def build(self):
print('\nBuilding model...')
# create the model
embedding_vector_length = settings['EMBEDDING_VECTOR_LENGTH']
self.model = Sequential()
self.model.add(
Embedding(self.top_words,
embedding_vector_length,
input_length=self.max_words_limit))
self.model.add(
Convolution1D(nb_filter=settings['CNN_NO_OF_FILTER'],
filter_length=settings['CNN_FILTER_LENGTH'],
border_mode='same',
activation='relu'))
self.model.add(MaxPooling1D(pool_length=settings['CNN_POOL_LENGTH']))
self.model.add(LSTM(settings['LSTM_CELLS_COUNT']))
self.model.add(Dropout(settings['DROPOUT']))
self.model.add(Dense(self.num_classes, activation='softmax'))
print(self.model.summary())
def build_cnn_model(self, embedding_weights):
model = Sequential()
vocab_size = len(embedding_weights)
# 嵌入层将正整数（下标）转换为具有固定大小的向量. eg. [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]
model.add(
Embedding(
input_dim=vocab_size, # 字典长度
output_dim=EMBEDDING_SIZE,
input_length=self.max_len,
weights=[embedding_weights])
) # (None, MAX_SENTENCE_LENGTH, EMBEDDING_SIZE), where None is the batch dimension
model.add(SpatialDropout1D(0.2))
model.add(Convolution1D(filters=128, kernel_size=3, activation='relu'))
model.add(GlobalMaxPool1D()) # 对于时间信号的全局最大池化,MaxPooling1D限制每一步的池化大小
model.add(Dense(1, activation="sigmoid"))
# model.add(Dense(2, activation='softmax'))
model.summary()
return model
def get_feature_model(params):
embedding_dims = params['embedding_dims']
max_features = 8001
model = Sequential()
model.add(Embedding(
max_features,
embedding_dims,
input_length=MAXLEN,
dropout=params['embedding_dropout']))
model.add(Convolution1D(
nb_filter=params['nb_filter'],
filter_length=params['filter_length'],
border_mode='valid',
activation='relu',
subsample_length=1))
model.add(MaxPooling1D(
pool_length=params['pool_length'], stride=params['stride']))
model.add(Flatten())
return model
def build_graph(n_variables):
'''
Creates the Graph component of the model, i.e., this creates the
conv+gru with bi-directional
'''
nb_feature_maps = 64
ngram_filters = [1, 2, 3, 4, 5] #, 6, 7, 8]
graph = Graph()
graph.add_input(name='data', input_shape=(N_TRACKS, n_variables))
for n_gram in ngram_filters:
graph.add_node(Convolution1D(nb_feature_maps,
n_gram,
activation='relu',
input_shape=(N_TRACKS, n_variables)),
name='conv_%s' % n_gram,
input='data')
graph.add_node(
GRU(25),
name='gru_fwd_%s' % n_gram,
input='conv_%s' % n_gram,
)
graph.add_node(
GRU(25, go_backwards=True),
name='gru_bwd_%s' % n_gram,
input='conv_%s' % n_gram,
)
pass_thru = Lambda(lambda x: x)
graph.add_node(pass_thru,
name='unit_{}'.format(n_gram),
inputs=['gru_fwd_%s' % n_gram,
'gru_bwd_%s' % n_gram])
graph.add_node(Dropout(0.4),
name='dropout',
inputs=['unit_{}'.format(n) for n in ngram_filters],
create_output=True)
return graph
def get_feature_model():
embedding_dims = 128
max_features = 8001
model = Sequential()
model.add(
Embedding(max_features,
embedding_dims,
input_length=MAXLEN,
dropout=0.2))
model.add(
Convolution1D(nb_filter=32,
filter_length=128,
border_mode='valid',
activation='relu',
subsample_length=1))
model.add(MaxPooling1D(pool_length=64, stride=32))
model.add(Flatten())
model.summary()
return model
def get_conv_model(config):
nclass = config.n_classes
input_length = config.audio_length
model = Sequential()
model.add(
Convolution1D(16,
9,
activation='relu',
padding="valid",
input_shape=(input_length, 1)))
model.add(Convolution1D(16, 9, activation='relu', padding="valid"))
model.add(MaxPooling1D(16))
model.add(Dropout(rate=0.1))
model.add(Convolution1D(32, 3, activation='relu', padding="valid"))
model.add(Convolution1D(32, 3, activation='relu', padding="valid"))
model.add(MaxPooling1D(4))
model.add(Dropout(rate=0.1))
model.add(Convolution1D(32, 3, activation='relu', padding="valid"))
model.add(Convolution1D(32, 3, activation='relu', padding="valid"))
model.add(MaxPooling1D(4))
model.add(Dropout(rate=0.1))
model.add(Convolution1D(256, 3, activation='relu', padding="valid"))
model.add(Convolution1D(256, 3, activation='relu', padding="valid"))
model.add(GlobalMaxPooling1D())
model.add(Dropout(rate=0.2))
model.add(Dense(64, activation='relu'))
model.add(Dense(1028, activation='relu'))
model.add(Dense(nclass, activation='softmax'))
opt = optimizers.Adam(config.learning_rate)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['acc'])
return model
def cnn_train(X_train, y_train, vocab_size):
X_train = sequence.pad_sequences(X_train, maxlen=MAX_LEN)
print('Build model...')
model = Sequential()
model.add(Embedding(vocab_size, EMBED_SIZE, input_length=MAX_LEN))
model.add(Dropout(0.25))
# we add a Convolution1D, which will learn nb_filter
# word group filters of size filter_length:
model.add(
Convolution1D(nb_filter=nb_filter,
filter_length=filter_length,
border_mode='valid',
activation='relu',
subsample_length=1))
# we use standard max pooling (halving the output of the previous layer):
model.add(MaxPooling1D(pool_length=2))
# We flatten the output of the conv layer,
# so that we can add a vanilla dense layer:
model.add(Flatten())
# We add a vanilla hidden layer:
model.add(Dense(HIDDEN_SIZE))
model.add(Dropout(0.25))
model.add(Activation('relu'))
# We project onto a single unit output layer, and squash it with a sigmoid:
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='rmsprop')
model.fit(X_train,
y_train,
batch_size=BATCH_SIZE,
nb_epoch=EPOCHS,
show_accuracy=True)
return model
def model_relu6():
batch_size=32
filter_length = 5
nb_filter = 64
pool_length = 4
nb_epoch = 3
inputDim = 26
model = Sequential()
model.add( Embedding(inputDim*inputDim*inputDim, inputDim, dropout=0.2) ) #input vector dimension
model.add(Convolution1D(nb_filter= nb_filter, filter_length= filter_length, border_mode='valid', activation='relu',subsample_length=1))
model.add(MaxPooling1D(pool_length= pool_length))
model.add( Bidirectional( LSTM(1024, return_sequences=True) ))
model.add(LeakyReLU())
model.add(BatchNormalization( ))
model.add(Dropout(0.5))
model.add( Bidirectional( LSTM(2048, return_sequences=True)) )
model.add(Activation('relu'))
model.add(BatchNormalization( ))
model.add(Dropout(0.5))
model.add( Bidirectional( LSTM(512, return_sequences=True)) )
model.add(Activation('relu'))
model.add(BatchNormalization( ))
model.add(Dropout(0.5))
model.add( Bidirectional( LSTM(256)) )
model.add(Activation('relu'))
model.add(BatchNormalization( ))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam',metrics=[jacek_auc,discussion41015_auc])
return model
def build_lstm_model(top_words,
embedding_size,
max_input_length,
num_outputs,
internal_lstm_size=100,
embedding_matrix=None,
embedding_trainable=True):
"""
Parameters
top_words : int
Size of the vocabulary
embedding_size : int
Number of dimensions of the word embedding. e.g. 300 for Google word2vec
embedding_matrix: None, or `top_words` x `embedding_size` matrix
Initial/pre-trained embeddings
embedding_trainable : bool
Whether we should train the word embeddings. Must be true if no embedding matrix provided
"""
if not embedding_trainable:
assert embedding_matrix is not None, "Must provide an embedding matrix if not training one"
_weights = None
if embedding_matrix is not None:
_weights = [embedding_matrix]
model = Sequential()
model.add(
Embedding(top_words,
embedding_size,
input_length=max_input_length,
weights=_weights,
trainable=embedding_trainable))
model.add(
Convolution1D(filters=32,
kernel_size=3,
padding='same',
activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(LSTM(internal_lstm_size))
model.add(Dense(num_outputs, activation='softmax'))
return model
def create(self, charset_len, weights=None):
latent_dim = 500
max_len = 120
inputs = Input(shape=(max_len, charset_len))
#6 Convolutional Layers (All Conv)
x = Convolution1D(charset_len * 2, 1, activation='relu',
name='conv_1')(inputs)
x = Convolution1D(charset_len * 2,
1,
subsample_length=2,
activation='relu',
name='resh_1')(inputs)
x = Convolution1D(charset_len, 1, activation='relu', name='conv_2')(x)
x = Convolution1D(charset_len,
1,
subsample_length=2,
activation='relu',
name='resh_2')(x)
x = Convolution1D(charset_len / 2,
1,
activation='relu',
name='resize_1')(x)
x = Convolution1D(charset_len / 2,
1,
subsample_length=max_len / 4,
activation='relu',
name='resh_3')(x)
x = Flatten()(x)
x = Dropout(0.2)(x)
x = Dense(240, name='dense_1')(x)
x = Dense(charset_len, name='dense_2')(x)
x = Dense(1, name='dense_3')(x)
predictions = Activation('sigmoid')(x)
self.sol = Model(input=inputs, output=predictions)
if weights:
self.sol.load_weights(weights)
self.sol.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['mean_absolute_error'])
def build_mixed_model(max_features, seqlen, nb_classes):
print('build mixed model ...')
model = Sequential()
model.add(Embedding(max_features, 100, input_length=seqlen))
model.add(Dropout(0.25))
model.add(
Convolution1D(nb_filter=200,
filter_length=10,
border_mode='valid',
activation='relu'))
model.add(MaxPooling1D(pool_length=50))
model.add(LSTM(100))
model.add(Dropout(0.25))
model.add(Activation('relu'))
model.add(Dense(nb_classes))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=["accuracy"])
return model
def cnn(sequence_input):
embedded = embedding_layer(sequence_input)
embedded = Dropout(0.25)(embedded)
# convolutional layer
convolution = Convolution1D(filters=nb_filter,
kernel_size=kernel_size,
padding='valid',
activation='relu',
strides=1)(embedded)
maxpooling = MaxPooling1D(pool_size=2)(convolution)
maxpooling = Flatten()(maxpooling)
# We add a vanilla hidden layer:
dense = Dense(70)(maxpooling) # best: 120
dense = Dropout(0.25)(dense) # best: 0.25
dense = Activation('relu')(dense)
output = Dense(2, activation='softmax')(dense)
model = Model(inputs=sequence_input, outputs=output)
return model
def hierarchical_cnn (input_shape, aux_shape, targets = 1, hidden = 256, multiclass = False, learn_rate=1e-4):
x = Input(shape = input_shape, name = 'x')
xx = Convolution1D(nb_filter = 64, filter_length = 3, border_mode = 'same', activation = 'relu') (x)
xx = MaxPooling1D(pool_length = 3) (xx)
xx = Bidirectional(LSTM (256, activation = 'relu'), merge_mode = 'concat') (xx)
xx = Dropout(0.5)(xx)
dx = Input(shape = aux_shape, name = 'aux')
xx = concatenate([xx, dx])
if multiclass:
y = Dense(targets, activation = 'softmax') (xx)
model = Model(inputs = [x, dx], outputs = [y])
model.compile (loss = 'categorical_crossentropy', optimizer = Adam(lr = learn_rate), metrics = ['categorical_accuracy'])
else:
y = Dense(targets, activation = 'sigmoid') (xx)
model = Model(inputs = [x, dx], outputs = [y])
model.compile (loss = 'binary_crossentropy', optimizer = Adam(lr = learn_rate), metrics = ['accuracy'])
return (model)
def buildModel_max(vocab_size):
model = Sequential()
model.add(
Embedding(vocab_size, EMBED_SIZE, input_length=MAX_LEN, dropout=0.2))
# we add a Convolution1D, which will learn nb_filter
# word group filters of size filter_length:
model.add(
Convolution1D(nb_filter=nb_filter,
filter_length=filter_length,
border_mode='valid',
activation='relu',
subsample_length=1))
# we use standard max pooling (halving the output of the previous layer):
model.add(MaxPooling1D(pool_length=2))
# We flatten the output of the conv layer,
# so that we can add a vanilla dense layer:
model.add(Flatten())
# model.add(RepeatVector(HIDDEN_SIZE))
return model
def cnn_prediction(X_train, y_train, X_test, y_test, vocab_size):
X_train = sequence.pad_sequences(X_train, maxlen=MAX_LEN)
X_test = sequence.pad_sequences(X_test, maxlen=MAX_LEN)
print('X_train shape:', X_train.shape)
print('X_test shape:', X_test.shape)
print('Build model...')
model = Sequential()
model.add(
Embedding(vocab_size, EMBED_SIZE, input_length=MAX_LEN, dropout=0.2))
model.add(
Convolution1D(nb_filter=nb_filter,
filter_length=filter_length,
border_mode='valid',
activation='relu',
subsample_length=1))
model.add(MaxPooling1D(pool_length=2))
model.add(Flatten())
model.add(Dense(HIDDEN_SIZE))
model.add(Dropout(0.25))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='rmsprop')
model.fit(X_train,
y_train,
batch_size=BATCH_SIZE,
nb_epoch=EPOCHS,
show_accuracy=True,
validation_data=(X_test, y_test))
X_pred = model.predict(X_test)
results = [result[0] for result in X_pred]
return readResult(y_test, results)
def set_up_model_up():
print('building model')
seq_input_shape = (2000, 4)
nb_filter = 64
filter_length = 6
input_shape = (2000, 4)
attentionhidden = 256
seq_input = Input(shape=seq_input_shape, name='seq_input')
convul1 = Convolution1D(filters=nb_filter,
kernel_size=filter_length,
padding='valid',
activation='relu',
kernel_constraint=maxnorm(3),
subsample_length=1)
pool_ma1 = MaxPooling1D(pool_size=3)
dropout1 = Dropout(0.5977908689086315)
dropout2 = Dropout(0.30131233477637737)
decoder = Attention(hidden=attentionhidden, activation='linear')
dense1 = Dense(1)
dense2 = Dense(1)
output_1 = pool_ma1(convul1(seq_input))
output_2 = dropout1(output_1)
att_decoder = decoder(output_2)
output_3 = attention_flatten(output_2._keras_shape[2])(att_decoder)
output_4 = dense1(dropout2(Flatten()(output_2)))
all_outp = merge([output_3, output_4], mode='concat')
output_5 = dense2(all_outp)
output_f = Activation('sigmoid')(output_5)
model = Model(inputs=seq_input, outputs=output_f)
model.compile(loss='binary_crossentropy',
optimizer='nadam',
metrics=['accuracy'])
print(model.summary())
return model
def imdb_cnn(W=None):
# Number of feature maps (outputs of convolutional layer)
N_fm = 60
# kernel size of convolutional layer
kernel_size = 3
dims = 300 # 300 dimension
maxlen = 200 # maxlen of sentence
max_features = W.shape[0]
hidden_dims = 100
print('Build model...')
model = Sequential()
# we start off with an efficient embedding layer which maps
# our vocab indices into embedding_dims dimensions
model.add(Embedding(max_features, dims, input_length=maxlen, weights=[W]))
model.add(Dropout(0.5))
# we add a Convolution1D, which will learn nb_filter
# word group filters of size filter_length:
model.add(Convolution1D(nb_filter=N_fm,
filter_length=kernel_size,
border_mode='valid',
activation='relu',
))
model.add(Dropout(0.5))
# we use standard max pooling (halving the output of the previous layer):
model.add(MaxPooling1D(pool_length=kernel_size*7))
# We flatten the output of the conv layer,
# so that we can add a vanilla dense layer:
model.add(Flatten())
# We add a vanilla hidden layer:
model.add(Dense(hidden_dims))
model.add(Dropout(0.5))
model.add(Activation('relu'))
# We project onto a single unit output layer, and squash it with a sigmoid:
model.add(Dense(2))
model.add(Activation('softmax'))
return model
def get_model(
go_id,
max_features=5000,
embedding_dims=100,
nb_filters=250,
hidden_dims=250,
pool_length=2,
filter_length=3):
filepath = DATA_ROOT + 'level_1/models/' + go_id + '.hdf5'
size = os.path.getsize(filepath)
max_features = get_model_max_features(size)
global go_model
if go_id in go_model:
return go_model[go_id]
# length of APAAC
maxlen = 20 + 6 * LAMBDA
model = Sequential()
model.add(Embedding(max_features, embedding_dims))
model.add(Dropout(0.25))
model.add(Convolution1D(
input_dim=embedding_dims,
nb_filter=nb_filters,
filter_length=filter_length,
border_mode='valid',
activation='relu',
subsample_length=1))
model.add(MaxPooling1D(pool_length=pool_length))
model.add(Flatten())
output_size = nb_filters * (((maxlen - filter_length) / 1) + 1) / 2
model.add(Dense(output_size, hidden_dims))
model.add(Dropout(0.25))
model.add(Activation('relu'))
model.add(Dense(hidden_dims, 1))
model.add(Activation('sigmoid'))
model.compile(
loss='binary_crossentropy', optimizer='adam', class_mode='binary')
# Loading saved weights
print 'Loading weights for ' + go_id
model.load_weights(filepath)
return model
def create(self):
assert self._config.merge_mode in ['max', 'ave', 'sum'], \
'Merge mode of this model is either max, ave or sum'
model_list = [None] * self._config.language_cnn_views
for j in xrange(1, self._config.language_cnn_views + 1):
current_view = Sequential()
self.textual_embedding(current_view, mask_zero=True)
current_view.add(
Convolution1D(nb_filter=self._config.language_cnn_filters,
filter_length=j,
border_mode='valid',
activation=self._config.language_cnn_activation,
subsample_length=1))
self.temporal_pooling(current_view)
model_list[j - 1] = current_view
self.add(Merge(model_list, mode='concat'))
self.deep_mlp()
self.add(Dense(self._config.output_dim))
self.add(Activation('softmax'))
def get_model(self):
inputs_x = Input(shape=(self.sequence_len, ), dtype='int32')
embedded_sequences = Embedding(self.nb_words,
self.embedding_dim,
weights=[self.embedding_matrix],
input_length=self.sequence_len,
trainable=False)(inputs_x)
x = Convolution1D(256, 3, padding='same')(embedded_sequences)
x = Activation('relu')(x)
x = GlobalMaxPooling1D()(x)
x = Dropout(0.25)(x)
x = Dense(256)(x) #128
x = Activation('relu')(x)
x = Dense(6)(x)
outputs = Activation('sigmoid', name='outputs')(x)
model = Model(inputs=[inputs_x], outputs=outputs)
model.compile(loss='binary_crossentropy', optimizer='adamax')
self.model = model
return self.model
def create_grouped():
# np.random.seed(seed)
feature_len = len(X[0, 0, :])
season_len = len(X[0, :])
model = Sequential()
model.add(GaussianNoise(.05,
input_shape=(season_len,
feature_len))) # output:(None, 12, 9)
model.add(Convolution1D(40, 1)) # (None, 12, 40)
model.add(Flatten()) # (None, 480)
model.add(Dense(int(40), init='normal', activation='relu')) # (None, 40)
model.add(Dropout(.25))
model.add(Dense(int(40), init='normal', activation='relu', bias=True))
model.add(Dropout(.25))
model.add(Dense(int(20), init='normal', activation='tanh')) # (None, 20)
model.add(Dropout(.2))
model.add(Dense(12, init='normal', activation='softmax')) # (None, 12)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy', 'precision', 'recall', 'fmeasure'])
return model
def create_deep_cnn_model(nb_dim, nb_width):
print("dim: " + str(nb_dim))
model = Sequential()
# model.add(Convolution2D(nb_dim,5,nb_dim, border_mode='valid',input_shape=(1, nb_width, nb_dim)))
# model.add(Activation('tanh'))
# model.add(MaxPooling2D(pool_size=( 46,1)))
model.add(Convolution1D(nb_filter=128,
filter_length=3,
border_mode="valid",
activation="tanh",
input_shape=(nb_width, nb_dim)))
model.add(MaxPooling1D(pool_length=48))
model.add(Flatten())
model.add(Dense(256, init='normal'))
model.add(Activation('tanh'))
model.add(Dropout(0.5))
model.add(Dense(nb_class, init='normal'))
model.add(Activation('softmax'))
return model
def __init__(self, output_dimesion, vocab_size, dropout_rate, emb_dim, max_len, nb_filters, init_W=None):
self.max_len = max_len
max_features = vocab_size
vanila_dimension = 200
self.filter_lengths = [3, 4, 5]
'''Embedding Layer'''
in_seq = Input(shape=(max_len,))
if init_W is None:
seq_emb = Embedding(max_features, emb_dim, input_length=max_len, trainable=True)(in_seq)
else:
seq_emb = Embedding(max_features, emb_dim, input_length=max_len, trainable=False, weights=[init_W / 20])(in_seq)
'''Convolution Layer & Max Pooling Layer'''
tmp_list = []
for ws in self.filter_lengths:
# cnn = Reshape((self.max_len, emb_dim, 1), input_shape=(self.max_len,))(seq_emb)
# cnn = Convolution2D(nb_filters, ws, emb_dim, activation="relu")(cnn)
# cnn = MaxPooling2D(pool_size=(self.max_len - ws + 1, 1))(cnn)
# cnn = Flatten()(cnn)
cnn = Convolution1D(nb_filters, ws, border_mode='valid', activation='relu', subsample_length=1)(seq_emb)
cnn = MaxPooling1D(pool_length=self.max_len - ws + 1)(cnn)
cnn = Flatten()(cnn)
tmp_list.append(cnn)
cnn_con = Concatenate()(tmp_list)
'''Dropout Layer'''
seq_dropout = Dense(vanila_dimension, activation='tanh')(cnn_con)
seq_dropout = Dropout(dropout_rate)(seq_dropout)
'''Projection Layer & Output Layer'''
out_seq = Dense(output_dimesion, activation='tanh')(seq_dropout)
# Output Layer
self.model = Model(in_seq, out_seq)
self.model.compile(optimizer='rmsprop', loss='mse')
print (self.model.summary())
def baseModel(self, nb_filter=250, filter_length=3, hidden_dims=125):
model = Sequential()
# we start off with an efficient embedding layer which maps
# our vocab indices into embedding_dims dimensions
model.add(
Embedding(self.max_words + self.index_from,
self.embedding_dims,
input_length=self.max_length))
model.add(Dropout(0.25))
# we add a Convolution1D, which will learn nb_filter
# word group filters of size filter_length:
# filter_length is like filter size, subsample_length is like step in 2D CNN.
model.add(
Convolution1D(filters=nb_filter,
kernel_size=filter_length,
padding='valid',
activation='relu',
strides=1))
# we use standard max pooling (halving the output of the previous layer):
model.add(MaxPooling1D(pool_size=2))
# We flatten the output of the conv layer,
# so that we can add a vanilla dense layer:
model.add(Flatten())
# We add a vanilla hidden layer:
model.add(Dense(hidden_dims))
model.add(Dropout(0.25))
model.add(Activation('relu'))
# We project onto a single unit output layer, and squash it with a sigmoid:
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='rmsprop')
return model
def build_model(ncell, nmark, nfilter, coeff_l1, coeff_l2,
k, dropout, dropout_p, regression, n_classes, lr=0.01):
""" Builds the neural network architecture """
# the input layer
data_input = Input(shape=(ncell, nmark))
# the filters
conv = Convolution1D(nfilter, 1, activation='linear',
W_regularizer=l1l2(l1=coeff_l1, l2=coeff_l2),
name='conv1')(data_input)
conv = Activation('relu')(conv) ### filter responses?
# the cell grouping part
pooled = Lambda(select_top, output_shape=(nfilter,), arguments={'k':k})(conv)
# possibly add dropout
if dropout or ((dropout == 'auto') and (nfilter > 5)):
pooled = Dropout(p=dropout_p)(pooled)
# network prediction output
if not regression:
output = Dense(n_classes, activation='softmax',
W_regularizer=l1l2(l1=coeff_l1, l2=coeff_l2),
name='output')(pooled)
else:
output = Dense(1, activation='linear', W_regularizer=l1l2(l1=coeff_l1, l2=coeff_l2),
name='output')(pooled)
model = Model(input=data_input, output=output)
if not regression:
model.compile(optimizer=Adam(lr=lr),
loss='categorical_crossentropy',
metrics=['accuracy'])
else:
model.compile(optimizer=Adam(lr=lr),
loss='mean_squared_error')
return model
def cgru_model():
m = Sequential()
layers = [
(FixedEmbedding if embedding_fixed else Embedding)\
(*embeddings.shape, input_length=max_len, weights=[embeddings]),
SimpleRNN(rnn_output, activation="relu", return_sequences=True),
Convolution1D(
nb_filter,
filter_length,
border_mode="valid",
activation="relu"),
MaxPooling1D(pool_length=max_len - filter_length + 1),
Flatten(),
Dropout(0.5),
Dense(1, activation='sigmoid', W_constraint=maxnorm(W_constraint))
]
for l in layers:
m.add(l)
m.compile(loss='binary_crossentropy',
optimizer="adadelta",
class_mode='binary')
return m
def cgru_model():
m = Sequential()
layers = [
(FixedEmbedding if embedding_fixed else Embedding)\
(*embeddings.shape, input_length=max_len, weights=[embeddings]),
Dropout(0.25),
Convolution1D(
nb_filter,
filter_length,
border_mode="valid",
activation="relu"),
MaxPooling1D(pool_length=pool_length),
GRU(rnn_output),
# Lambda(lambda X: X.mean(axis=-2), output_shape=(rnn_output,)),
Dense(1, activation='sigmoid', W_constraint=maxnorm(W_constraint))
]
for l in layers:
m.add(l)
m.compile(loss='binary_crossentropy',
optimizer="adadelta",
class_mode='binary')
return m
def build_model(features, seq_len, out):
model = Sequential()
model.add(LSTM(100, input_shape=(seq_len, features),
return_sequences=True))
model.add(Activation("tanh"))
model.add(Convolution1D(50, 10, border_mode='valid'))
model.add(Activation("relu"))
model.add(Flatten())
model.add(Dense(units=out))
model.add(Activation("linear"))
start = time.time()
adam = Adam(lr=0.25, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
#model.compile(loss = "mean_absolute_percentage_error", optimizer = 'RMSprop')
model.compile(loss="mean_absolute_percentage_error", optimizer=adam)
print("> Compilation Time : ", time.time() - start)
return model
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
def _simple_model(self, shape):
filter_width = 8
n_filters = 128
timesteps = shape[1]
features = shape[2]
model = Sequential()
# model.add(TimeDistributed(Dense(512), input_shape=(timesteps,features)))
model.add(
Convolution1D(n_filters,
filter_width,
input_shape=(timesteps, features)))
timesteps -= filter_width - 1
model.add(Dropout(self.dropout))
model.add(AveragePooling1D(timesteps))
model.add(Flatten())
#model.add(Dense(128,activation='relu'))
model.add(Dense(15))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
return model
