def ha(args): len_local, neighbor_size = args['len_local'], args['neighbor_size'] main_input = [] neighbor_slide_len = neighbor_size * 2 + 1 stack_local_flow = \ Input(shape=(len_local * 2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='stack_local_flow') main_input.append(stack_local_flow) # merge layer ask the number greater than 1 if len_local == 1: output = main_input model = Model(inputs=main_input, outputs=output, name='HA') return model # average the stack def slice(inputs, channel): return inputs[:, channel:channel+1, :, :] outflow_list = [] inflow_list = [] for i in range(len_local): inflow_list.append(Lambda(slice, arguments={'channel':2*i})(stack_local_flow)) outflow_list.append(Lambda(slice, arguments={'channel': 2*i+1})(stack_local_flow)) inflow_ave = merge.Average()(inflow_list) outflow_ave = merge.Average()(outflow_list) output = merge.Concatenate(axis=1)([inflow_ave, outflow_ave]) model = Model(inputs=main_input, outputs=output, name='HA') return model
def __init__(self, hparams, fl): """ Initialises new linear SVM model based on input features_dim, labels_dim, hparams :param features_dim: Number of input feature nodes. Integer :param labels_dim: Number of output label nodes. Integer :param hparams: Dict containing hyperparameter information. Dict can be created using create_hparams() function. hparams includes: hidden_layers: List containing number of nodes in each hidden layer. [10, 20] means 10 then 20 nodes. """ self.features_dim = fl.features_c_dim self.features_d_count = fl.features_d_count self.labels_dim = fl.n_classes self.hparams = hparams self.fp_length = [ hparams['fp_length'] for _ in range(hparams['fp_number']) ] self.conv_width = [ hparams['conv_width'] for _ in range(hparams['conv_number']) ] # Left side lc = Input(shape=(fl.features_c_dim, )) left_features_d = [] left_conv_net = [] for idx in range(fl.features_d_count): # Creating left input tensors for features_d. # For each molecule # Make one input tensor for atoms, bond, edge tensor left_features_d.append([ Input(name='l_a_inputs_' + str(idx) + 'x', shape=fl.features_d_a[idx][0].shape[1:]), Input(name='l_b_inputs_' + str(idx) + 'y', shape=fl.features_d_a[idx][1].shape[1:]), Input(name='l_e_inputs_' + str(idx) + 'z', shape=fl.features_d_a[idx][2].shape[1:], dtype='int32') ]) # Building the left_conv_net for that particular molecule left_conv_net.append( build_graph_conv_net_fp_only(left_features_d[idx], conv_layer_sizes=self.conv_width, fp_layer_size=self.fp_length, conv_activation='relu', fp_activation='softmax')) # Concat left side 4 inputs. Unlike SNN, there is no right side. left_combined = merge.Concatenate()([lc] + left_conv_net) # Input concat vector into SVM prediction = Dense(2, activation='linear')(left_combined) self.model = Model(input=[lc] + [ left_tensor for molecule in left_features_d for left_tensor in molecule ], output=prediction) # SVM uses categorical hinge loss self.model.compile(optimizer='Adam', loss="categorical_hinge", metrics=['accuracy'])
def geo_lprnn_text_model(user_dim, len, place_dim=GRID_COUNT * GRID_COUNT, time_dim=config.time_dim, pl_d=config.pl_d, time_k=config.time_k, hidden_neurons=config.hidden_neurons, learning_rate=config.learning_rate): # RNN model construction pl_input = Input(shape=(len - 1, ), dtype='int32', name='pl_input') time_input = Input(shape=(len - 1, ), dtype='int32', name='time_input') user_input = Input(shape=(len - 1, ), dtype='int32', name='user_input') text_input = Input(shape=(len - 1, pl_d), dtype='float32', name='text_input') pl_embedding = Embedding(input_dim=place_dim + 1, output_dim=pl_d, name='pl_embedding', mask_zero=True)(pl_input) time_embedding = Embedding(input_dim=time_dim + 1, output_dim=time_k, name='time_embedding', mask_zero=True)(time_input) user_embedding = Embedding(input_dim=user_dim + 1, output_dim=place_dim + 1, name='user_embedding', mask_zero=True)(user_input) # text_embedding = Dense(pl_d)(text_input) attrs_latent = merge.Concatenate( [pl_embedding, time_embedding, text_input] ) # attrs_latent = merge([pl_embedding,time_embedding, text_input],mode='concat') # time_dist = TimeDistributed(Dense(50)) lstm_out = LSTM(hidden_neurons, return_sequences=True, name='lstm_layer')(attrs_latent) dense = Dense(place_dim + 1, name='dense')(lstm_out) out_vec = merge.Add( [dense, user_embedding]) # out_vec = merge([dense,user_embedding],mode='sum') pred = Activation('softmax')(out_vec) model = Model([pl_input, time_input, user_input, text_input], pred) # model.load_weights('./model/User_RNN_Seg_Epoch_0.3_rmsprop_300.h5') # Optimization sgd = optimizers.SGD(lr=learning_rate) rmsprop = optimizers.RMSprop(lr=learning_rate) model.compile(optimizer=rmsprop, loss='categorical_crossentropy') model.summary() return model
def build_model(tokenizer): embedding_model = word2vec.Word2Vec.load( 'D:/TSE/python/missplaceclass/embedding_model/new_model_1.bin') word_index = tokenizer.word_index nb_words = len(word_index) embedding_matrix = np.zeros((nb_words + 1, EMBEDDING_DIM)) for word, i in word_index.items(): if word == 'false': print(word) embedding_vector = embedding_model.wv[word] if embedding_vector is not None: embedding_matrix[i] = embedding_vector models = [] for i in range(MODEL_NUMBER): embedding_layer = Embedding(nb_words + 1, EMBEDDING_DIM, input_length=MAX_SEQUENCE_LENGTH, weights=[embedding_matrix], trainable=False) model_left = Sequential() model_left.add(embedding_layer) model_left.add(Conv1D(128, 1, padding="same", activation='tanh')) model_left.add(Conv1D(128, 1, activation='tanh')) model_left.add(Conv1D(128, 1, activation='tanh')) model_left.add(Flatten()) model_right = Sequential() model_right.add( Conv1D(128, 1, input_shape=(8, 1), padding="same", activation='tanh')) model_right.add(Conv1D(128, 1, activation='tanh')) model_right.add(Conv1D(128, 1, activation='tanh')) model_right.add(Flatten()) output = merge.Concatenate()([model_left.output, model_right.output]) output = Dense(128, activation='tanh')(output) output = Dense(1, activation='sigmoid')(output) input_left = model_left.input input_right = model_right.input model = Model([input_left, input_right], output) model.compile(loss='binary_crossentropy', optimizer='Adadelta', metrics=['accuracy']) models.append(model) return models
def _build_big_conv_nn(self, optimizer="adam"): """ Defines and compiles same CNN as J. Saxe et al. - eXpose: A Character-Level Convolutional Neural Network with Embeddings For Detecting Malicious URLs, File Paths and Registry Keys. Parameters ---------- optimizer: Optimizer algorithm """ main_input = Input(shape=(self.max_length, ), dtype='int32', name='main_input') embedding = Embedding(input_dim=self.vocab_size, output_dim=32, input_length=self.max_length, dropout=0)(main_input) conv1 = self._get_complete_conv_layer(2, 256)(embedding) conv2 = self._get_complete_conv_layer(3, 256)(embedding) conv3 = self._get_complete_conv_layer(4, 256)(embedding) conv4 = self._get_complete_conv_layer(5, 256)(embedding) merged = merge.Concatenate()([conv1, conv2, conv3, conv4]) merged = BatchNormalization()(merged) middle = Dense(1024, activation='relu')(merged) middle = BatchNormalization()(middle) middle = Dropout(0.5)(middle) middle = Dense(1024, activation='relu')(middle) middle = BatchNormalization()(middle) middle = Dropout(0.5)(middle) middle = Dense(1024, activation='relu')(middle) middle = BatchNormalization()(middle) middle = Dropout(0.5)(middle) output = Dense(1, activation='sigmoid')(middle) self.model = Model(input=main_input, output=output) self.model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['acc', self.f1]) print(self.model.summary())
def build_cell(self, modeltype): """ build lstm or gru cell """ if modeltype == 'lstm': # kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', # not zeros # rnn_out_f = LSTM(self.hidden_layer_size, input_shape=(self.length ,self.n_features), use_bias=True, activation=self.activation, dropout=self.output_dropout, recurrent_dropout=self.input_dropout, )(self.feature) # rnn_out_b = LSTM(self.hidden_layer_size, input_shape=(self.length ,self.n_features), use_bias=True, activation=self.activation, dropout=self.output_dropout, recurrent_dropout=self.input_dropout, go_backwards=True)(self.feature) #zeros failing spontaneously. rnn_out_f = CuDNNLSTM( self.hidden_layer_size, input_shape=(self.length, self.n_features), )(self.feature) rnn_out_b = CuDNNLSTM(self.hidden_layer_size, input_shape=(self.length, self.n_features), go_backwards=True)(self.feature) #zeros # rnn_cell=tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(self.hidden_layer_size) # rnn_cell_bw=tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(self.hidden_layer_size) #zeros # rnn_cell=tf.contrib.cudnn_rnn.CudnnLSTM(1, self.hidden_layer_size, dropout=self.output_dropout, kernel_initializer=tf.glorot_uniform_initializer(), bias_initializer='zeros', direction='bidirectional') # rnn_cell_bw=tf.contrib.cudnn_rnn.CudnnLSTM(1, self.hidden_layer_size, dropout=self.output_dropout, kernel_initializer=tf.glorot_uniform_initializer(), bias_initializer='zeros', direction='bidirectional') # rnn_cell=tf.keras.layers.LSTMCell(self.hidden_layer_size, activation=self.activation) elif modeltype == 'gru': rnn_out_f = CuDNNGRU( self.hidden_layer_size, input_shape=(self.length, self.n_features), )(self.feature) rnn_out_b = CuDNNGRU(self.hidden_layer_size, input_shape=(self.length, self.n_features), go_backwards=True)(self.feature) else: raise ('Unknown modeltype for RNN') # self.rnn_cell=tf.nn.rnn_cell.DropoutWrapper(rnn_cell, input_keep_prob=1.0-self.input_dropout, output_keep_prob=1.0-self.output_dropout) # self.rnn_cell_bw=tf.nn.rnn_cell.DropoutWrapper(rnn_cell_bw, input_keep_prob=1.0-self.input_dropout, output_keep_prob=1.0-self.output_dropout) self.rnn_cell = merge.Concatenate(axis=-1)([rnn_out_f, rnn_out_b]) self.rnn_cell = Dropout(self.output_dropout)(self.rnn_cell)
def Spatial_attention(x, name, kernel_size=7): assert kernel_size in (3, 7), 'kernel_size must be 3 or 7' # padding = 3 if kernel_size==7 else 1 avg_out = Lambda(lambda y: K.mean(y, axis=3, keepdims=True), name=f'{name}_avgpool')(x) # (B, W, H, 1) max_out = Lambda(lambda y: K.max(x, axis=3, keepdims=True), name=f'{name}_maxpool')(x) # (B, W, H, 1) out = merge.Concatenate(name=f'{name}_concat')([avg_out, max_out]) # (B, W, H, 2) out = Conv2D(1, kernel_size, padding='same', name=f'{name}_conv', activation='sigmoid')(out) x = Multiply(name=f'{name}_mul')([out, x]) return x
def build_model(): GLOVE_STORE = 'nli_precomputed_glove.weights' if USE_GLOVE: if not os.path.exists(GLOVE_STORE + '.npy'): print('Computing GloVe') embeddings_index = {} f = open(GLOVE_FILE_PATH) for line in f: values = line.split(' ') word = values[0] coefs = np.asarray(values[1:], dtype='float32') embeddings_index[word] = coefs f.close() # prepare embedding matrix embedding_matrix = np.zeros((VOCAB, EMBED_HIDDEN_SIZE)) for word, i in tokenizer.word_index.items(): embedding_vector = embeddings_index.get(word) if embedding_vector is not None: # words not found in embedding index will be all-zeros. embedding_matrix[i] = embedding_vector else: print('Missing from GloVe: {}'.format(word)) np.save(GLOVE_STORE, embedding_matrix) print('Loading GloVe') embedding_matrix = np.load(GLOVE_STORE + '.npy') print('Total number of null word embeddings:') print(np.sum(np.sum(embedding_matrix, axis=1) == 0)) embed = Embedding(VOCAB, EMBED_HIDDEN_SIZE, weights=[embedding_matrix], input_length=MAX_LEN, trainable=TRAIN_EMBED) else: embed = Embedding(VOCAB, EMBED_HIDDEN_SIZE, input_length=MAX_LEN) rnn_kwargs = dict(output_dim=SENT_HIDDEN_SIZE, dropout_W=DP, dropout_U=DP) SumEmbeddings = keras.layers.core.Lambda(lambda x: K.sum(x, axis=1), output_shape=(SENT_HIDDEN_SIZE, )) translate = TimeDistributed(Dense(SENT_HIDDEN_SIZE, activation=ACTIVATION)) premise = Input(shape=(MAX_LEN, ), dtype='int32') hypothesis = Input(shape=(MAX_LEN, ), dtype='int32') prem = embed(premise) hypo = embed(hypothesis) prem = translate(prem) hypo = translate(hypo) if RNN and LAYERS > 1: for l in range(LAYERS - 1): rnn = RNN(return_sequences=True, **rnn_kwargs) prem = BatchNormalization()(rnn(prem)) hypo = BatchNormalization()(rnn(hypo)) rnn = SumEmbeddings if not RNN else RNN(return_sequences=False, **rnn_kwargs) prem = rnn(prem) hypo = rnn(hypo) prem = BatchNormalization()(prem) hypo = BatchNormalization()(hypo) joint = merge.Concatenate()([prem, hypo]) joint = Dropout(DP)(joint) for i in range(3): joint = Dense(2 * SENT_HIDDEN_SIZE, activation=ACTIVATION, W_regularizer=l2(L2) if L2 else None)(joint) joint = Dropout(DP)(joint) joint = BatchNormalization()(joint) pred = Dense(len(LABELS), activation='softmax')(joint) model = Model(input=[premise, hypothesis], output=pred) model.compile(optimizer=OPTIMIZER, loss='categorical_crossentropy', metrics=['accuracy']) return model
def __init__(self, SNN_hparams, fl): self.hparams = SNN_hparams self.features_c_dim = fl.features_c_dim self.features_d_count = fl.features_d_count self.fp_length = [ SNN_hparams['fp_length'] for _ in range(SNN_hparams['fp_number']) ] self.conv_width = [ SNN_hparams['conv_width'] for _ in range(SNN_hparams['conv_number']) ] # Left side lc = Input(shape=(fl.features_c_dim, )) left_features_d = [] left_conv_net = [] for idx in range(fl.features_d_count): # Creating left input tensors for features_d. # For each molecule # Make one input tensor for atoms, bond, edge tensor left_features_d.append([ Input(name='l_a_inputs_' + str(idx) + 'x', shape=fl.features_d_a[idx][0].shape[1:]), Input(name='l_b_inputs_' + str(idx) + 'y', shape=fl.features_d_a[idx][1].shape[1:]), Input(name='l_e_inputs_' + str(idx) + 'z', shape=fl.features_d_a[idx][2].shape[1:], dtype='int32') ]) # Building the left_conv_net for that particular molecule left_conv_net.append( build_graph_conv_net_fp_only(left_features_d[idx], conv_layer_sizes=self.conv_width, fp_layer_size=self.fp_length, conv_activation='relu', fp_activation='softmax')) # Right side rc = Input(shape=(fl.features_c_dim, )) right_features_d = [] right_conv_net = [] for idx in range(fl.features_d_count): # Same as left side. Just change left to right. right_features_d.append([ Input(name='r_a_inputs_' + str(idx) + 'x', shape=fl.features_d_a[idx][0].shape[1:]), Input(name='r_b_inputs_' + str(idx) + 'y', shape=fl.features_d_a[idx][1].shape[1:]), Input(name='r_e_inputs_' + str(idx) + 'z', shape=fl.features_d_a[idx][2].shape[1:], dtype='int32') ]) right_conv_net.append( build_graph_conv_net_fp_only(right_features_d[idx], conv_layer_sizes=self.conv_width, fp_layer_size=self.fp_length, conv_activation='relu', fp_activation='softmax')) # Concat left side 4 inputs and right side 4 inputs left_combined = merge.Concatenate()([lc] + left_conv_net) right_combined = merge.Concatenate()([rc] + right_conv_net) encoded_l = self.singlenet()(left_combined) encoded_r = self.singlenet()(right_combined) # layer to merge two encoded inputs with the l1 distance between them L1_layer = Lambda(lambda tensors: K.abs(tensors[0] - tensors[1])) # call this layer on list of two input tensors. L1_distance = L1_layer([encoded_l, encoded_r]) prediction = Dense(1, activation='sigmoid')(L1_distance) self.siamese_net = Model(input=[lc] + [ left_tensor for molecule in left_features_d for left_tensor in molecule ] + [rc] + [ right_tensor for molecule in right_features_d for right_tensor in molecule ], output=prediction) if self.hparams.get('learning_rate', None) is None: self.siamese_net.compile(loss='binary_crossentropy', optimizer=self.hparams['optimizer']) else: sgd = optimizers.Adam(lr=self.hparams['learning_rate']) self.siamese_net.compile(loss='binary_crossentropy', optimizer=sgd)
def __init__(self, SNN_hparams, fl): self.hparams = SNN_hparams self.features_c_dim = fl.features_c_dim self.features_d_count = fl.features_d_count self.fp_length = [ SNN_hparams['fp_length'] for _ in range(SNN_hparams['fp_number']) ] self.conv_width = [ SNN_hparams['conv_width'] for _ in range(SNN_hparams['conv_number']) ] # First step: SMILES ==> fingerprint vector # Defining fingerprint(fp) model half_features_d = [] half_conv_net = [] for idx in range(fl.features_d_count): # Creating left input tensors for features_d. # For each molecule # Make one input tensor for atoms, bond, edge tensor half_features_d.append([ Input(name='h_a_inputs_' + str(idx) + 'x', shape=fl.features_d_a[idx][0].shape[1:]), Input(name='h_b_inputs_' + str(idx) + 'y', shape=fl.features_d_a[idx][1].shape[1:]), Input(name='h_e_inputs_' + str(idx) + 'z', shape=fl.features_d_a[idx][2].shape[1:], dtype='int32') ]) single_molecule = half_features_d[-1] # Building the half_conv_net for that particular molecule single_molecule_half_conv_net = build_graph_conv_net_fp_only( single_molecule, conv_layer_sizes=self.conv_width, fp_layer_size=self.fp_length, conv_activation=self.hparams['conv_activation'], conv_l1=self.hparams['conv_l1'], conv_l2=self.hparams['conv_l2'], fp_activation='softmax') single_molecule_half_conv_net_model = Model( name='h_fp_' + str(idx), inputs=single_molecule, outputs=single_molecule_half_conv_net) half_conv_net.append(single_molecule_half_conv_net_model) # Second step: Concat features_c and fingerprint vectors ==> form intermediate input vector (IIV) # IIV put into single SNN net # Defining half_model_model half_c = Input(shape=(fl.features_c_dim, )) half_fp = [ Input(shape=(self.fp_length[0], )) for _ in range(fl.features_d_count) ] # Concat left side 4 inputs and right side 4 inputs half_combined = merge.Concatenate()([half_c] + half_fp) # singlenet for the SNN. Same weights and biases for top and bottom half of SNN singlenet = Sequential() hidden_layers = self.hparams['hidden_layers'] numel = len(hidden_layers) generator_dropout = self.hparams.get('dropout', 0) singlenet.add( Dense(hidden_layers[0], input_dim=self.features_c_dim + self.features_d_count * self.hparams['fp_length'], activation=self.hparams['activation'], kernel_regularizer=regularizers.L1L2( l1=self.hparams['singlenet_l1'], l2=self.hparams['singlenet_l2']))) if generator_dropout != 0: singlenet.add(Dropout(generator_dropout)) if numel > 1: if hidden_layers[ 1] != 0: # Even if hidden layers has 2 elements, 2nd element may be 0 for i in range(numel - 1): singlenet.add( Dense(hidden_layers[i + 1], activation=self.hparams['activation'], kernel_regularizer=regularizers.L1L2( l1=self.hparams['singlenet_l1'], l2=self.hparams['singlenet_l2']))) singlenet.add( Dense(self.hparams.get('feature_vector_dim', 10), activation='sigmoid')) # Output of half_model encoded_half = singlenet(half_combined) # Make half_model callable half_model = Model(name='half_model_encoded', input=[half_c] + half_fp, output=encoded_half) # All steps together by calling the above models one after another. # fp model ==> half_model ==> L1 distance and final node model lc = Input(name='left_c', shape=(fl.features_c_dim, )) left_features_d = [] left_fp_model = [] rc = Input(name='right_c', shape=(fl.features_c_dim, )) right_features_d = [] right_fp_model = [] for idx in range(fl.features_d_count): # a = atom tensor, b = bond tensor, e = edge tensor left_features_d.append([ Input(name='l_a_inputs_' + str(idx) + 'x', shape=fl.features_d_a[idx][0].shape[1:]), Input(name='l_b_inputs_' + str(idx) + 'y', shape=fl.features_d_a[idx][1].shape[1:]), Input(name='l_e_inputs_' + str(idx) + 'z', shape=fl.features_d_a[idx][2].shape[1:], dtype='int32') ]) # Call fp model for each set of left molecules left_fp_model.append(half_conv_net[idx](left_features_d[-1])) # Same as left side. Just change left to right. right_features_d.append([ Input(name='r_a_inputs_' + str(idx) + 'x', shape=fl.features_d_a[idx][0].shape[1:]), Input(name='r_b_inputs_' + str(idx) + 'y', shape=fl.features_d_a[idx][1].shape[1:]), Input(name='r_e_inputs_' + str(idx) + 'z', shape=fl.features_d_a[idx][2].shape[1:], dtype='int32') ]) # Call fp model for each set of right molecules right_fp_model.append(half_conv_net[idx](right_features_d[-1])) # Apply half_model to left and right side encoded_l = half_model([lc] + left_fp_model) encoded_r = half_model([rc] + right_fp_model) # layer to merge two encoded inputs with the l1 distance between them L1_layer = Lambda(lambda tensors: K.abs(tensors[0] - tensors[1])) # call this layer on list of two input tensors. L1_distance = L1_layer([encoded_l, encoded_r]) prediction = Dense(1, activation='sigmoid')(L1_distance) self.siamese_net = Model(name='final_model', input=[lc] + [ left_tensor for molecule in left_features_d for left_tensor in molecule ] + [rc] + [ right_tensor for molecule in right_features_d for right_tensor in molecule ], output=prediction) if self.hparams.get('learning_rate', None) is None: self.siamese_net.compile(loss='binary_crossentropy', optimizer=self.hparams['optimizer']) else: sgd = optimizers.Adam(lr=self.hparams['learning_rate']) self.siamese_net.compile(loss='binary_crossentropy', optimizer=sgd)
embedding_layer = Embedding(len(word_index) + 1, EMBEDDING_DIM, weights=[embedding_matrix], input_length=MAX_SEQUENCE_LENGTH, trainable=False) sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH, ), dtype='int32') embedded_sequences = embedding_layer(sequence_input) for fsz in filter_sizes: l_conv = Conv1D(nb_filter=128, filter_length=fsz, activation='relu')(embedded_sequences) l_pool = MaxPooling1D(5)(l_conv) convs.append(l_pool) l_merge = merge.Concatenate(axis=1)(convs) l_cov1 = Conv1D(128, 5, activation='relu')(l_merge) l_pool1 = MaxPooling1D(5)(l_cov1) l_cov2 = Conv1D(128, 5, activation='relu')(l_pool1) l_pool2 = MaxPooling1D(30)(l_cov2) l_flat = Flatten()(l_pool2) l_dense = Dense(128, activation='relu')(l_flat) preds = Dense(2, activation='softmax')(l_dense) model = Model(sequence_input, preds) checkpointer = ModelCheckpoint(filepath="weights.hdf5", verbose=1, save_best_only=True) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=["accuracy", f1])
def train():#select optional model for kk in range(len(projects)):#len(projects) ss=time.time() print("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") print(projects[kk]) print("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&") distances = [] # TrainSet labels = [] # 0/1 texts = [] # ClassNameAndMethodName MAX_SEQUENCE_LENGTH = 15 EMBEDDING_DIM = 200 # Dimension of word vector embedding_model=word2vec.Word2Vec.load(basepath+"new_model.bin") with open(basepath+"data_compare/"+projects[kk]+"/train_Distances.txt",'r') as file_to_read: #with open("D:/data/7#Fold/train-weka"+"/train_distances.txt",'r') as file_to_read: for line in file_to_read.readlines(): values = line.split() distance = values[:2] distances.append(distance) label =values[2:] labels.append(label) with open(basepath+"data_compare/"+projects[kk]+"/train_Names.txt",'r') as file_to_read: #with open("D:/data/7#Fold/train-weka"+"/train_names.txt",'r') as file_to_read: for line in file_to_read.readlines(): texts.append(line) print('Found %s train_distances.' % len(distances)) tokenizer = Tokenizer(num_words=None) tokenizer.fit_on_texts(texts) sequences = tokenizer.texts_to_sequences(texts) word_index = tokenizer.word_index data = pad_sequences(sequences, maxlen=MAX_SEQUENCE_LENGTH) distances = np.asarray(distances) labels = to_categorical(np.asarray(labels)) print('Shape of train_data tensor:', data.shape) print('Shape of train_label tensor:', labels.shape) x_train = [] x_train_names = data x_train_dis = distances x_train_dis = np.expand_dims(x_train_dis, axis=2) x_train.append(x_train_names) x_train.append(np.array(x_train_dis)) y_train = np.array(labels) for index in range(model_num):######################## print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") print(projects[kk],'---',index+1) print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") print ("start time: "+time.strftime("%Y/%m/%d %H:%M:%S")) x_train,y_train=getsubset(x_train,y_train) nb_words = len(word_index) embedding_matrix = np.zeros((nb_words+1, EMBEDDING_DIM)) for word, i in word_index.items(): embedding_vector = embedding_model.wv[word] if embedding_vector is not None: embedding_matrix[i] = embedding_vector embedding_layer = Embedding(nb_words + 1, EMBEDDING_DIM, input_length=MAX_SEQUENCE_LENGTH, weights=[embedding_matrix], trainable=False) print('Training model.') model_left = Sequential() model_left.add(embedding_layer) model_left.add(Conv1D(128, 1, padding = "same", activation='tanh')) model_left.add(Conv1D(128, 1, activation='tanh')) model_left.add(Conv1D(128, 1, activation='tanh')) model_left.add(Flatten()) model_right = Sequential() model_right.add(Conv1D(128, 1, input_shape=(2,1), padding = "same", activation='tanh')) model_right.add(Conv1D(128, 1, activation='tanh')) model_right.add(Conv1D(128, 1, activation='tanh')) model_right.add(Flatten()) output = merge.Concatenate()([model_left.output, model_right.output]) output=Dense(128, activation='tanh')(output) output=Dense(2,activation='sigmoid')(output) input_left=model_left.input input_right=model_right.input model=Model([input_left,input_right],output) model.compile(loss='binary_crossentropy',optimizer='Adadelta',metrics=['accuracy']) model.fit(x_train, y_train,epochs=3,verbose=2) #json_string = model.to_json() #open(basepath+"models_compare/"+projects[kk]+"_"+str(index)+".json",'w').write(json_string) #model.save_weights(basepath+"models_compare/"+projects[kk]+"_"+str(index)+'.h5') print('########################',time.time()-ss)
def stdn(args): att_lstm_num, att_lstm_seq_len, lstm_seq_len, neighbor_size, external_dim = \ args['att_lstm_num'], args['att_lstm_seq_len'], args['lstm_seq_len'], \ args['neighbor_size'], args['external_dim'] slide_len = neighbor_size * 2 + 1 flatten_att_nbhd_inputs = [ Input(shape=(2, slide_len, slide_len), name="att_nbhd_volume_input_time_{0}_{1}".format( att + 1, ts + 1)) for ts in range(att_lstm_seq_len) for att in range(att_lstm_num) ] flatten_att_flow_inputs = [ Input(shape=(2, slide_len, slide_len), name="att_flow_volume_input_time_{0}_{1}".format( att + 1, ts + 1)) for ts in range(att_lstm_seq_len) for att in range(att_lstm_num) ] # take out the corresponding local and flow data for attention att_nbhd_inputs = [] att_flow_inputs = [] for att in range(att_lstm_num): att_nbhd_inputs.append( flatten_att_nbhd_inputs[att * att_lstm_seq_len:(att + 1) * att_lstm_seq_len]) att_flow_inputs.append( flatten_att_flow_inputs[att * att_lstm_seq_len:(att + 1) * att_lstm_seq_len]) # external data for attention, holiday and weather att_lstm_inputs = [ Input(shape=(att_lstm_seq_len, external_dim), name="att_lstm_input_{0}".format(att + 1)) for att in range(att_lstm_num) ] # local, flow, external data for local cnn nbhd_inputs = [ Input(shape=(2, slide_len, slide_len), name="nbhd_volume_input_time_{0}".format(ts + 1)) for ts in range(lstm_seq_len) ] # include many sequence flow_inputs = [ Input(shape=(2, slide_len, slide_len), name="flow_volume_input_time_{0}".format(ts + 1)) for ts in range(lstm_seq_len) ] lstm_inputs = Input(shape=(lstm_seq_len, external_dim), name="lstm_input") # short-term part, repeat three times # conv (local + flow) data --> Multiply fuse nbhd_convs = [ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="nbhd_convs_time0_{0}".format(ts + 1))(nbhd_inputs[ts]) for ts in range(lstm_seq_len) ] # Conv for different interval in current nbhd_convs = [ Activation("relu", name="nbhd_convs_activation_time0_{0}".format(ts + 1))( nbhd_convs[ts]) for ts in range(lstm_seq_len) ] flow_convs = [ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="flow_convs_time0_{0}".format(ts + 1))(flow_inputs[ts]) for ts in range(lstm_seq_len) ] # Conv for past l(2) interval for flow gate flow_convs = [ Activation("relu", name="flow_convs_activation_time0_{0}".format(ts + 1))( flow_convs[ts]) for ts in range(lstm_seq_len) ] flow_gates = [ Activation("sigmoid", name="flow_gate0_{0}".format(ts + 1))(flow_convs[ts]) for ts in range(lstm_seq_len) ] # use sigmoid to scale the range of flow conv into (0, 1) nbhd_convs = [ keras.layers.Multiply()([nbhd_convs[ts], flow_gates[ts]]) for ts in range(lstm_seq_len) ] # Multiply local and flow # 2nd level gate nbhd_convs = [ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="nbhd_convs_time1_{0}".format(ts + 1))(nbhd_convs[ts]) for ts in range(lstm_seq_len) ] # ! here we use nbhd_convs(the result of first level) nbhd_convs = [ Activation("relu", name="nbhd_convs_activation_time1_{0}".format(ts + 1))( nbhd_convs[ts]) for ts in range(lstm_seq_len) ] flow_convs = [ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="flow_convs_time1_{0}".format(ts + 1))(flow_inputs[ts]) for ts in range(lstm_seq_len) ] # flow input contai flow_convs = [ Activation("relu", name="flow_convs_activation_time1_{0}".format(ts + 1))( flow_convs[ts]) for ts in range(lstm_seq_len) ] flow_gates = [ Activation("sigmoid", name="flow_gate1_{0}".format(ts + 1))(flow_convs[ts]) for ts in range(lstm_seq_len) ] nbhd_convs = [ keras.layers.Multiply()([nbhd_convs[ts], flow_gates[ts]]) for ts in range(lstm_seq_len) ] # 3rd level gate nbhd_convs = [ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="nbhd_convs_time2_{0}".format(ts + 1))(nbhd_convs[ts]) for ts in range(lstm_seq_len) ] nbhd_convs = [ Activation("relu", name="nbhd_convs_activation_time2_{0}".format(ts + 1))( nbhd_convs[ts]) for ts in range(lstm_seq_len) ] flow_convs = [ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="flow_convs_time2_{0}".format(ts + 1))(flow_inputs[ts]) for ts in range(lstm_seq_len) ] flow_convs = [ Activation("relu", name="flow_convs_activation_time2_{0}".format(ts + 1))( flow_convs[ts]) for ts in range(lstm_seq_len) ] flow_gates = [ Activation("sigmoid", name="flow_gate2_{0}".format(ts + 1))(flow_convs[ts]) for ts in range(lstm_seq_len) ] nbhd_convs = [ keras.layers.Multiply()([nbhd_convs[ts], flow_gates[ts]]) for ts in range(lstm_seq_len) ] # dense part nbhd_vecs = [ Flatten(name="nbhd_flatten_time_{0}".format(ts + 1))(nbhd_convs[ts]) for ts in range(lstm_seq_len) ] nbhd_vecs = [ Dense(units=128, name="nbhd_dense_time_{0}".format(ts + 1))(nbhd_vecs[ts]) for ts in range(lstm_seq_len) ] nbhd_vecs = [ Activation("relu", name="nbhd_dense_activation_time_{0}".format(ts + 1))( nbhd_vecs[ts]) for ts in range(lstm_seq_len) ] # feature concatenate nbhd_vec = merge.Concatenate(axis=-1)(nbhd_vecs) nbhd_vec = Reshape(target_shape=(lstm_seq_len, 128))(nbhd_vec) lstm_input = merge.Concatenate(axis=-1)( [lstm_inputs, nbhd_vec]) # lstm_input: external data, nbhd_vec: cnn flatten result # lstm: the result of current interval lstm = LSTM(units=128, return_sequences=False, dropout=0.1, recurrent_dropout=0.1)(lstm_input) # attention part, repeat 3 times # # conv (local + flow) data --> Multiply fuse att_nbhd_convs = [[ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="att_nbhd_convs_time0_{0}_{1}".format(att + 1, ts + 1))( att_nbhd_inputs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] # att local conv att_nbhd_convs = [[ Activation("relu", name="att_nbhd_convs_activation_time0_{0}_{1}".format( att + 1, ts + 1))(att_nbhd_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_flow_convs = [[ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="att_flow_convs_time0_{0}_{1}".format(att + 1, ts + 1))( att_flow_inputs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] # att flow att_flow_convs = [[ Activation("relu", name="att_flow_convs_activation_time0_{0}_{1}".format( att + 1, ts + 1))(att_flow_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_flow_gates = [[ Activation("sigmoid", name="att_flow_gate0_{0}_{1}".format(att + 1, ts + 1))( att_flow_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] # att flow gate att_nbhd_convs = [[ keras.layers.Multiply()( [att_nbhd_convs[att][ts], att_flow_gates[att][ts]]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] # multiply to fuse local and flow gate att_nbhd_convs = [[ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="att_nbhd_convs_time1_{0}_{1}".format(att + 1, ts + 1))( att_nbhd_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] # ! note the input att_nbhd_convs = [[ Activation("relu", name="att_nbhd_convs_activation_time1_{0}_{1}".format( att + 1, ts + 1))(att_nbhd_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_flow_convs = [[ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="att_flow_convs_time1_{0}_{1}".format(att + 1, ts + 1))( att_flow_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_flow_convs = [[ Activation("relu", name="att_flow_convs_activation_time1_{0}_{1}".format( att + 1, ts + 1))(att_flow_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_flow_gates = [[ Activation("sigmoid", name="att_flow_gate1_{0}_{1}".format(att + 1, ts + 1))( att_flow_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_nbhd_convs = [[ keras.layers.Multiply()( [att_nbhd_convs[att][ts], att_flow_gates[att][ts]]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_nbhd_convs = [[ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="att_nbhd_convs_time2_{0}_{1}".format(att + 1, ts + 1))( att_nbhd_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_nbhd_convs = [[ Activation("relu", name="att_nbhd_convs_activation_time2_{0}_{1}".format( att + 1, ts + 1))(att_nbhd_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_flow_convs = [[ Conv2D(filters=64, kernel_size=(3, 3), padding="same", name="att_flow_convs_time2_{0}_{1}".format(att + 1, ts + 1))( att_flow_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_flow_convs = [[ Activation("relu", name="att_flow_convs_activation_time2_{0}_{1}".format( att + 1, ts + 1))(att_flow_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_flow_gates = [[ Activation("sigmoid", name="att_flow_gate2_{0}_{1}".format(att + 1, ts + 1))( att_flow_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_nbhd_convs = [[ keras.layers.Multiply()( [att_nbhd_convs[att][ts], att_flow_gates[att][ts]]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] # reshape cnn into (att_lstm_seq_len, 128), # then concatenate with lstm_input(external data)--> every day data att_nbhd_vecs = [[ Flatten(name="att_nbhd_flatten_time_{0}_{1}".format(att + 1, ts + 1))( att_nbhd_convs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_nbhd_vecs = [[ Dense(units=128, name="att_nbhd_dense_time_{0}_{1}".format(att + 1, ts + 1))( att_nbhd_vecs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_nbhd_vecs = [[ Activation("relu", name="att_nbhd_dense_activation_time_{0}_{1}".format( att + 1, ts + 1))(att_nbhd_vecs[att][ts]) for ts in range(att_lstm_seq_len) ] for att in range(att_lstm_num)] att_nbhd_vec = [ merge.Concatenate(axis=-1)(att_nbhd_vecs[att]) for att in range(att_lstm_num) ] att_nbhd_vec = [ Reshape(target_shape=(att_lstm_seq_len, 128))(att_nbhd_vec[att]) for att in range(att_lstm_num) ] att_lstm_input = [ merge.Concatenate(axis=-1)([att_lstm_inputs[att], att_nbhd_vec[att]]) for att in range(att_lstm_num) ] # attention part : every day data --> lstm att_lstms = [ LSTM(units=128, return_sequences=True, dropout=0.1, recurrent_dropout=0.1, name="att_lstm_{0}".format(att + 1))(att_lstm_input[att]) for att in range(att_lstm_num) ] print('Before') # compare att_low_level = [ Attention()([att_lstms[att], lstm]) for att in range(att_lstm_num) ] att_low_level = merge.Concatenate(axis=-1)(att_low_level) att_low_level = Reshape(target_shape=(att_lstm_num, 128))(att_low_level) print('After') att_high_level = LSTM(units=128, return_sequences=False, dropout=0.1, recurrent_dropout=0.1)(att_low_level) lstm_all = merge.Concatenate(axis=-1)([att_high_level, lstm]) lstm_all = Dense(units=2 * slide_len * slide_len)(lstm_all) lstm_all = Reshape((2, slide_len, slide_len))(lstm_all) pred_volume = Activation('tanh')(lstm_all) # every input is a list, only be this way inputs = \ flatten_att_nbhd_inputs + flatten_att_flow_inputs + att_lstm_inputs + nbhd_inputs + flow_inputs + [lstm_inputs] # flatten_att_nbhd_inputs: (att_lstm_num * att_lstm_seq_len, 2, slide_len, slide_len) # flatten_att_flow_inputs: (att_lstm_num * att_lstm_seq_len, 2, slide_len, slide_len) # att_lstm_inputs: (att_lstm_num, att_lstm_seq_len, 18) # nbhd_inputs: (lstm_seq_len, 2, slide_len, slide_len) # flow_inputs: (lstm_seq_len, 2, slide_len, slide_len) # lstm_inputs: (lstm_seq_len, 18) print('flatten_att_nbhd_inputs:', att_lstm_num * att_lstm_seq_len, 2, slide_len, slide_len) print('flatten_att_flow_inputs:', att_lstm_num * att_lstm_seq_len, 2, slide_len, slide_len) print('att_lstm_inputs:', att_lstm_num, att_lstm_seq_len, 18) print('nbhd_inputs:', lstm_seq_len, 2, slide_len, slide_len) print('flow_inputs:', lstm_seq_len, 2, slide_len, slide_len) print('lstm_inputs:', lstm_seq_len, 18) model = Model(inputs=inputs, outputs=pred_volume) return model
meta_input = Input(shape=data.x_train.shape[1:]) meta_hidden_layer = Dense(50)(meta_input) meta_hidden_activation = LeakyReLU()(meta_hidden_layer) meta = Dense(30)(meta_hidden_activation) meta = LeakyReLU()(meta) # ## Concatenate # In[38]: flatten1 = Flatten()(user_activity_stream) flatten2 = Flatten()(sys_activity_stream) concat_layer = merge.Concatenate(axis=-1)([flatten1, flatten2, meta]) # ## Merging MLP layer # In[39]: mlp_layer1 = Dense(380, input_shape=())(concat_layer) mlp_activ1 = LeakyReLU()(mlp_layer1) mlp_layer2 = Dense(450)(mlp_activ1) mlp_activ2 = LeakyReLU()(mlp_layer2) mlp_layer3 = Dense(260)(mlp_activ2) mlp_activ3 = LeakyReLU()(mlp_layer3) mlp_layer4 = Dense(200)(mlp_activ3)
def tcn(args): len_global, len_local, neighbor_size, is_BN, nb_res_unit, num_cnn, num_tcn, nb_stacks, dataset, width, height = \ args['len_global'], args['len_local'], args['neighbor_size'], args['is_BN'], \ args['nb_res_unit'], args['num_cnn'], args['num_tcn'], args['nb_stacks'], \ args['dataset'], args['width'], args['height'] main_input = [] neighbor_slide_len = neighbor_size * 2 + 1 local_feature_list = [] # ============================== # deal with the global local external data if dataset == 'bj_taxi': g_vacation = Input(shape=(len_global, ), dtype='int32', name='g_vacation') g_hour = Input(shape=(len_global, ), dtype='int32', name='g_hour') g_dayOfWeek = Input(shape=(len_global, ), dtype='int32', name='g_dayOfWeek') g_weather = Input(shape=(len_global, ), dtype='int32', name='g_weather') g_continuous_external = Input(shape=(len_global, 2), dtype='float32', name='g_continuous_external') main_input.append(g_vacation) main_input.append(g_hour) main_input.append(g_dayOfWeek) main_input.append(g_weather) main_input.append(g_continuous_external) embed_g_holiday = Embedding(output_dim=2, input_dim=2, input_length=len_global)(g_vacation) embed_g_hour = Embedding(output_dim=2, input_dim=25, input_length=len_global)(g_hour) embed_g_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_global)(g_dayOfWeek) embed_g_weather = Embedding(output_dim=2, input_dim=17, input_length=len_global)(g_weather) g_external = merge.Concatenate(axis=-1)([ embed_g_holiday, embed_g_hour, embed_g_dayOfWeek, embed_g_weather, g_continuous_external ]) else: g_hour = Input(shape=(len_global, ), dtype='int32', name='g_hour') g_dayOfWeek = Input(shape=(len_global, ), dtype='int32', name='g_dayOfWeek') main_input.append(g_hour) main_input.append(g_dayOfWeek) embed_g_hour = Embedding(output_dim=2, input_dim=25, input_length=len_global)(g_hour) embed_g_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_global)(g_dayOfWeek) g_external = merge.Concatenate(axis=-1)( [embed_g_hour, embed_g_dayOfWeek]) g_out = Flatten()(g_external) g_out = Dense(units=50)(g_out) g_out = Dropout(rate=0.1)(g_out) g_out = Activation('relu')(g_out) g_out = Dense(units=2 * width * height)(g_out) g_out = Activation('relu')(g_out) feature_external_g = Reshape((2, width, height))(g_out) # ============================== # deal with the local external data if dataset == 'bj_taxi': t_vacation = Input(shape=(len_local, ), dtype='int32', name='t_vacation') t_hour = Input(shape=(len_local, ), dtype='int32', name='t_hour') t_dayOfWeek = Input(shape=(len_local, ), dtype='int32', name='t_dayOfWeek') t_weather = Input(shape=(len_local, ), dtype='int32', name='t_weather') t_continuous_external = Input(shape=(len_local, 2), dtype='float32', name='t_continuous_external') main_input.append(t_vacation) main_input.append(t_hour) main_input.append(t_dayOfWeek) main_input.append(t_weather) main_input.append(t_continuous_external) embed_t_holiday = Embedding(output_dim=2, input_dim=2, input_length=len_local)(t_vacation) embed_t_hour = Embedding(output_dim=2, input_dim=25, input_length=len_local)(t_hour) embed_t_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_local)(t_dayOfWeek) embed_t_weather = Embedding(output_dim=2, input_dim=17, input_length=len_local)(t_weather) t_external = merge.Concatenate(axis=-1)([ embed_t_holiday, embed_t_hour, embed_t_dayOfWeek, embed_t_weather, t_continuous_external ]) else: t_hour = Input(shape=(len_local, ), dtype='int32', name='t_hour') t_dayOfWeek = Input(shape=(len_local, ), dtype='int32', name='t_dayOfWeek') main_input.append(t_hour) main_input.append(t_dayOfWeek) embed_t_hour = Embedding(output_dim=2, input_dim=25, input_length=len_local)(t_hour) embed_t_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_local)(t_dayOfWeek) t_external = merge.Concatenate(axis=-1)( [embed_t_hour, embed_t_dayOfWeek]) t_out = Flatten()(t_external) t_out = Dense(units=50)(t_out) t_out = Dropout(rate=0.1)(t_out) t_out = Activation('relu')(t_out) t_out = Dense(units=2 * neighbor_slide_len * neighbor_slide_len)(t_out) t_out = Activation('relu')(t_out) feature_external_t = Reshape( (2, neighbor_slide_len, neighbor_slide_len))(t_out) # ============================== # deal with the current local flow data current_local_flow = \ Input(shape=(2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='current_local_flow') main_input.append(current_local_flow) cnn_out = cnn_unit(is_BN, num_cnn)(current_local_flow) activation = Activation('relu')(cnn_out) feature_current_local_flow = Conv2D(2, (3, 3), strides=(1, 1), padding='same')(activation) local_feature_list.append(feature_current_local_flow) # ============================== # deal with the local stacked flow data stack_local_flow = \ Input(shape=(len_local * 2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='stack_local_flow') main_input.append(stack_local_flow) tcn_out = Reshape( (len_local, 2 * neighbor_slide_len * neighbor_slide_len))(stack_local_flow) for i in range(num_tcn): if i == num_tcn - 1 or (i == 0 and num_tcn == 1): tcn_out = TCN(nb_stacks=nb_stacks, return_sequences=False)(tcn_out) else: tcn_out = TCN(nb_stacks=nb_stacks, return_sequences=True)(tcn_out) o = Dense(units=(2 * neighbor_slide_len * neighbor_slide_len))(tcn_out) feature_stacked_local_flow = Reshape( (2, neighbor_slide_len, neighbor_slide_len))(o) local_feature_list.append(feature_stacked_local_flow) # ============================== # fuse local stacked flow feature and current local flow feature, then fuse local external feature local_output = [] for feature in local_feature_list: local_output.append(ilayer()(feature)) feature_local_flow = merge.Add()(local_output) # todo consider the fuse method feature_local = merge.Add()([feature_external_t, feature_local_flow]) # ============================== # deal with the global flow data, then fuse global external feature global_flow = \ Input(shape=(len_global * 2, width, height), dtype='float32', name='global_flow') main_input.append(global_flow) # todo consider the model here conv1 = Conv2D(64, (3, 3), strides=(1, 1), padding='same')(global_flow) activation = Activation('relu')(conv1) res_out = rest_unit(is_BN, nb_res_unit)(activation) activation = Activation('relu')(res_out) feature_global_flow = Conv2D(2, (3, 3), strides=(1, 1), padding='same')(activation) # todo consider the fuse method feature_global = merge.Add()([feature_external_g, feature_global_flow]) # reshape the global feaure feature_global = Flatten()(feature_global) feature_global = Dense(units=200)(feature_global) feature_global = Dropout(rate=0.1)(feature_global) feature_global = Dense(units=2 * neighbor_slide_len * neighbor_slide_len)(feature_global) feature_global = Activation('relu')(feature_global) feature_global = Reshape( (2, neighbor_slide_len, neighbor_slide_len))(feature_global) # ============================== # fuse local and global feature to predict # index_cut = Input(shape=(2,), dtype='int32', name='index_cut') # main_input.append(index_cut) # row, column = index_cut[0].eval(), index_cut[1].eval(session=K.get_session()) # fuse the global and local feature output = [] for feature in [feature_global, feature_local]: output.append(ilayer()(feature)) main_output = merge.Add()(output) main_output = Activation('tanh')(main_output) model = Model(inputs=main_input, outputs=main_output, name='GLST-Net') return model
def tcn_nog_rdw_att(args): len_recent, len_daily, len_week, neighbor_size, num_tcn, nb_stacks, is_BN, num_cnn, dataset = \ args['len_recent'], args['len_daily'], args['len_week'], args['neighbor_size'], \ args['num_tcn'], args['nb_stacks'], args['BN'], args['num_cnn'], args['dataset'] main_input = [] neighbor_slide_len = neighbor_size * 2 + 1 local_feature_list = [] # ============================== # deal with the local external data if dataset == 'bj_taxi': # current current_vacation = Input(shape=(1, ), dtype='int32', name='current_vacation') current_hour = Input(shape=(1, ), dtype='int32', name='current_hour') current_dayOfWeek = Input(shape=(1, ), dtype='int32', name='current_dayOfWeek') current_weather = Input(shape=(1, ), dtype='int32', name='current_weather') current_continuous_external = Input(shape=(1, 2), dtype='float32', name='current_continuous_external') main_input.append(current_vacation) main_input.append(current_hour) main_input.append(current_dayOfWeek) main_input.append(current_weather) main_input.append(current_continuous_external) embed_current_vacation = Embedding(output_dim=2, input_dim=2, input_length=1)(current_vacation) embed_current_hour = Embedding(output_dim=2, input_dim=25, input_length=1)(current_hour) embed_current_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=1)(current_dayOfWeek) embed_current_weather = Embedding(output_dim=2, input_dim=17, input_length=1)(current_weather) current_external = merge.Concatenate(axis=-1)([ embed_current_vacation, embed_current_hour, embed_current_dayOfWeek, embed_current_weather, current_continuous_external ]) # recent external recent_vacation = Input(shape=(len_recent, ), dtype='int32', name='recent_vacation') recent_hour = Input(shape=(len_recent, ), dtype='int32', name='recent_hour') recent_dayOfWeek = Input(shape=(len_recent, ), dtype='int32', name='recent_dayOfWeek') recent_weather = Input(shape=(len_recent, ), dtype='int32', name='recent_weather') recent_continuous_external = Input(shape=(len_recent, 2), dtype='float32', name='recent_continuous_external') main_input.append(recent_vacation) main_input.append(recent_hour) main_input.append(recent_dayOfWeek) main_input.append(recent_weather) main_input.append(recent_continuous_external) embed_recent_vacation = Embedding( output_dim=2, input_dim=2, input_length=len_recent)(recent_vacation) embed_recent_hour = Embedding(output_dim=2, input_dim=25, input_length=len_recent)(recent_hour) embed_recent_dayOfWeek = Embedding( output_dim=2, input_dim=7, input_length=len_recent)(recent_dayOfWeek) embed_recent_weather = Embedding( output_dim=2, input_dim=17, input_length=len_recent)(recent_weather) recent_external = merge.Concatenate(axis=-1)([ embed_recent_vacation, embed_recent_hour, embed_recent_dayOfWeek, embed_recent_weather, recent_continuous_external ]) # daily external daily_vacation = Input(shape=(len_daily, ), dtype='int32', name='daily_vacation') daily_hour = Input(shape=(len_daily, ), dtype='int32', name='daily_hour') daily_dayOfWeek = Input(shape=(len_daily, ), dtype='int32', name='daily_dayOfWeek') daily_weather = Input(shape=(len_daily, ), dtype='int32', name='daily_weather') daily_continuous_external = Input(shape=(len_daily, 2), dtype='float32', name='daily_continuous_external') main_input.append(daily_vacation) main_input.append(daily_hour) main_input.append(daily_dayOfWeek) main_input.append(daily_weather) main_input.append(daily_continuous_external) embed_daily_vacation = Embedding( output_dim=2, input_dim=2, input_length=len_daily)(daily_vacation) embed_daily_hour = Embedding(output_dim=2, input_dim=25, input_length=len_daily)(daily_hour) embed_daily_dayOfWeek = Embedding( output_dim=2, input_dim=7, input_length=len_daily)(daily_dayOfWeek) embed_daily_weather = Embedding(output_dim=2, input_dim=17, input_length=len_daily)(daily_weather) daily_external = merge.Concatenate(axis=-1)([ embed_daily_vacation, embed_daily_hour, embed_daily_dayOfWeek, embed_daily_weather, daily_continuous_external ]) # weekly external week_vacation = Input(shape=(len_week, ), dtype='int32', name='week_vacation') week_hour = Input(shape=(len_week, ), dtype='int32', name='week_hour') week_dayOfWeek = Input(shape=(len_week, ), dtype='int32', name='week_dayOfWeek') week_weather = Input(shape=(len_week, ), dtype='int32', name='week_weather') week_continuous_external = Input(shape=(len_week, 2), dtype='float32', name='week_continuous_external') main_input.append(week_vacation) main_input.append(week_hour) main_input.append(week_dayOfWeek) main_input.append(week_weather) main_input.append(week_continuous_external) embed_week_vacation = Embedding(output_dim=2, input_dim=2, input_length=len_week)(week_vacation) embed_week_hour = Embedding(output_dim=2, input_dim=25, input_length=len_week)(week_hour) embed_week_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_week)(week_dayOfWeek) embed_week_weather = Embedding(output_dim=2, input_dim=17, input_length=len_week)(week_weather) week_external = merge.Concatenate(axis=-1)([ embed_week_vacation, embed_week_hour, embed_week_dayOfWeek, embed_week_weather, week_continuous_external ]) else: # current current_hour = Input(shape=(1, ), dtype='int32', name='current_hour') current_dayOfWeek = Input(shape=(1, ), dtype='int32', name='current_dayOfWeek') main_input.append(current_hour) main_input.append(current_dayOfWeek) embed_current_hour = Embedding(output_dim=2, input_dim=25, input_length=1)(current_hour) embed_current_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=1)(current_dayOfWeek) current_external = merge.Concatenate(axis=-1)( [embed_current_hour, embed_current_dayOfWeek]) # recent external recent_hour = Input(shape=(len_recent, ), dtype='int32', name='recent_hour') recent_dayOfWeek = Input(shape=(len_recent, ), dtype='int32', name='recent_dayOfWeek') main_input.append(recent_hour) main_input.append(recent_dayOfWeek) embed_recent_hour = Embedding(output_dim=2, input_dim=25, input_length=len_recent)(recent_hour) embed_recent_dayOfWeek = Embedding( output_dim=2, input_dim=7, input_length=len_recent)(recent_dayOfWeek) recent_external = merge.Concatenate(axis=-1)( [embed_recent_hour, embed_recent_dayOfWeek]) # daily external daily_hour = Input(shape=(len_daily, ), dtype='int32', name='daily_hour') daily_dayOfWeek = Input(shape=(len_daily, ), dtype='int32', name='daily_dayOfWeek') main_input.append(daily_hour) main_input.append(daily_dayOfWeek) embed_daily_hour = Embedding(output_dim=2, input_dim=25, input_length=len_daily)(daily_hour) embed_daily_dayOfWeek = Embedding( output_dim=2, input_dim=7, input_length=len_daily)(daily_dayOfWeek) daily_external = merge.Concatenate(axis=-1)( [embed_daily_hour, embed_daily_dayOfWeek]) # weekly external week_hour = Input(shape=(len_week, ), dtype='int32', name='week_hour') week_dayOfWeek = Input(shape=(len_week, ), dtype='int32', name='week_dayOfWeek') main_input.append(week_hour) main_input.append(week_dayOfWeek) embed_week_hour = Embedding(output_dim=2, input_dim=25, input_length=len_week)(week_hour) embed_week_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_week)(week_dayOfWeek) week_external = merge.Concatenate(axis=-1)( [embed_week_hour, embed_week_dayOfWeek]) current_out = Flatten()(current_external) current_out = Dense(units=20)(current_out) current_out = Dropout(rate=0.1)(current_out) current_out = Activation('relu')(current_out) current_out = Dense(units=10)(current_out) feature_external_current = Activation('relu')(current_out) recent_out = Dense(units=20)(recent_external) recent_out = Dropout(rate=0.1)(recent_out) recent_out = Activation('relu')(recent_out) recent_out = Dense(units=10)(recent_out) feature_external_recent = Activation('relu')(recent_out) daily_out = Dense(units=20)(daily_external) daily_out = Dropout(rate=0.1)(daily_out) daily_out = Activation('relu')(daily_out) daily_out = Dense(units=10)(daily_out) feature_external_daily = Activation('relu')(daily_out) week_out = Dense(units=20)(week_external) week_out = Dropout(rate=0.1)(week_out) week_out = Activation('relu')(week_out) week_out = Dense(units=10)(week_out) feature_external_week = Activation('relu')(week_out) # ============================== # deal with the current local flow data current_local_flow = \ Input(shape=(2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='current_local_flow') main_input.append(current_local_flow) current_local_flow = cnn_unit(is_BN, num_cnn)(current_local_flow) current_local_flow = Activation('relu')(current_local_flow) current_local_flow = Conv2D(2, (3, 3), strides=(1, 1), padding='same')(current_local_flow) current_local_flow = Flatten()(current_local_flow) current_local_flow = merge.Concatenate(axis=-1)( [feature_external_current, current_local_flow]) current_local_flow = Dense(units=64, activation='relu')(current_local_flow) local_feature_list.append(current_local_flow) # ============================== # deal with the recent stacked flow data recent_local_flow = \ Input(shape=(len_recent * 2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='recent_local_flow') main_input.append(recent_local_flow) recent_local_flow = Reshape( (len_recent, 2 * neighbor_slide_len * neighbor_slide_len))(recent_local_flow) recent_local_flow = merge.Concatenate(axis=-1)( [feature_external_recent, recent_local_flow]) recent_local_flow = Dense(units=64, activation='relu')(recent_local_flow) # deal with the daily stacked flow data daily_local_flow = \ Input(shape=(len_daily * 2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='daily_local_flow') main_input.append(daily_local_flow) daily_local_flow = Reshape( (len_daily, 2 * neighbor_slide_len * neighbor_slide_len))(daily_local_flow) daily_local_flow = merge.Concatenate(axis=-1)( [feature_external_daily, daily_local_flow]) daily_local_flow = Dense(units=64, activation='relu')(daily_local_flow) # deal with the week stacked flow data week_local_flow = \ Input(shape=(len_week * 2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='week_local_flow') main_input.append(week_local_flow) week_local_flow = Reshape( (len_week, 2 * neighbor_slide_len * neighbor_slide_len))(week_local_flow) week_local_flow = merge.Concatenate(axis=-1)( [feature_external_week, week_local_flow]) week_local_flow = Dense(units=64, activation='relu')(week_local_flow) for i in range(num_tcn): recent_local_flow = TCN(nb_stacks=nb_stacks, return_sequences=True)(recent_local_flow) daily_local_flow = TCN(nb_stacks=nb_stacks, return_sequences=True)(daily_local_flow) week_local_flow = TCN(nb_stacks=nb_stacks, return_sequences=True)(daily_local_flow) attention_hidden_recent = Lambda(lambda x: x[:, :])(recent_local_flow) attention_hidden_daily = Lambda(lambda x: x[:, :])(daily_local_flow) attention_hidden_week = Lambda(lambda x: x[:, :])(week_local_flow) att_recent = Attention()([attention_hidden_recent, current_local_flow]) att_daily = Attention()([attention_hidden_daily, current_local_flow]) att_week = Attention()([attention_hidden_week, current_local_flow]) # fuse attention output = [] for att in [att_recent, att_daily, att_week]: output.append(ilayer()(att)) att_final = merge.Add()(output) att_current = merge.Concatenate(axis=-1)([att_final, current_local_flow]) att_current = Dense(units=2 * neighbor_slide_len * neighbor_slide_len)(att_current) att_current = Reshape( (2, neighbor_slide_len, neighbor_slide_len))(att_current) main_output = Activation('tanh')(att_current) model = Model(inputs=main_input, outputs=main_output, name='tcn_nog_rdw_att') return model
def tcn_no_global(args): len_local, neighbor_size, num_tcn, nb_stacks, is_BN, num_cnn, dataset = \ args['len_local'], args['neighbor_size'], args['num_tcn'], args['nb_stacks'], \ args['is_BN'], args['num_cnn'], args['dataset'] main_input = [] neighbor_slide_len = neighbor_size * 2 + 1 local_feature_list = [] # ============================== # deal with the local external data if dataset == 'bj_taxi': t_vacation = Input(shape=(len_local, ), dtype='int32', name='t_vacation') t_hour = Input(shape=(len_local, ), dtype='int32', name='t_hour') t_dayOfWeek = Input(shape=(len_local, ), dtype='int32', name='t_dayOfWeek') t_weather = Input(shape=(len_local, ), dtype='int32', name='t_weather') t_continuous_external = Input(shape=(len_local, 2), dtype='float32', name='t_continuous_external') main_input.append(t_vacation) main_input.append(t_hour) main_input.append(t_dayOfWeek) main_input.append(t_weather) main_input.append(t_continuous_external) embed_t_holiday = Embedding(output_dim=2, input_dim=2, input_length=len_local)(t_vacation) embed_t_hour = Embedding(output_dim=2, input_dim=25, input_length=len_local)(t_hour) embed_t_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_local)(t_dayOfWeek) embed_t_weather = Embedding(output_dim=2, input_dim=17, input_length=len_local)(t_weather) t_external = merge.Concatenate(axis=-1)([ embed_t_holiday, embed_t_hour, embed_t_dayOfWeek, embed_t_weather, t_continuous_external ]) else: t_hour = Input(shape=(len_local, ), dtype='int32', name='t_hour') t_dayOfWeek = Input(shape=(len_local, ), dtype='int32', name='t_dayOfWeek') main_input.append(t_hour) main_input.append(t_dayOfWeek) embed_t_hour = Embedding(output_dim=2, input_dim=25, input_length=len_local)(t_hour) embed_t_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_local)(t_dayOfWeek) t_external = merge.Concatenate(axis=-1)( [embed_t_hour, embed_t_dayOfWeek]) t_out = Flatten()(t_external) t_out = Dense(units=50)(t_out) t_out = Dropout(rate=0.1)(t_out) t_out = Activation('relu')(t_out) t_out = Dense(units=2 * neighbor_slide_len * neighbor_slide_len)(t_out) t_out = Activation('relu')(t_out) feature_external_t = Reshape( (2, neighbor_slide_len, neighbor_slide_len))(t_out) # ============================== # deal with the current local flow data current_local_flow = \ Input(shape=(2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='current_local_flow') main_input.append(current_local_flow) cnn_out = cnn_unit(is_BN, num_cnn)(current_local_flow) activation = Activation('relu')(cnn_out) feature_current_local_flow = Conv2D(2, (3, 3), strides=(1, 1), padding='same')(activation) local_feature_list.append(feature_current_local_flow) # ============================== # deal with the local stacked flow data stack_local_flow = \ Input(shape=(len_local * 2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='stack_local_flow') main_input.append(stack_local_flow) tcn_out = Reshape( (len_local, 2 * neighbor_slide_len * neighbor_slide_len))(stack_local_flow) for i in range(num_tcn): if i == num_tcn - 1 or (i == 0 and num_tcn == 1): tcn_out = TCN(nb_stacks=nb_stacks, return_sequences=False)(tcn_out) else: tcn_out = TCN(nb_stacks=nb_stacks, return_sequences=True)(tcn_out) o = Dense(units=(2 * neighbor_slide_len * neighbor_slide_len))(tcn_out) feature_stacked_local_flow = Reshape( (2, neighbor_slide_len, neighbor_slide_len))(o) local_feature_list.append(feature_stacked_local_flow) # ============================== # fuse local stacked flow feature and current local flow feature, then fuse local external feature local_output = [] for feature in local_feature_list: local_output.append(ilayer()(feature)) feature_local_flow = merge.Add()(local_output) feature_local = merge.Add()([feature_external_t, feature_local_flow]) main_output = Activation('tanh')(feature_local) model = Model(inputs=main_input, outputs=main_output, name='tcn_nog') return model
def simple_tcn(args): len_local, neighbor_size, num_tcn, nb_stacks, dataset = \ args['len_local'], args['neighbor_size'], args['num_tcn'], args['nb_stacks'], args['dataset'] main_input = [] neighbor_slide_len = neighbor_size * 2 + 1 # ============================== # deal with the local external data if dataset == 'bj_taxi': t_vacation = Input(shape=(len_local, ), dtype='int32', name='t_vacation') t_hour = Input(shape=(len_local, ), dtype='int32', name='t_hour') t_dayOfWeek = Input(shape=(len_local, ), dtype='int32', name='t_dayOfWeek') t_weather = Input(shape=(len_local, ), dtype='int32', name='t_weather') t_continuous_external = Input(shape=(len_local, 2), dtype='float32', name='t_continuous_external') main_input.append(t_vacation) main_input.append(t_hour) main_input.append(t_dayOfWeek) main_input.append(t_weather) main_input.append(t_continuous_external) embed_t_holiday = Embedding(output_dim=2, input_dim=2, input_length=len_local)(t_vacation) embed_t_hour = Embedding(output_dim=2, input_dim=25, input_length=len_local)(t_hour) embed_t_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_local)(t_dayOfWeek) embed_t_weather = Embedding(output_dim=2, input_dim=17, input_length=len_local)(t_weather) t_external = merge.Concatenate(axis=-1)([ embed_t_holiday, embed_t_hour, embed_t_dayOfWeek, embed_t_weather, t_continuous_external ]) else: t_hour = Input(shape=(len_local, ), dtype='int32', name='t_hour') t_dayOfWeek = Input(shape=(len_local, ), dtype='int32', name='t_dayOfWeek') main_input.append(t_hour) main_input.append(t_dayOfWeek) embed_t_hour = Embedding(output_dim=2, input_dim=25, input_length=len_local)(t_hour) embed_t_dayOfWeek = Embedding(output_dim=2, input_dim=7, input_length=len_local)(t_dayOfWeek) t_external = merge.Concatenate(axis=-1)( [embed_t_hour, embed_t_dayOfWeek]) t_out = Flatten()(t_external) t_out = Dense(units=50)(t_out) t_out = Dropout(rate=0.1)(t_out) t_out = Activation('relu')(t_out) t_out = Dense(units=2 * neighbor_slide_len * neighbor_slide_len)(t_out) t_out = Activation('relu')(t_out) feature_external_t = Reshape( (2, neighbor_slide_len, neighbor_slide_len))(t_out) # ============================== # deal with the local stacked flow data stack_local_flow = \ Input(shape=(len_local * 2, neighbor_slide_len, neighbor_slide_len), dtype='float32', name='stack_local_flow') main_input.append(stack_local_flow) tcn_out = Reshape( (len_local, 2 * neighbor_slide_len * neighbor_slide_len))(stack_local_flow) for i in range(num_tcn): if i == num_tcn - 1 or (i == 0 and num_tcn == 1): tcn_out = TCN(nb_stacks=nb_stacks, return_sequences=False)(tcn_out) else: tcn_out = TCN(nb_stacks=nb_stacks, return_sequences=True)(tcn_out) o = Dense(units=(2 * neighbor_slide_len * neighbor_slide_len))(tcn_out) feature_stacked_local_flow = Reshape( (2, neighbor_slide_len, neighbor_slide_len))(o) feature_local = merge.Add()( [feature_external_t, feature_stacked_local_flow]) main_output = Activation('tanh')(feature_local) model = Model(inputs=main_input, outputs=main_output, name='simple-tcn') return model