def __build_network(self):
embedding_layer = Embedding(
self.corpus_size,
EMBEDDING_DIM,
weights=[self.embedding_matrix],
input_length=MAX_TITLE_LENGTH,
trainable=False)
# train a 1D convnet with global maxpooling
sequence_input = Input(shape=(MAX_TITLE_LENGTH, ), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
x = LSTM(
128,
dropout_W=0.2,
dropout_U=0.2,
W_regularizer=regularizers.l2(0.01),
b_regularizer=regularizers.l2(0.01))(embedded_sequences)
x = Dropout(0.5)(x)
preds = Dense(self.class_num, activation='softmax')(x)
print preds.get_shape()
if self.optimizer == 'adam':
self.optimizer = Adam(lr=self.lr)
if self.optimizer == 'rmsprop':
self.optimizer = RMSprop(lr=self.lr)
# rmsprop = RMSprop(lr=self.lr)
self.model = Model(sequence_input, preds)
self.model.compile(
loss='categorical_crossentropy',
optimizer=self.optimizer,
metrics=['acc'])
def test_layer_trainability_switch():
# with constructor argument, in Sequential
model = Sequential()
model.add(Dense(2, trainable=False, input_dim=1))
assert model.trainable_weights == []
# by setting the `trainable` argument, in Sequential
model = Sequential()
layer = Dense(2, input_dim=1)
model.add(layer)
assert model.trainable_weights == layer.trainable_weights
layer.trainable = False
assert model.trainable_weights == []
# with constructor argument, in Model
x = Input(shape=(1,))
y = Dense(2, trainable=False)(x)
model = Model(x, y)
assert model.trainable_weights == []
# by setting the `trainable` argument, in Model
x = Input(shape=(1,))
layer = Dense(2)
y = layer(x)
model = Model(x, y)
assert model.trainable_weights == layer.trainable_weights
layer.trainable = False
assert model.trainable_weights == []
def __init__(self, memory_cells, query, project_query=False):
"""Define Attention.
Args:
memory_cells (SequenceBatch): a SequenceBatch containing a Tensor of shape (batch_size, num_cells, cell_dim)
query (Tensor): a tensor of shape (batch_size, query_dim).
project_query (bool): defaults to False. If True, the query goes through an extra projection layer to
coerce it to cell_dim.
"""
cell_dim = memory_cells.values.get_shape().as_list()[2]
if project_query:
# project the query up/down to cell_dim
self._projection_layer = Dense(cell_dim, activation='linear')
query = self._projection_layer(query) # (batch_size, cand_dim)
memory_values, memory_mask = memory_cells.values, memory_cells.mask
# batch matrix multiply to compute logit scores for all choices in all batches
query = tf.expand_dims(query, 2) # (batch_size, cell_dim, 1)
logit_values = tf.batch_matmul(memory_values, query) # (batch_size, num_cells, 1)
logit_values = tf.squeeze(logit_values, [2]) # (batch_size, num_cells)
# set all pad logits to negative infinity
logits = SequenceBatch(logit_values, memory_mask)
logits = logits.with_pad_value(-float('inf'))
# normalize to get probs
probs = tf.nn.softmax(logits.values) # (batch_size, num_cells)
retrieved = tf.batch_matmul(tf.expand_dims(probs, 1), memory_values) # (batch_size, 1, cell_dim)
retrieved = tf.squeeze(retrieved, [1]) # (batch_size, cell_dim)
self._logits = logits.values
self._probs = probs
self._retrieved = retrieved
def __build_network(self):
embedding_layer = Embedding(self.corpus_size,
EMBEDDING_DIM,
weights=[self.embedding_matrix],
input_length=MAX_SEQUENCE_LENGTH,
trainable=False)
# train a 1D convnet with global maxpooling
sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
# sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')
# embedded_sequences = embedding_layer(sequence_input)
x = Convolution1D(128, 5)(embedded_sequences)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling1D(5)(x)
x = Convolution1D(128, 5)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling1D(5)(x)
print "before 256", x.get_shape()
x = Convolution1D(128, 5)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
print "before 35 ", x.get_shape()
x = MaxPooling1D(35)(x)
x = Flatten()(x)
# print x.shape()
x = Dense(128, activation='relu')(x)
print x.get_shape()
x = Dropout(0.5)(x)
print x.get_shape()
preds = Dense(self.class_num, activation='softmax')(x)
print preds.get_shape()
# conv_blocks = []
# for sz in self.filter_sizes:
# conv = Convolution1D(filters=self.num_filters, kernel_size=sz, activation="relu", padding='valid', strides=1)(embedded_sequences)
# conv = MaxPooling1D(pool_size=2)(conv)
# conv = Flatten()(conv)
# conv_blocks.append(conv)
# z = Concatenate()(conv_blocks) if len(conv_blocks) > 1 else conv_blocks[0]
# z = Dropout(rate=0.5)(z)
# z = Dense(units=self.hidden_dims, activation="relu")(z)
# preds = Dense(self.class_num, activation="softmax")(z)
rmsprop = RMSprop(lr=0.001)
self.model = Model(sequence_input, preds)
self.model.compile(loss='categorical_crossentropy', optimizer=rmsprop, metrics=['acc'])
def test_get_losses_for():
a = Input(shape=(2,))
dense_layer = Dense(1)
dense_layer.add_loss(0, inputs=a)
dense_layer.add_loss(1, inputs=None)
assert dense_layer.get_losses_for(a) == [0]
assert dense_layer.get_losses_for(None) == [1]
def __build_network(self):
embedding_layer = Embedding(self.corpus_size,
EMBEDDING_DIM,
weights=[self.embedding_matrix],
input_length=MAX_SEQUENCE_LENGTH,
trainable=False)
# train a 1D convnet with global maxpooling
sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
x = Convolution1D(self.num_filters, 5, activation="relu")(embedded_sequences)
x = MaxPooling1D(5)(x)
x = Convolution1D(self.num_filters, 5, activation="relu")(x)
x = MaxPooling1D(5)(x)
x = LSTM(64, dropout_W=0.2, dropout_U=0.2)(x)
preds = Dense(self.class_num, activation='softmax')(x)
print preds.get_shape()
rmsprop = RMSprop(lr=0.01)
self.model = Model(sequence_input, preds)
self.model.compile(loss='categorical_crossentropy', optimizer=rmsprop, metrics=['acc'])
def get_ResNet_classifier():
inputs = Input((CLASSIFY_INPUT_WIDTH, CLASSIFY_INPUT_HEIGHT, CLASSIFY_INPUT_DEPTH, CLASSIFY_INPUT_CHANNEL))
x = conv_bn_relu(inputs, RESNET_INITIAL_FILTERS)
print('base')
print(x.get_shape())
for i in range(RESNET_BLOCKS):
x = bottleneck(x, shrinkage=(i % RESNET_SHRINKAGE_STEPS == 0))
print('top')
x = GlobalMaxPooling3D()(x)
print(x.get_shape())
x = Dense(2, activation='softmax')(x)
print(x.get_shape())
model = Model(inputs=inputs, outputs=x)
model.compile(optimizer=Adam(lr=TRAIN_CLASSIFY_LEARNING_RATE), loss='binary_crossentropy', metrics=['accuracy'])
return model
'include_flip': False,
'random_flip': True
}))
if debug: print model.output_shape
model.add(Lambda(ev_translation, output_shape=(REDUCTION, )))
#needed for the pylearn moduls used by kerasCudaConvnetConv2DLayer and kerasCudaConvnetPooling2DLayer
if debug: print model.output_shape
model.add(Dropout(0.5))
model.add(
Dense(output_dim=2048,
activation='tanh',
weights=dense_weight_init_values(model.output_shape[-1], 2048)))
model.add(Dropout(0.5))
model.add(
MaxoutDense(output_dim=2048,
nb_feature=2,
weights=dense_weight_init_values(model.output_shape[-1],
2048,
nb_feature=2)))
model.add(Dropout(0.5))
model.add(
MaxoutDense(output_dim=2048,
nb_feature=2,
weights=dense_weight_init_values(model.output_shape[-1],
def _build(self, phase, seq_shape=None, batch_size=None):
# Recognition model
self.z_recognition_model = STORNRecognitionModel(
self.data_dim, self.latent_dim, self.n_hidden_dense,
self.n_hidden_recurrent, self.n_deep, self.dropout,
self.activation)
self.z_recognition_model.build(phase=phase,
seq_shape=seq_shape,
batch_size=batch_size)
if phase == Phases.train:
x_tm1 = Input(shape=(seq_shape, self.data_dim),
name="storn_input_train",
dtype="float32")
z_t = self.z_recognition_model.train_z_t
x_t = self.z_recognition_model.train_input
z_post_stats = self.z_recognition_model.train_recogn_stats
else:
x_tm1 = Input(batch_shape=(batch_size, 1, self.data_dim),
name="storn_input_predict",
dtype="float32")
z_t = self.z_recognition_model.predict_z_t
x_t = self.z_recognition_model.predict_input
z_post_stats = self.z_recognition_model.predict_recogn_stats
# Prior model
if self.with_trending_prior:
z_tm1 = LambdaWithMasking(
STORNModel.shift_z,
output_shape=self.shift_z_output_shape)(z_t)
self.z_prior_model = STORNPriorModel(
self.latent_dim,
self.with_trending_prior,
n_hidden_recurrent=self.n_hidden_recurrent,
x_tm1=x_tm1,
z_tm1=z_tm1)
else:
self.z_prior_model = STORNPriorModel(self.latent_dim,
self.with_trending_prior)
self.z_prior_model.build(phase=phase,
seq_shape=seq_shape,
batch_size=batch_size)
if phase == Phases.train:
z_prior_stats = self.z_prior_model.train_prior_stats
else:
z_prior_stats = self.z_prior_model.predict_prior_stats
# Generative model
# Fix of keras/engine/topology.py required for masked layer!
# Otherwise concat with masked and non masked layer returns an error!
# masked = Masking()(x_tm1)
# gen_input = merge(inputs=[masked, z_t], mode='concat')
# Unmasked Layer
gen_input = merge(inputs=[x_tm1, z_t], mode='concat')
for i in range(self.n_deep):
gen_input = TimeDistributed(
Dense(self.n_hidden_dense,
activation=self.activation))(gen_input)
if self.dropout != 0:
gen_input = Dropout(self.dropout)(gen_input)
rnn_gen = RecurrentLayer(self.n_hidden_recurrent,
return_sequences=True,
stateful=(phase == Phases.predict),
consume_less='gpu')(gen_input)
gen_map = rnn_gen
for i in range(self.n_deep):
gen_map = TimeDistributed(
Dense(self.n_hidden_dense,
activation=self.activation))(gen_map)
if self.dropout != 0:
gen_map = Dropout(self.dropout)(gen_map)
# Output statistics for the generative model
gen_mu = TimeDistributed(Dense(self.data_dim,
activation="linear"))(gen_map)
gen_sigma = TimeDistributed(Dense(self.data_dim,
activation="softplus"))(gen_map)
# Combined model
output = merge([gen_mu, gen_sigma, z_post_stats, z_prior_stats],
mode='concat')
inputs = [x_t, x_tm1] if self.with_trending_prior else [
x_t, x_tm1, z_prior_stats
]
model = Model(input=inputs, output=output)
model.compile(optimizer='rmsprop', loss=keras_variational)
# metrics=[keras_gauss, keras_divergence, mu_minus_x, mean_sigma]
return model
recog_right=recog
recog_right.add(Dense(64,input_shape=(64,),activation='relu'))
recog_right.add(Lambda(lambda x: x + K.exp(x / 2) * K.random_normal(shape=(1, 64), mean=0.,
std=epsilon_std), output_shape=(64,)))
recog_right.add(Highway())
recog_right.add(Activation('sigmoid'))
recog1=Sequential()
recog1.add(Merge([recog_left,recog_right],mode = 'ave'))
recog1.add(Dense(784))
recog1.add(Activation('relu'))
#### GATE***
recog11=Sequential()
layer=Dense(2,init='glorot_uniform',input_shape=(784,))
layer.trainable=False
recog11.add(layer)
layer2=Dense(784, activation='sigmoid',init='glorot_uniform')
layer2.trainable=True
recog11.add(layer2)
recog11.layers[0].W.set_value(np.ones((784,2)).astype(np.float32))
recog11.compile(loss='mean_squared_error', optimizer=sgd,metrics = ['mae'])
recog11.get_weights()[0].shape
gan_input = Input(batch_shape=(1,784))
gan_level2 = recog11(recog1(gan_input))
test_label_data_path,
dev_emb_data_path, dev_tag_data_path,
dev_label_data_path)
# read config
sentence_words_num = int(getConfig('cnn', 'WORDS_DIM'))
word_vector_dim = int(getConfig('cnn', 'VEC_DIM'))
# end config
model = Sequential()
model.add(Conv1D(500, 3, activation='relu', input_shape=(300, 900)))
model.add(MaxPooling1D(3))
model.add(Dropout(1.0))
model.add(Flatten())
model.add(Dense(11, activation='softmax'))
# sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy'])
# test
early_stopping = EarlyStopping(monitor='acc', patience=3, mode='max')
model.fit(x_train, y_train, batch_size=128, epochs=50, callbacks=[early_stopping])
score_test = model.evaluate(x_test, y_test, batch_size=64)
print 'loss=', score_test[0], ' acc=', score_test[1]
# dev
score_dev = model.evaluate(x_dev, y_dev, batch_size=64)
print 'dev loss=', score_dev[0], ' acc=', score_dev[1]
mnist = keras.datasets.mnist
# x_train is the list of images y_train is the labels assigned to each image
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Normalise values to range (0,1)
x_train, x_test = x_train / 255.0, x_test / 255.0
y_train = K.cast(y_train, 'float32')
y_test = K.cast(y_test, 'float32')
model = Sequential()
# optimizer='adam'
# (28,28) represents the dimensions of image in pixels
input_layer = Flatten(input_shape=(28, 28))
model.add(input_layer)
# Activation function is relu
hidden_layer_1 = Dense(128, activation='relu')
model.add(hidden_layer_1)
# Percentage of nodes destroyed
hidden_layer_2 = Dropout(0.3)
model.add(hidden_layer_2)
# Activation function is softmax
output_layer = Dense(10, activation='softmax')
model.add(output_layer)
# Define custom loss
def custom_loss(layer):
# Create a loss function that adds the MSE loss to the mean of all squared activations of a specific layer
def loss(y_true, y_pred):
ad = Adam(lr=0.00005)
input_context = Input(shape=(maxlen_input,), dtype='int32')#, name='input_context')
input_answer = Input(shape=(maxlen_input,), dtype='int32')#, name='input_answer')
LSTM_encoder = LSTM(sentence_embedding_size, kernel_initializer= 'lecun_uniform')
LSTM_decoder = LSTM(sentence_embedding_size, kernel_initializer= 'lecun_uniform')
if os.path.isfile(weights_file):
Shared_Embedding = Embedding(output_dim=word_embedding_size, input_dim=dictionary_size, input_length=maxlen_input)
else:
Shared_Embedding = Embedding(output_dim=word_embedding_size, input_dim=dictionary_size, weights=[embedding_matrix], input_length=maxlen_input)
word_embedding_context = Shared_Embedding(input_context)
context_embedding = LSTM_encoder(word_embedding_context)
# LSTM_encoder_topic = LSTM(topic_embedding_size, kernel_initializer='lecun_uniform')
LSTM_encoder_topic = Dense(topic_embedding_size, activation="relu")
topic_embedding = LSTM_encoder_topic(context_embedding)
word_embedding_answer = Shared_Embedding(input_answer)
answer_embedding = LSTM_decoder(word_embedding_answer)
merge_layer = Concatenate(axis=1)([topic_embedding, context_embedding, answer_embedding])
out = Dense(int(dictionary_size/2), activation="relu")(merge_layer)
out = Dense(dictionary_size, activation="softmax")(out)
model = Model(inputs=[input_context, input_answer], outputs = [out])
checkpoint = ModelCheckpoint(weights_file, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
# model.add(MaxPooling2D((2,2), strides=(2,2)))
# model.add(Convolution2D(512, kernel_size=3, strides=3, activation='relu', padding='same'))
# model.add(Convolution2D(512, kernel_size=3, strides=3, activation='relu', padding='same'))
# model.add(Convolution2D(512, kernel_size=3, strides=3, activation='relu', padding='same'))
# model.add(Convolution2D(512, kernel_size=3, strides=3, activation='relu', padding='same'))
# model.add(MaxPooling2D((2,2), strides=(2,2)))
# model.add(Convolution2D(512, kernel_size=3, strides=3, activation='relu', padding='same'))
# model.add(Convolution2D(512, kernel_size=3, strides=3, activation='relu', padding='same'))
# model.add(Convolution2D(512, kernel_size=3, strides=3, activation='relu', padding='same'))
# model.add(Convolution2D(512, kernel_size=3, strides=3, activation='relu', padding='same'))
# model.add(MaxPooling2D((2,2), strides=(2,2)))
model.add(Flatten())
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1000, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# COMPILING MODEL
model.compile(loss='mean_squared_logarithmic_error',
optimizer='Adam',
metrics=['accuracy'])
# FITTING THE MODEL ON TRAINING DATA USING TESTING DATA AS VALIDATION DATA
# STORING THE RETURNED HISTORY OBJECT FOR CALLING HISTORY FUNCTION LATER
# PASSING CALLBACK VARIABLE TO UPDATE EVENT LOG FILE
cnn_model = Sequential([
Conv2D(filters=64, kernel_size=3, activation='relu', input_shape=IM_SHAPE),
MaxPooling2D(pool_size=2),
BatchNormalization(),
# Conv2D(filters = 128, kernel_size = 3, activation = 'relu', input_shape = IM_SHAPE),
# MaxPooling2D(pool_size = 2),
# BatchNormalization(),
Conv2D(filters=128, kernel_size=3, activation='relu',
input_shape=IM_SHAPE),
MaxPooling2D(pool_size=2),
Conv2D(filters=64, kernel_size=3, activation='relu', input_shape=IM_SHAPE),
MaxPooling2D(pool_size=2),
Flatten(),
Dense(1024, activation='relu'),
Dropout(0.2),
BatchNormalization(),
Dense(1024, activation='relu'),
Dropout(0.2),
BatchNormalization(),
Dense(256, activation='relu'),
Dropout(0.2),
BatchNormalization(),
Dense(NUM_CLASSES, activation='softmax')
])
cnn_model.compile(loss='sparse_categorical_crossentropy',
optimizer=Adam(lr=0.001),
metrics=['accuracy'])
model.add(MaxPooling2D(pool_size=(5,5), strides=(2, 2))) #2nd convolution layer model.add(Conv2D(64, (3, 3), activation='relu')) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(AveragePooling2D(pool_size=(3,3), strides=(2, 2))) #3rd convolution layer model.add(Conv2D(128, (3, 3), activation='relu')) model.add(Conv2D(128, (3, 3), activation='relu')) model.add(AveragePooling2D(pool_size=(3,3), strides=(2, 2))) model.add(Flatten()) #fully connected neural networks model.add(Dense(1024, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(1024, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(num_classes, activation='softmax')) # visualise model model.summary() #optimiser and loss function model.compile(loss='categorical_crossentropy', optimizer='Adam', metrics=['accuracy']) # training the model
clf = Sequential()
# Convolution
clf.add(Convolution2D(32, (3, 3), input_shape = (64, 64,3), activation = 'relu'))
# Max pooling
clf.add(MaxPooling2D(pool_size = (2,2)))
# Second convolution
clf.add(Convolution2D(32, (3,3), activation = 'relu'))
# Flattening
clf.add(Flatten())
# Full connection
clf.add(Dense(units = 128, activation = 'relu'))
clf.add(Dense(units = 128, activation = 'relu'))
clf.add(Dense(units = 1, activation = 'sigmoid'))
clf.compile(optimizer = "adam", loss = "binary_crossentropy",
metrics = ['accuracy'])
# Image preprocessing
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(
rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
# Step 1 - Convolution
classifier.add(Conv2D(32, (3, 3), input_shape = (256, 256, 3), activation = 'relu'))
# Step 2 - Pooling
classifier.add(MaxPooling2D(pool_size = (2, 2)))
# Adding a second convolutional layer
classifier.add(Conv2D(32, (3, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
# Step 3 - Flattening
classifier.add(Flatten())
# Step 4 - Full connection
classifier.add(Dropout(0.3))
classifier.add(Dense(units=256,activation='relu'))
classifier.add(Dropout(0.5))
classifier.add(Dense(units =1, activation = 'softmax'))
# Compiling the CNN
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
# Part 2 - Fitting the CNN to the images
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale = 1./255)
test_datagen = ImageDataGenerator(rescale = 1./255)
validation_datagen = ImageDataGenerator(rescale=1/255)
training_set = train_datagen.flow_from_directory('C:\\Users\\thswl\\Desktop\\cat_dog\\cat_dog\\train',
target_size = (256, 256),
def call(self, x): et = TimeDistributed(Dense(1, activation="tanh"), input_shape=(40, 512))(x) alphat = K.exp(et) weights = alphat / K.cast(K.sum(alphat, axis=1, keepdims=True) + K.epsilon(), K.floatx()) weighted_input = x*weights return K.sum(weighted_input, axis=1)
def ngramCNN():
train = pd.read_csv("./Data/train/train.csv", header=None, sep="|", names=["raw_str"])
label = pd.read_csv("./Data/train/train_label.csv", sep=",")
# test = pd.read_csv("./Data/test/test.csv", header=None, sep="|", names=["raw_str"])
train_sub = train.sample(frac=0.1, replace=True, random_state=5242)
label_sub = label.sample(frac=0.1, replace=True, random_state=5242)
label_sub.drop('sample_id', axis=1, inplace=True)
print('Shape of the sub train data: ', train_sub.shape)
print('Shape of the sub label data: ', label_sub.shape)
# print('Shape of the test data: ', test.shape)
print(train_sub.head())
# Apply ngram and Tfidf to
tfidf = TfidfVectorizer(analyzer="word", max_features=5000, ngram_range=(2, 4))
print(tfidf)
train_transformed = tfidf.fit_transform(train_sub.raw_str)
train_transformed = train_transformed.toarray() # reshape (N, 5000) to (N, 5000, 1)
train_transformed = train_transformed.reshape(
(train_transformed.shape[0], train_transformed.shape[1], 1))
# test_transformed = tfidf.fit_transform(test.raw_str)
X_train, X_val, y_train, y_val = train_test_split(train_transformed,
label_sub,
test_size=0.05,
random_state=5242)
X_max_len = X_train.shape[1]
print('Shape of the sub train data: ', X_train.shape)
print('Shape of the sub train label: ', y_train.shape)
tensorBoardCallback = TensorBoard(log_dir='./logs/ngram_cnn', write_graph=True)
# model = SentimentAnalysisConv(X_train.shape[1])
model = Sequential()
# embedding_layer = Embedding(1, 1, input_length=X_train.shape[1], mask_zero=False)
# model.add(embedding_layer)
model.add(Convolution1D(128, 50, input_shape=(X_max_len, 1), strides=50, padding='same'))
model.add(Flatten())
model.add(Dropout(0.2))
model.add(Dense(128, activation='sigmoid'))
model.add(Dropout(0.2))
model.add(Dense(1, activation='sigmoid'))
model.summary()
early_stopping = EarlyStopping(monitor='val_loss', patience=3)
model.compile(loss='binary_crossentropy', optimizer=RMSprop(), metrics=['accuracy'])
model.fit(X_train,
y_train,
batch_size=64,
epochs=10,
verbose=1,
callbacks=[early_stopping, tensorBoardCallback],
validation_data=(X_val, y_val))
score, acc = model.evaluate(X_val, y_val, verbose=2, batch_size=64)
print("score: %.2f" % (score))
print("acc: %.2f" % (acc))
def train(run_name, start_epoch, stop_epoch, img_w):
# Input Parameters
img_h = 64
words_per_epoch = 16000
val_split = 0.2
val_words = int(words_per_epoch * (val_split))
# Network parameters
conv_filters = 16
kernel_size = (3, 3)
pool_size = 2
time_dense_size = 32
rnn_size = 512
minibatch_size = 32
if K.image_data_format() == 'channels_first':
input_shape = (1, img_w, img_h)
else:
input_shape = (img_w, img_h, 1)
img_gen = TextImageGenerator(
monogram_file='train.txt', # 定长数据
bigram_file='train.txt',# 不定长数据，这个暂时没用上
minibatch_size=minibatch_size,
img_w=img_w,
img_h=img_h,
downsample_factor=(pool_size ** 2),
val_split=words_per_epoch - val_words)
act = 'relu'
input_data = Input(name='the_input', shape=input_shape, dtype='float32')
inner = Conv2D(conv_filters, kernel_size, padding='same',
activation=act, kernel_initializer='he_normal',
name='conv1')(input_data)
inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max1')(inner)
inner = Conv2D(conv_filters, kernel_size, padding='same',
activation=act, kernel_initializer='he_normal',
name='conv2')(inner)
inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max2')(inner)
conv_to_rnn_dims = (img_w // (pool_size ** 2),
(img_h // (pool_size ** 2)) * conv_filters)
inner = Reshape(target_shape=conv_to_rnn_dims, name='reshape')(inner)
# cuts down input size going into RNN:
inner = Dense(time_dense_size, activation=act, name='dense1')(inner)
# Two layers of bidirectional GRUs
# GRU seems to work as well, if not better than LSTM:
gru_1 = GRU(rnn_size, return_sequences=True,
kernel_initializer='he_normal', name='gru1')(inner)
gru_1b = GRU(rnn_size, return_sequences=True,
go_backwards=True, kernel_initializer='he_normal',
name='gru1_b')(inner)
gru1_merged = add([gru_1, gru_1b])
gru_2 = GRU(rnn_size, return_sequences=True,
kernel_initializer='he_normal', name='gru2')(gru1_merged)
gru_2b = GRU(rnn_size, return_sequences=True, go_backwards=True,
kernel_initializer='he_normal', name='gru2_b')(gru1_merged)
# transforms RNN output to character activations:
inner = Dense(img_gen.get_output_size(), kernel_initializer='he_normal',
name='dense2')(concatenate([gru_2, gru_2b]))
y_pred = Activation('softmax', name='softmax')(inner)
# Model(inputs=input_data, outputs=y_pred).summary()
Model(inputs=input_data, outputs=y_pred)
labels = Input(name='the_labels',
shape=[img_gen.absolute_max_string_len], dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
# Keras doesn't currently support loss funcs with extra parameters
# so CTC loss is implemented in a lambda layer
loss_out = Lambda(
ctc_lambda_func, output_shape=(1,),
name='ctc')([y_pred, labels, input_length, label_length])
# clipnorm seems to speeds up convergence
sgd = SGD(lr=0.02, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
model = Model(inputs=[input_data, labels, input_length, label_length],
outputs=loss_out)
# the loss calc occurs elsewhere, so use a dummy lambda func for the loss
model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd)
if start_epoch > 0:
weight_file = os.path.join(
OUTPUT_DIR,
os.path.join(run_name, 'weights%02d.h5' % (start_epoch - 1)))
model.load_weights(weight_file)
# captures output of softmax so we can decode the output during visualization
test_func = K.function([input_data], [y_pred])
viz_cb = VizCallback(run_name, test_func, img_gen.next_val())
model.fit_generator(
generator=img_gen.next_train(),
steps_per_epoch=(words_per_epoch - val_words) // minibatch_size,
epochs=stop_epoch,
validation_data=img_gen.next_val(),
validation_steps=val_words // minibatch_size,
callbacks=[viz_cb, img_gen],
initial_epoch=start_epoch)
def execute_model_21(data):
#-----------------------------------------------------------------------------
# Data Preparation
#-----------------------------------------------------------------------------
### add address of the dataset
'''
loc = ("https://github.com/CIDARLAB/neural-optimizer/transfer_learning/dataset/DAFD_transfer_learning_regime_2.xlsx")
### Read data
wb = xlrd.open_workbook(loc)
sheet = wb.sheet_by_index(0)
### Extract input and output
X=[]
Y=[]
for i in range(1,sheet.nrows): ## data
X.append(sheet.row_values(i))
Y.append(sheet.cell_value(i,12)) ## Regimes
X=np.array(X)
X=X[:,1:9] # Geometry Features
Y=np.array(Y) # Regime labels
X1=[] #Regime 1 data-set
X2=[] #Regime 2 data-set
Y11=[] # Regime 1 Output 1 (generation rate)
Y12=[] # Regime 1 Output 2 (size)
Y21=[] # Regime 2 Output 1 (generation rate)
Y22=[] # Regime 2 Output 2 (size)
for i in range(len(Y)):
if Y[i]==1 :
X1.append(X[i,:])
Y11.append(sheet.cell_value(i+1,10))
Y12.append(sheet.cell_value(i+1,11))
elif Y[i]==2 :
X2.append(X[i,:])
Y21.append(sheet.cell_value(i+1,10))
Y22.append(sheet.cell_value(i+1,11))
'''
X2 = data[['Orifice width', 'Aspect ratio', 'Expansion ratio', 'Normalized orifice length',
'Normalized water inlet', 'Normalized oil inlet', 'Flow rate ratio', 'capillary']]
Y21 = data['Rate']
###train-test split
validation_size = 0.20
X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X2, Y21, test_size=validation_size) #Regime 2 Output 1
###data scaling
scaler=StandardScaler().fit(X_train)
X_train=scaler.transform(X_train)
X_test=scaler.transform(X_test)
X_train =np.array(X_train)
Y_train=np.array(Y_train)
X_test =np.array(X_test)
Y_test =np.array(Y_test)
Y21 = np.array(Y21)
#-----------------------------------------------------------------------------
# Training Nueral Network Model
#-----------------------------------------------------------------------------
### Initializing NN and Define initial structure as the saved model
TLmodel = Sequential()
### load first layer weights and keep unchanged to avoid over-fitting
TLmodel.add(Dense(units = 16, input_dim=8, activation='relu', name='dense_1', trainable=False))
### load second layer weights and keep unchanged to avoid over-fitting
TLmodel.add(Dense(units = 16, activation='relu', name='dense_2', trainable=False))
#TLmodel.add(Dropout(0.4))
#update 3rd layer weights to fit the data
TLmodel.add(Dense(units = 8, activation='relu', name='new_dense3'))
#TLmodel.add(Dropout(0.4))
### update last layer weights to fit the data
TLmodel.add(Dense(units = 1, name='new_dense4'))#, kernel_regularizer=regularizers.l2(0.001)))
#-----------------------------------------------------------------------------
# Load the Pre-Trained Nueral Network Model
#-----------------------------------------------------------------------------
#Load saved weights
TLmodel.load_weights(os.path.join(RESOURCES, 'Y21_weights.h5'), by_name=True)
### Optimizer
adam=optimizers.Adam(lr=0.005)#(lr=0.001,beta_1=0.9, beta_2=0.999, amsgrad=False)
### Compiling the NN
TLmodel.compile(optimizer = adam, loss = 'mean_squared_error',metrics=['mean_squared_error', rmse, r_square] )
### Early stopping
earlystopping=EarlyStopping(monitor="mean_squared_error", patience=10, verbose=1, mode='auto')
### Fitting the model to the train set
result = TLmodel.fit(X_train, Y_train, validation_data=(X_test, Y_test), batch_size = 1, epochs = 400, callbacks=[earlystopping])
#-----------------------------------------------------------------------------
# Predictions of the Trained Nueral Network Model
#-----------------------------------------------------------------------------
### Test-set prediction
y_pred = TLmodel.predict(X_test)
### train-set prediction
y_pred_train = TLmodel.predict(X_train)
mae_score = sklearn.metrics.mean_absolute_error(Y_test,y_pred)
mse_score = sklearn.metrics.mean_squared_error(Y_test,y_pred)
rmse_score = math.sqrt(sklearn.metrics.mean_squared_error(Y_test,y_pred))
r2_score = sklearn.metrics.r2_score(Y_test,y_pred)
print("\n")
print("Mean absolute error (MAE) for test-set: %f" % sklearn.metrics.mean_absolute_error(Y_test,y_pred))
print("Mean squared error (MSE) for test-set: %f" % sklearn.metrics.mean_squared_error(Y_test,y_pred))
print("Root mean squared error (RMSE) for test-set: %f" % math.sqrt(sklearn.metrics.mean_squared_error(Y_test,y_pred)))
print("R square (R^2) for test-set: %f" % sklearn.metrics.r2_score(Y_test,y_pred))
print("\n")
print("Mean absolute error (MAE) for train-set: %f" % sklearn.metrics.mean_absolute_error(Y_train, y_pred_train))
print("Mean squared error (MSE) for train-set: %f" % sklearn.metrics.mean_squared_error(Y_train, y_pred_train))
print("Root mean squared error (RMSE) for train-set: %f" % math.sqrt(sklearn.metrics.mean_squared_error(Y_train, y_pred_train)))
print("R square (R^2) for train-set: %f" % sklearn.metrics.r2_score(Y_train, y_pred_train))
return mae_score, mse_score, rmse_score, r2_score
train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:] # reshape into X=t and Y=t+1, timestep 240 look_back = 240 trainX, trainY = create_dataset(train, look_back) testX, testY = create_dataset(test, look_back) # reshape input to be [samples, time steps, features] trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1])) testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1])) # create and fit the LSTM network, optimizer=adam, 25 neurons, dropout 0.1 model = Sequential() model.add(LSTM(25, input_shape=(1, look_back))) model.add(Dropout(0.1)) model.add(Dense(1)) model.compile(loss='mse', optimizer='adam') model.fit(trainX, trainY, epochs=1000, batch_size=240, verbose=1) # make predictions trainPredict = model.predict(trainX) testPredict = model.predict(testX) # invert predictions trainPredict = scaler.inverse_transform(trainPredict) trainY = scaler.inverse_transform([trainY]) testPredict = scaler.inverse_transform(testPredict) testY = scaler.inverse_transform([testY]) # calculate root mean squared error trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))
def fit_modele(self, config, final=False):
"""
Fait un fit rapide (100 itérations par défaut) d'un LSTM selon les
paramètres contenus dans config (h, n, f, d)
"""
resultat = None
key = str(config)
iter = 500 if final else 100 # entraînement final du modèle retenu
nbre_couches = config.get("nbre_couches")
taille = config.get("taille_entree")
nbre_neurones = config.get("nbre_neurones")
activation = config.get("activation")
dropout = config.get("dropout")
nbre_retards = np.count_nonzero(
np.isnan(self.serie.data['Série stationnarisée']))
# MinMaxScaler
donnees_brutes = self.serie.data['Série stationnarisée'][0:self.serie.index_fin_entrainement].dropna(
).values
scaler = MinMaxScaler(feature_range=(-1, 1))
scaler = scaler.fit(np.array(donnees_brutes).reshape(-1, 1))
serie_reduite = scaler.transform(np.array(
self.serie.data['Série stationnarisée'].dropna().values).reshape(-1, 1))
a = np.empty((1, nbre_retards))
a[:] = np.nan
serie_reduite = np.concatenate((a, np.array(serie_reduite)), axis=0)
self.serie.data['Série stationnarisée réduite'] = serie_reduite
X_train, y_train = decouper_serie_apprentissage_supervise(
self.serie.data['Série stationnarisée réduite'][0:self.serie.index_fin_entrainement].dropna().values, taille)
X_test, y_test = decouper_serie_apprentissage_supervise(
self.serie.data['Série stationnarisée réduite'][self.serie.index_fin_entrainement:self.serie.index_fin_test].dropna().values, taille)
n_features = 1 # une variable explicative
X_train = X_train.reshape(
(X_train.shape[0], X_train.shape[1], n_features))
X_test = X_test.reshape(
(X_test.shape[0], X_test.shape[1], n_features))
# Création du réseau de neurones
model = Sequential()
# couche d'entrée
for i in range(0, nbre_couches):
model.add(kLSTM(nbre_neurones, activation=activation, return_sequences=True,
input_shape=(taille, n_features)))
model.add(Dropout(dropout)) # ajout d'un dropout
# dernière couche (pas de retour)
model.add(kLSTM(nbre_neurones, activation=activation))
model.add(Dropout(dropout)) # ajout d'un dropout
# couche de sortie (1 dimension)
model.add(Dense(1))
methode_optimisation = optimizers.Nadam()
model.compile(optimizer=methode_optimisation,
loss='mse')
# Critère d'arret prématuré, aucune amélioration sur le jeu de test
# pendant plus de 20 itérations
critere_stop = EarlyStopping(
monitor='val_loss', min_delta=0, patience=20)
# Fit du modèle
historique = model.fit(
X_train, y_train, validation_data=(X_test, y_test), epochs=iter, verbose=final, callbacks=[critere_stop], shuffle=False)
if final: # sauvegarde de l'historique d'entrainement si modèle final
self.historique = historique
# Prédiction sur jeu de test + validation
serie_predite = []
serie_predite_temp = [] # stock les prédictions réduites
serie_predite_dynamique = []
# walk-forward validation (one step ahead)
for i in range(0, len(self.serie.data['Test'].dropna())+len(self.serie.data['Validation'].dropna())):
x_input = self.serie.data['Série stationnarisée réduite'][self.serie.index_fin_entrainement -
taille+i:self.serie.index_fin_entrainement+i].values
x_input = x_input.reshape((1, taille, n_features))
yhat = model.predict(x_input, verbose=0)[0][0]
serie_predite_temp.append(yhat)
# inversion de la mise à l'échelle
padding = np.zeros(taille-1).reshape(1, taille - 1)
yhat = np.append(padding, [yhat]).reshape(1, -1)
yhat = scaler.inverse_transform(yhat)
yhat = yhat[0][-1]
# déstationnarisation
yhat = yhat + \
self.serie.data['Série'][self.serie.index_fin_entrainement+i-nbre_retards]
serie_predite.append(yhat)
# prévision dynamique
if final:
anciennes_predictions = []
for i in range(0, len(self.serie.data['Test'].dropna())+len(self.serie.data['Validation'].dropna())):
decoupe = -taille + i
if decoupe < 0:
x_input_dynamique = np.append(
self.serie.data['Série stationnarisée réduite'][decoupe:].values, anciennes_predictions)
else:
x_input_dynamique = np.array(anciennes_predictions)[-taille:]
x_input_dynamique = x_input_dynamique.reshape(
(1, taille, n_features))
yhat_dynamique = model.predict(
x_input_dynamique, verbose=0)[0][0]
anciennes_predictions.append(yhat_dynamique)
# inversion de la mise à l'échelle
padding = np.zeros(taille-1).reshape(1, taille - 1)
yhat_dynamique = np.append(
padding, [yhat_dynamique]).reshape(1, -1)
yhat_dynamique = scaler.inverse_transform(yhat_dynamique)
yhat_dynamique = yhat_dynamique[0][-1]
# déstationnarisation
yhat_dynamique = yhat_dynamique + \
self.serie.data['Série'][self.serie.index_fin_entrainement+i-nbre_retards]
serie_predite_dynamique.append(yhat_dynamique)
# ajout d'un padding avec des nan
a = np.empty((1, len(self.serie.data['Entraînement'].dropna())))
a[:] = np.nan
serie_predite = np.concatenate((a[0], np.array(serie_predite)), axis=0)
# calcul du MSE uniquement sur le jeu de test
resultat = mean_squared_error(
serie_predite[self.serie.index_fin_entrainement:self.serie.index_fin_test], self.serie.data['Test'].dropna())
if final:
self.serie.data[self.__class__.__name__] = serie_predite
# ajout d'un padding avec des nan
a = np.empty((1, len(self.serie.data['Entraînement'].dropna())))
a[:] = np.nan
serie_predite_dynamique = np.concatenate(
(a[0], np.array(serie_predite_dynamique)), axis=0)
self.serie.data[self.__class__.__name__ +
"_dynamique"] = serie_predite_dynamique
self.modele = model
print("Fit du modèle " + key + " : " + str(resultat))
return (key, resultat)
model = Sequential()
#model.add(Convolution2D(32, 3, 3, border_mode='same',input_shape=(150,150,1)))
model.add(Convolution2D(32, 3, 3, border_mode='same',input_shape=(1,150,150)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2),strides=(2,2)))
model.add(Convolution2D(32, 3, 3, border_mode='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2),strides=(2,2)))
model.add(Convolution2D(32, 3, 3, border_mode='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2),strides=(2,2)))
model.add(Flatten())
model.add(Dense(4096))
model.add(Activation('relu'))
model.add(Dense(1024))
model.add(Activation('relu'))
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.load_weights("/home/shiv/Desktop/Major1/weights.hdf5")
model.compile(loss='mse', optimizer=sgd, metrics=['accuracy'])
getResults()
def train(self):
df_tokens_train = parallelize_dataframe(self.df_train, get_sentence_df_content, 10)
df_tokens_test = parallelize_dataframe(self.df_test, get_sentence_df_content, 10)
wv_title_feature_train = df_tokens_train['title_tokens'].progress_apply(self.get_sentence_mean_embedding)
wv_content_feature_train = df_tokens_train['content_tokens'].progress_apply(self.get_sentence_mean_embedding)
wv_title_feature_test = df_tokens_test['title_tokens'].progress_apply(self.get_sentence_mean_embedding)
wv_content_feature_test = df_tokens_test['content_tokens'].progress_apply(self.get_sentence_mean_embedding)
X_train = np.column_stack([
np.array(list(wv_title_feature_train)),
np.array(list(wv_content_feature_train))
])
X_test = np.column_stack([
np.array(list(wv_title_feature_test)),
np.array(list(wv_content_feature_test))
])
print("X_train: ", X_train.shape)
print("y_train: ", self.y_train.shape)
print("X_test: ", X_test.shape)
print("y_test: ", self.y_test.shape)
train_labels = to_categorical(np.asarray(self.y_train))
hier_label_dict = convert_event_category_json_to_dict(self.event_category_json)
label_level = self.get_label_level(hier_label_dict)
hier_label_dict_child = self.get_hier_label_dict_child(hier_label_dict)
parent_label_index_list = self.get_parent_label_index_list(hier_label_dict, self.labels)
coefficient_matrix = self.get_coefficient_matrix(
label_level=label_level,
labels=self.labels.tolist(),
hier_label_dict_child=hier_label_dict_child,
)
model = Sequential()
model.add(Dense(DENSE, input_dim=X_train.shape[1], activation="relu",))
model.add(Dropout(DROPOUT_RATE))
model.add(Dense(train_labels.shape[1], activation='sigmoid'))
model.summary()
def hmlc_rr_loss(y_true, y_pred, penalty=DECAY):
penalty_coefficient = tf.constant(coefficient_matrix, dtype=tf.float32)
y_true = K.stack([y_true] * self.labels.shape[0], axis=2)
y_pred = K.stack([y_pred] * self.labels.shape[0], axis=1)
hmlc_res = K.mean(K.sum(K.square(y_true - y_pred) * penalty_coefficient, axis=-1), axis=-1)
w_child = model.layers[-1].weights[0]
w_parent = tf.gather(model.layers[-1].weights[0], parent_label_index_list, axis=-1)
recursive_regularization = penalty * 0.5 * K.sum(K.square(w_parent - w_child))
return hmlc_res + recursive_regularization
adam = keras.optimizers.Adam(lr=LEARNING_RATE)
model.compile(loss=hmlc_rr_loss,
optimizer=adam,
metrics=['acc'])
history = model.fit(X_train, self.y_train, epochs=30, batch_size=64, validation_data=(X_test, self.y_test))
plt.figure(figsize=(10, 8))
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
# "bo" is for "blue dot"
plt.plot(epochs[1:], loss[1:], '-.', label='Training loss')
# b is for "solid blue line"
plt.plot(epochs, val_loss, '-*', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
y_prob = model.predict(X_test)
y_pred = (y_prob > PROB_RATE).astype(int)
y_labels = np.loadtxt(DATA_DIR + 'fmc_labels.csv', delimiter=',', dtype='str', encoding='utf-8')
hierarchy_graph = DiGraph(convert_event_category_json_to_dict(self.event_category_json))
print("HTC Evaluation:")
h_precision, h_recall, h_fscore = hierarchy_metrics(self.y_test, y_pred, hierarchy_graph, y_labels)
print("h_precision: %2.4f" % h_precision)
print("h_recall: %2.4f" % h_recall)
print("h_fscore: %2.4f" % h_fscore)
hmdscore = get_HMDScore(y_prob=y_prob, y_test=self.y_test, penalty_coefficient=coefficient_matrix,
threshold=HMDSCORE_THRESHOLD)
print("HMDScore : %2.4f" % hmdscore)
from sklearn import datasets
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense
iris = datasets.load_iris()
X = iris.data
y = iris.target
y_binary = to_categorical(y, num_classes=3)
model = Sequential()
model.add(Dense(10, input_dim=4))
model.add(Dense(10))
model.add(Dense(3, activation='softmax'))
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(X, y_binary, epochs=100)
X1 = Dropout(0.2)(X1)
X1 = Activation('relu')(X1)
X2 = concatenate([X, X1])
X2 = GRU(LayerUnits, return_sequences=True)(X1)
X2 = Dropout(0.2)(X2)
X2 = Activation('relu')(X2)
X3 = concatenate( [X2,X] )
X3 = GRU(LayerUnits, return_sequences=True)(X2)
X3 = Dropout(0.2)(X3)
X3 = Activation('relu')(X3)
'''
X_output = Dense(2)(X0)
GRUModel = Model(inputs = [ PPG_input , DIFF1_input , DIFF2_input ], outputs = X_output )
# Compiling
GRUModel.compile(optimizer = 'adam', loss = rmse_loss )
GRUModel.summary()
GRUModel.fit( [PPG_train, DIFF1_input , DIFF2_input] , BP_train, validation_split = 0.1 , epochs = 200, batch_size = 32)
print( 'saving model.....' )
GRUModel.save( path )
print( 'finish saving model.....' )
print( GRUModel.evaluate( PPG_test , BP_test ) )
GRUModel.predict( PPG_test )
def add_top_layers(model, image_size, patch_net='resnet50', block_type='resnet',
depths=[512,512], repetitions=[1,1],
block_fn=bottleneck_org, nb_class=2,
shortcut_with_bn=True, bottleneck_enlarge_factor=4,
dropout=.0, weight_decay=.0001,
add_heatmap=False, avg_pool_size=(7,7), return_heatmap=False,
add_conv=True, add_shortcut=False,
hm_strides=(1,1), hm_pool_size=(5,5),
fc_init_units=64, fc_layers=2):
def add_residual_blocks(block):
for depth,repetition in zip(depths, repetitions):
block = _residual_block(
block_fn, depth, repetition,
dropout=dropout, weight_decay=weight_decay,
shortcut_with_bn=shortcut_with_bn,
bottleneck_enlarge_factor=bottleneck_enlarge_factor)(block)
pool = GlobalAveragePooling2D()(block)
dropped = Dropout(dropout)(pool)
return dropped
def add_vgg_blocks(block):
for depth,repetition in zip(depths, repetitions):
block = _vgg_block(depth, repetition,
dropout=dropout,
weight_decay=weight_decay)(block)
pool = GlobalAveragePooling2D()(block)
dropped = Dropout(dropout)(pool)
return dropped
def add_fc_layers(block):
flattened = Flatten()(block)
dropped = Dropout(dropout)(flattened)
units=fc_init_units
for i in xrange(fc_layers):
fc = Dense(units, kernel_initializer="he_normal",
kernel_regularizer=l2(weight_decay))(dropped)
norm = BatchNormalization()(fc)
relu = Activation('relu')(norm)
dropped = Dropout(dropout)(relu)
units /= 2
return dropped, flattened
if patch_net == 'resnet50':
last_kept_layer = model.layers[-5]
elif patch_net == 'yaroslav':
last_kept_layer = model.layers[-3]
else:
last_kept_layer = model.layers[-4]
block = last_kept_layer.output
channels = 1 if patch_net == 'yaroslav' else 3
image_input = Input(shape=(image_size[0], image_size[1], channels))
model0 = Model(inputs=model.inputs, outputs=block)
block = model0(image_input)
if add_heatmap or return_heatmap: # add softmax heatmap.
pool1 = AveragePooling2D(pool_size=avg_pool_size,
strides=hm_strides)(block)
if return_heatmap:
dropped = pool1
else:
dropped = Dropout(dropout)(pool1)
clf_layer = model.layers[-1]
clf_weights = clf_layer.get_weights()
clf_classes = clf_layer.output_shape[1]
if return_heatmap:
activation = activations.softmax(x, axis=CHANNEL_AXIS)
else:
activation = 'relu'
heatmap_layer = Dense(clf_classes, activation=activation,
kernel_regularizer=l2(weight_decay))
heatmap = heatmap_layer(dropped)
heatmap_layer.set_weights(clf_weights)
if return_heatmap:
model_heatmap = Model(inputs=image_input, outputs=heatmap)
return model_heatmap
block = MaxPooling2D(pool_size=hm_pool_size)(heatmap)
top_layer_nb = 8
else:
top_layer_nb = 2
if add_conv:
if block_type == 'resnet':
block = add_residual_blocks(block)
elif block_type == 'vgg':
block = add_vgg_blocks(block)
else:
raise Exception('Unsupported block type: ' + block_type)
else:
block, flattened = add_fc_layers(block)
if add_shortcut and not add_conv:
dense = Dense(nb_class, kernel_initializer="he_normal",
kernel_regularizer=l2(weight_decay))(block)
shortcut = Dense(nb_class, kernel_initializer="he_normal",
kernel_regularizer=l2(weight_decay))(flattened)
addition = add([dense, shortcut])
dense = Activation('softmax')(addition)
else:
dense = Dense(nb_class, kernel_initializer="he_normal",
activation='softmax',
kernel_regularizer=l2(weight_decay))(block)
model_addtop = Model(inputs=image_input, outputs=dense)
# import pdb; pdb.set_trace()
return model_addtop, top_layer_nb
y_test = np_utils.to_categorical(y_test, 10)
# keras callbacks
# earlystop = keras.callbacks.EarlyStopping(monitor='val_loss',
# min_delta=0,
# patience=5,
# verbose=0, mode='auto')
# callback_list = [earlystop]
# Neural network architecture
for (optimizer, optimizer_name) in zip([keras.optimizers.Adamax()],
["Adamax"]):
nn = Sequential()
nn.add(
Dense(initial_layer_neurons,
activation='relu',
input_shape=x_train.shape[1:],
kernel_initializer=kernel_initializer))
if dropout != 0.:
nn.add(Dropout(dropout))
if batch_normalization:
nn.add(BatchNormalization())
for i in range(layers):
nn.add(
Dense(
neurons,
activation='relu',
kernel_regularizer=keras.regularizers.l2(regularization)))
if dropout != 0.:
nn.add(Dropout(dropout))
if batch_normalization:
nn.add(BatchNormalization())
model.add(Dropout(0.5,trainable='False'))
model.add(Dense(10,trainable='False'))
model.add(Activation('softmax',trainable='False'))
# LOADING WEIGHTS TO FINE-TUNNE THEM
model.load_weights(weights_path)
pop_layer(model)
pop_layer(model)
# for layer in model.layers:
# layer.trainable= False
nb_classes=13
layer_last=Dense(nb_classes)
layer_last.trainable=True
layer_last2=Activation('softmax')
layer_last2.trainable=True
model.add(layer_last)
model.add(layer_last2)
print(model.summary())
# let's train the model using SGD + momentum (how original).
#sgd = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer="sgd",
###Test parameters: sample_width = 5 nb_train_samples = 20000 nb_test_samples = 1000 ###Making the layers: labels = tf.placeholder(tf.float32, shape=(None,1)) features = tf.placeholder(tf.float32, shape=(None,sample_width)) from keras.models import Sequential from keras.layers import Dense import random model = Sequential() first_layer = Dense(20, activation='sigmoid', input_shape=(None,sample_width)) first_layer.set_input(features) model.add(first_layer) model.add(Dense(1, activation='sigmoid')) output_layer = model.output ###making training data & test data: train_features = np.random.randn(nb_train_samples, sample_width) train_labels = np.zeros(nb_train_samples).reshape(nb_train_samples, 1) test_features = np.random.randn(nb_test_samples, sample_width) test_labels = np.zeros(nb_test_samples).reshape(nb_test_samples, 1) train_ones = 0 test_ones = 0
def build_model(self):
# image process
image = Input(shape=self.state_size)
image_process = BatchNormalization()(image)
image_process = TimeDistributed(
Conv2D(32, (8, 8),
activation='elu',
padding='same',
kernel_initializer='he_normal'))(image_process)
image_process = TimeDistributed(MaxPooling2D((2, 2)))(image_process)
image_process = TimeDistributed(
Conv2D(32, (5, 5),
activation='elu',
kernel_initializer='he_normal'))(image_process)
image_process = TimeDistributed(MaxPooling2D((2, 2)))(image_process)
image_process = TimeDistributed(
Conv2D(16, (3, 3),
activation='elu',
kernel_initializer='he_normal'))(image_process)
image_process = TimeDistributed(MaxPooling2D((2, 2)))(image_process)
image_process = TimeDistributed(
Conv2D(8, (1, 1), activation='elu',
kernel_initializer='he_normal'))(image_process)
image_process = TimeDistributed(Flatten())(image_process)
image_process = GRU(64, kernel_initializer='he_normal',
use_bias=False)(image_process)
image_process = BatchNormalization()(image_process)
image_process = Activation('tanh')(image_process)
# vel process
vel = Input(shape=[self.vel_size])
vel_process = Dense(6, kernel_initializer='he_normal',
use_bias=False)(vel)
vel_process = BatchNormalization()(vel_process)
vel_process = Activation('tanh')(vel_process)
# state process
state_process = Concatenate()([image_process, vel_process])
# Critic
Qvalue1 = Dense(128, kernel_initializer='he_normal',
use_bias=False)(state_process)
Qvalue1 = BatchNormalization()(Qvalue1)
Qvalue1 = ELU()(Qvalue1)
Qvalue1 = Dense(128, kernel_initializer='he_normal',
use_bias=False)(Qvalue1)
Qvalue1 = BatchNormalization()(Qvalue1)
Qvalue1 = ELU()(Qvalue1)
Qvalue1 = Dense(self.action_size,
kernel_initializer=tf.random_uniform_initializer(
minval=-3e-3, maxval=3e-3))(Qvalue1)
Qvalue2 = Dense(128, kernel_initializer='he_normal',
use_bias=False)(state_process)
Qvalue2 = BatchNormalization()(Qvalue2)
Qvalue2 = ELU()(Qvalue2)
Qvalue2 = Dense(128, kernel_initializer='he_normal',
use_bias=False)(Qvalue2)
Qvalue2 = BatchNormalization()(Qvalue2)
Qvalue2 = ELU()(Qvalue2)
Qvalue2 = Dense(self.action_size,
kernel_initializer=tf.random_uniform_initializer(
minval=-3e-3, maxval=3e-3))(Qvalue2)
Qvalue3 = Dense(128, kernel_initializer='he_normal',
use_bias=False)(state_process)
Qvalue3 = BatchNormalization()(Qvalue3)
Qvalue3 = ELU()(Qvalue3)
Qvalue3 = Dense(128, kernel_initializer='he_normal',
use_bias=False)(Qvalue3)
Qvalue3 = BatchNormalization()(Qvalue3)
Qvalue3 = ELU()(Qvalue3)
Qvalue3 = Dense(self.action_size,
kernel_initializer=tf.random_uniform_initializer(
minval=-3e-3, maxval=3e-3))(Qvalue3)
critic = Model(inputs=[image, vel],
outputs=[Qvalue1, Qvalue2, Qvalue3])
critic._make_predict_function()
return critic
class Attention(Model):
"""Implements standard attention.
Given some memory, a memory mask and a query, outputs the weighted memory cells.
"""
def __init__(self, memory_cells, query, project_query=False):
"""Define Attention.
Args:
memory_cells (SequenceBatch): a SequenceBatch containing a Tensor of shape (batch_size, num_cells, cell_dim)
query (Tensor): a tensor of shape (batch_size, query_dim).
project_query (bool): defaults to False. If True, the query goes through an extra projection layer to
coerce it to cell_dim.
"""
cell_dim = memory_cells.values.get_shape().as_list()[2]
if project_query:
# project the query up/down to cell_dim
self._projection_layer = Dense(cell_dim, activation='linear')
query = self._projection_layer(query) # (batch_size, cand_dim)
memory_values, memory_mask = memory_cells.values, memory_cells.mask
# batch matrix multiply to compute logit scores for all choices in all batches
query = tf.expand_dims(query, 2) # (batch_size, cell_dim, 1)
logit_values = tf.batch_matmul(memory_values, query) # (batch_size, num_cells, 1)
logit_values = tf.squeeze(logit_values, [2]) # (batch_size, num_cells)
# set all pad logits to negative infinity
logits = SequenceBatch(logit_values, memory_mask)
logits = logits.with_pad_value(-float('inf'))
# normalize to get probs
probs = tf.nn.softmax(logits.values) # (batch_size, num_cells)
retrieved = tf.batch_matmul(tf.expand_dims(probs, 1), memory_values) # (batch_size, 1, cell_dim)
retrieved = tf.squeeze(retrieved, [1]) # (batch_size, cell_dim)
self._logits = logits.values
self._probs = probs
self._retrieved = retrieved
@property
def logits(self):
return self._logits # (batch_size, num_cells)
@property
def probs(self):
return self._probs # (batch_size, num_cells)
@property
def retrieved(self):
return self._retrieved # (batch_size, cell_dim)
@property
def projection_weights(self):
"""Get projection weights.
Returns:
(np.array, np.array): a pair of numpy arrays, (W, b) used to project the query tensor to
match the predicate embedding dimension.
"""
return self._projection_layer.get_weights()
@projection_weights.setter
def projection_weights(self, value):
W, b = value
self._projection_layer.set_weights([W, b])
y_validation = keras.utils.to_categorical(y_validation, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
row, col, pixel = x_train.shape[1:]
# 4D input.
x = Input(shape=(row, col, pixel))
# Encodes a row of pixels using TimeDistributed Wrapper.
encoded_rows = TimeDistributed(LSTM(row_hidden))(x)
# Encodes columns of encoded rows.
encoded_columns = LSTM(col_hidden)(encoded_rows)
# Final predictions and model.
prediction = Dense(num_classes, activation='softmax')(encoded_columns)
model = Model(x, prediction)
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
# Training.
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_validation, y_validation))
# Evaluation.
scores = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', scores[0])
def build_models(self, weights_path=None):
# weights_path 如果给出weights_path的话，可以接着训练
# inp_mix_fea_shape (MaxLen(time), feature_dim)
mix_fea_inp = Input(shape=(self.inp_fea_len, self.inp_fea_dim),
name='input_mix_feature')
# inp_mix_spec_shape (MaxLen(time), spectrum_dim)，固定time_steps
mix_spec_inp = Input(shape=(self.inp_fea_len, self.inp_spec_dim),
name='input_mix_spectrum')
# bg_mask_inp = Input(shape=(self.inp_fea_len, self.inp_spec_dim), name='input_bg_mask')
# inp_target_spk_shape (1)
target_spk_inp = Input(shape=(self.inp_spk_len, ),
name='input_target_spk') #这个应该就是说话人的id的数字
# inp_clean_fea_shape (MaxLen(time), feature_dim)，不固定time_steps
# clean_fea_inp = Input(shape=(None, self.inp_fea_dim), name='input_clean_feature') #这个是目标说话人的原始语音，在evaluate的时候应该是不用的
clean_fea_inp = Input(shape=config.ImageSize,
name='input_clean_feature') #输入的单个目标图片
mix_fea_layer = mix_fea_inp
mix_spec_layer = mix_spec_inp
target_spk_layer = target_spk_inp
clean_fea_layer = clean_fea_inp
'''由于图像不存在序列问题，不需要以下的一些mask'''
# if config.IS_LOG_SPECTRAL:
# clean_fea_layer = MaskingGt(mask_value=np.log(np.spacing(1) * 2))(clean_fea_inp)
# else:
# clean_fea_layer = Masking(mask_value=0.)(clean_fea_inp)
'''混合语音抽取的部分保持不变'''
# clean_fea_layer = clean_fea_inp
# 设置了两层 双向 LSTM, 抽取混叠语音的特征
# (None(batch), MaxLen(time), feature_dim) -> (None(batch), None(time), hidden_dim)
for _layer in range(config.NUM_LAYERS):
# 开始累加 LSTM, SIZE_RLAYERS LSTM隐层和输出神经元大小，
mix_fea_layer = \
Bidirectional(LSTM(config.HIDDEN_UNITS, return_sequences=True),
merge_mode='concat')(mix_fea_layer)
# 利用全连接层, 转换到语谱图(t,f)的嵌入维度
# (None(batch), MaxLen(time), hidden_dim) -> (None(batch), MaxLen(time), spec_dim * embed_dim)
mix_embedding_layer = TimeDistributed(
Dense(self.inp_spec_dim * config.EMBEDDING_SIZE,
activation='tanh'))(mix_fea_layer)
# (None(batch), MaxLen(time), spec_dim * embed_dim) -> (None(batch), MaxLen(time), spec_dim, embed_dim)
mix_embedding_layer = Reshape(
(self.inp_fea_len, self.inp_spec_dim,
config.EMBEDDING_SIZE))(mix_embedding_layer)
# 抽取目标说话人纯净语音的特征, 测试阶段为全0
# (Batch,imagesize[0],imagesize[1]) -> (Batch,imageEmbedding)
# TODO: 这块用来设计抽取图像特征所采用的网络
# spk_vector_layer_forImage=image_net(clear_fea_layer)
# spk_vector_layer1=Convolution2D(4, 5, 5, border_mode='valid', input_shape=(1,config.ImageSize[0],config.ImageSize[1]))(clean_fea_layer)
clean_fea_layer = Reshape(
(1, config.ImageSize[0], config.ImageSize[1]))(clean_fea_layer)
spk_vector_layer1 = Convolution2D(4, 5, 5,
border_mode='valid')(clean_fea_layer)
spk_vector_layer1 = Activation('relu')(spk_vector_layer1)
spk_vector_layer1 = MaxPooling2D(pool_size=(2, 2))(spk_vector_layer1)
spk_vector_layer2 = Convolution2D(
8, 3, 3, border_mode='valid')(spk_vector_layer1)
spk_vector_layer2 = Activation('relu')(spk_vector_layer2)
spk_vector_layer2 = MaxPooling2D(pool_size=(2, 2))(spk_vector_layer2)
spk_vector_layer3 = Convolution2D(
16, 3, 3, border_mode='valid')(spk_vector_layer2)
spk_vector_layer3 = Activation('relu')(spk_vector_layer3)
spk_vector_layer3 = MaxPooling2D(pool_size=(2, 2))(spk_vector_layer3)
spk_vector_flatten = Flatten()(spk_vector_layer3)
spk_vector_layer_image = Dense(config.EMBEDDING_SIZE,
init='normal')(spk_vector_flatten)
# 加载并更新到当前的 长时记忆单元中
# [((None(batch), 1), ((None(batch), embed_dim))] -> (None(batch), spk_size, embed_dim)
spk_life_long_memory_layer = SpkLifeLongMemory(
self.spk_size,
config.EMBEDDING_SIZE,
unk_spk=config.UNK_SPK,
name='SpkLifeLongMemory')(
[target_spk_layer, spk_vector_layer_image])
# 抽取当前Batch下的记忆单元
# (None(batch), embed_dim)
spk_memory_layer = SelectSpkMemory(name='SelectSpkMemory')(
[target_spk_layer, spk_life_long_memory_layer])
# 全连接层
# (None(batch), MaxLen(time), hidden_dim) -> (None(batch), MaxLen(time), spec_dim * embed_dim)
# (None(batch), embed_dim) -> (None(batch), embed_dim)
# memory_layer = Dense(config.EMBEDDING_SIZE, activation='tanh')(spk_memory_layer)
# 进行Attention(Masking)计算
# (None(batch), MaxLen(time), spec_dim)
output_mask_layer = Attention(
self.inp_fea_len,
self.inp_spec_dim,
config.EMBEDDING_SIZE,
mode='align',
name='Attention')([
mix_embedding_layer # 这是那个三维的mix语音
,
spk_memory_layer # 这个是memory里得到的目标说话人的声纹
# , memory_layer
# , bg_mask_layer])
])
# 进行masking
# (None(batch), MaxLen(time), spec_dim)
output_clean = merge([output_mask_layer, mix_spec_layer],
mode='mul',
name='target_clean_spectrum')
# 注意，可以有多个输入，多个输出
auditory_model = Model(
input=[mix_fea_inp, mix_spec_inp, target_spk_inp, clean_fea_inp],
output=[output_clean],
name='auditory_model')
# 输出Memory的结果, 用于外部长时记忆单元的更新
spk_memory_model = Model(
input=auditory_model.input,
output=auditory_model.get_layer('SelectSpkMemory').output,
name='spk_vec_model')
# 如果保存过模型的话，可以加载之前的权重继续跑
if weights_path:
print 'Load the trained weights of ', weights_path
self.log_file.write('Load the trained weights of %s\n' %
weights_path)
auditory_model.load_weights(weights_path)
print 'Compiling...'
time_start = time.time()
# 如果采用交叉熵(categorical_crossentropy)的话，输出一定要是0-1之间的概率，那么只能用logistic或softmax做输出
# 如非概率输出的话，可以考虑最小均方误差(mse)等loss, 后面改用概率输出的话，可换成交叉熵
auditory_model.compile(loss='mse', optimizer=self.optimizer)
time_end = time.time()
print 'Compiled, cost time: %f second' % (time_end - time_start)
return auditory_model, spk_memory_model
classifier = Sequential()
# First convolution layer and pooling
classifier.add(
Convolution2D(32, (3, 3), input_shape=(64, 64, 1), activation='relu'))
classifier.add(MaxPooling2D(pool_size=(2, 2)))
# Second convolution layer and pooling
classifier.add(Convolution2D(32, (3, 3), activation='relu'))
# input_shape is going to be the pooled feature maps from the previous convolution layer
classifier.add(MaxPooling2D(pool_size=(2, 2)))
# Flattening the layers
classifier.add(Flatten())
# Adding a fully connected layer
classifier.add(Dense(units=128, activation='relu'))
classifier.add(Dense(units=45,
activation='softmax')) # softmax for more than 2
# Compilation du CNN
classifier.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'
]) # categorical_crossentropy for more than 2
# Step 2 - Preparing the train/test data and training the model
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale=1. / 255,
shear_range=0.2,
_y1 = lstm_layer(embedded_sequences_2)
y1 = lstm_layer2(_y1)
merged = concatenate([x1, y1])
merged = Dropout(rate_drop_dense)(merged)
merged = BatchNormalization()(merged)
merged = Dense(num_dense, activation=act)(merged)
merged = Dropout(rate_drop_dense)(merged)
merged = Dense(num_dense, activation=act)(merged)
merged = Dropout(rate_drop_dense)(merged)
merged = BatchNormalization()(merged)
preds = Dense(1, activation='sigmoid')(merged)
########################################
## add class weight
########################################
if re_weight:
class_weight = {0: 1.309028344, 1: 0.472001959}
else:
class_weight = None
########################################
## train the model
########################################
model = Model(inputs=[sequence_1_input, sequence_2_input], \
outputs=preds)
model.compile(loss='binary_crossentropy',
sent_encode = concatenate([block2, block3], axis=-1)
# sent_encode = Dropout(0.2)(sent_encode)
encoder = Model(inputs=in_sentence, outputs=sent_encode)
encoder.summary()
encoded = TimeDistributed(encoder)(document)
lstm_h = 92
lstm_layer = LSTM(lstm_h, return_sequences=True, dropout=0.1, recurrent_dropout=0.1, implementation=0)(encoded)
lstm_layer2 = LSTM(lstm_h, return_sequences=False, dropout=0.1, recurrent_dropout=0.1, implementation=0)(lstm_layer)
# output = Dropout(0.2)(bi_lstm)
output = Dense(1, activation='sigmoid')(lstm_layer2)
model = Model(outputs=output, inputs=document)
model.summary()
if checkpoint:
model.load_weights(checkpoint)
file_name = os.path.basename(sys.argv[0]).split('.')[0]
check_cb = keras.callbacks.ModelCheckpoint('checkpoints/' + file_name + '.{epoch:02d}-{val_loss:.2f}.hdf5',
monitor='val_loss',
verbose=0, save_best_only=True, mode='min')
earlystop_cb = keras.callbacks.EarlyStopping(monitor='val_loss', patience=5, verbose=0, mode='auto')
def model():
# VGG model initialization with pretrained weights
vgg_model_cari = VGGFace(include_top=True, input_shape=(224, 224, 3))
last_layer_cari = vgg_model_cari.get_layer('pool5').output
for i in vgg_model_cari.layers[0:7]:
i.trainable = False
custom_vgg_model_cari = Model(vgg_model_cari.input, last_layer_cari)
vgg_model_visu = VGGFace(include_top=True, input_shape=(224, 224, 3))
last_layer_visu = vgg_model_visu.get_layer('pool5').output
for i in vgg_model_visu.layers[0:7]:
i.trainable = False
custom_vgg_model_visu = Model(vgg_model_visu.input, last_layer_visu)
# Input of the siamese network : Caricature and Visual images
caricature = Input(shape=(224, 224, 3), name='caricature')
visual = Input(shape=(224, 224, 3), name='visual')
# Get the ouput of the net for caricature and visual images
caricature_net_out = custom_vgg_model_cari(caricature)
caricature_net_out = Flatten()(caricature_net_out)
visual_net_out = custom_vgg_model_visu(visual)
visual_net_out = Flatten()(visual_net_out)
# Merge the two networks by taking the transformation P_C, P_V[Unique transformations of visual & Caricature] and W [shared transformation]
caricature_net_out = Dense(4096, activation="relu")(caricature_net_out)
visual_net_out = Dense(4096, activation="relu")(visual_net_out)
# Unique Layer - Caricature
P_C_layer = Dense(2084, activation="relu", name="P_C_layer")
P_C = P_C_layer(caricature_net_out)
# Unique Layer - Visual
P_V_layer = Dense(2084, activation="relu", name="P_V_layer")
P_V = P_V_layer(visual_net_out)
# Shared layers
W = Dense(
2084, activation="relu", name="W", kernel_initializer='glorot_uniform')
W_C = W(caricature_net_out)
W_V = W(visual_net_out)
d = keras.layers.Concatenate(axis=-1)([W_C, W_V])
d_1 = Dense(2048, activation="relu")(d)
d_2 = Dense(1024, activation="sigmoid")(d_1)
d_3 = Dense(2, activation="softmax", name='verification')(d_2)
# Merge Unique and Shared layers for getting the feature descriptor of the image
feature_caricature = keras.layers.Concatenate(axis=-1)([P_C, W_C])
feature_visual = keras.layers.Concatenate(axis=-1)([P_V, W_V])
# CARICATURE Classification Network - Dense layers
fc1_c = Dense(2048, activation="relu")(feature_caricature)
drop1_c = Dropout(0.6)(fc1_c)
fc2_c = Dense(1024, activation="relu")(drop1_c)
drop2_c = Dropout(0.6)(fc2_c)
fc3_c = Dense(
nb_class, activation="softmax",
name='caricature_classification')(drop2_c)
# VISUAL Classification Network - Dense layers
fc1_v = Dense(2048, activation="relu")(feature_visual)
drop1_v = Dropout(0.6)(fc1_v)
fc2_v = Dense(1024, activation="relu")(drop1_v)
drop2_v = Dropout(0.6)(fc2_v)
fc3_v = Dense(
nb_class, activation="softmax", name='visual_classification')(drop2_v)
model = Model([caricature, visual], [d_3, fc3_c, fc3_v])
return model
train_lable = []
num = len(train_list)
for i in range(num):
#print(random_num[i])
train_data.append(x_train[train_list[i]])
train_lable.append(y_train[train_list[i]])
train_data = np.array(train_data)
train_lable = np.array(train_lable)
print('train_data:',train_data.shape)
dim = train_data.shape[1]
input_img = Input(shape=(dim,))#
model = Sequential()
model.add(Dense(64, activation='elu', input_dim = dim, activity_regularizer=regularizers.l1(10e-5)))
model.add(Dense(32, activation='elu', activity_regularizer=regularizers.l1(10e-5)))
model.add(Dense(64, activation='elu', activity_regularizer=regularizers.l1(10e-5)))
model.add(Dense(dim, activation='elu', activity_regularizer=regularizers.l1(10e-5)))
model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])
model.fit(x_train, x_train, nb_epoch=200, batch_size=64, shuffle=True, verbose=1, validation_split= 0.2)
model.summary()
model.save('my_model.h5')
#------------------------------------
# ----------train adaboost-----------
encode_train_output = K.function([model.layers[0].input], [model.layers[2].output])
train_output = encode_train_output([train_data, 0])[0]
def test_node_construction():
####################################################
# test basics
a = Input(shape=(32,), name='input_a')
b = Input(shape=(32,), name='input_b')
assert a._keras_shape == (None, 32)
a_layer, a_node_index, a_tensor_index = a._keras_history
b_layer, b_node_index, b_tensor_index = b._keras_history
assert len(a_layer._inbound_nodes) == 1
assert a_tensor_index is 0
node = a_layer._inbound_nodes[a_node_index]
assert node.outbound_layer == a_layer
assert isinstance(node.inbound_layers, list)
assert node.inbound_layers == []
assert isinstance(node.input_tensors, list)
assert node.input_tensors == [a]
assert isinstance(node.input_masks, list)
assert node.input_masks == [None]
assert isinstance(node.input_shapes, list)
assert node.input_shapes == [(None, 32)]
assert isinstance(node.output_tensors, list)
assert node.output_tensors == [a]
assert isinstance(node.output_shapes, list)
assert node.output_shapes == [(None, 32)]
assert isinstance(node.output_masks, list)
assert node.output_masks == [None]
dense = Dense(16, name='dense_1')
a_2 = dense(a)
b_2 = dense(b)
assert len(dense._inbound_nodes) == 2
assert len(dense._outbound_nodes) == 0
assert dense._inbound_nodes[0].inbound_layers == [a_layer]
assert dense._inbound_nodes[0].outbound_layer == dense
assert dense._inbound_nodes[1].inbound_layers == [b_layer]
assert dense._inbound_nodes[1].outbound_layer == dense
assert dense._inbound_nodes[0].input_tensors == [a]
assert dense._inbound_nodes[1].input_tensors == [b]
assert dense._inbound_nodes[0].get_config()['inbound_layers'] == ['input_a']
assert dense._inbound_nodes[1].get_config()['inbound_layers'] == ['input_b']
# test layer properties
test_layer = Dense(16, name='test_layer')
a_test = test_layer(a)
assert K.int_shape(test_layer.kernel) == (32, 16)
assert test_layer.input == a
assert test_layer.output == a_test
assert test_layer.input_mask is None
assert test_layer.output_mask is None
assert test_layer.input_shape == (None, 32)
assert test_layer.output_shape == (None, 16)
with pytest.raises(AttributeError):
dense.input
with pytest.raises(AttributeError):
dense.output
with pytest.raises(AttributeError):
dense.input_mask
with pytest.raises(AttributeError):
dense.output_mask
assert dense.get_input_at(0) == a
assert dense.get_input_at(1) == b
assert dense.get_output_at(0) == a_2
assert dense.get_output_at(1) == b_2
assert dense.get_input_shape_at(0) == (None, 32)
assert dense.get_input_shape_at(1) == (None, 32)
assert dense.get_output_shape_at(0) == (None, 16)
assert dense.get_output_shape_at(1) == (None, 16)
assert dense.get_input_mask_at(0) is None
assert dense.get_input_mask_at(1) is None
assert dense.get_output_mask_at(0) is None
assert dense.get_output_mask_at(1) is None
return K.mean(y_pred)
# f = open("data/Cancer Claim Data - X causes cancer.csv", "r")
# df = pd.read_csv(f)
# f.close()
# pu.db
# Y = list(df("X"))
input = Input(shape=(110, 100))
model = Bidirectional(
LSTM(units=50, return_sequences=True,
recurrent_dropout=0.1))(input) # variational biLSTM
model = TimeDistributed(Dense(50, activation="relu"))(
model) # a dense layer as suggested by neuralNer
crf = CRF(1) # CRF layer
out = crf(model) # output
model = Model(input, out)
model.compile(optimizer="rmsprop", loss=crf.loss_function)
model.summary()
# pu.db
Y = keras.utils.to_categorical(Y, num_classes=110)
Y = Y.reshape((Y.shape[0], Y.shape[1], 1))
all_train = all[:int(0.8 * all.shape[0]), ...]
Y_train = Y[:int(0.8 * all.shape[0]), ...]
recog_left.add(Dense(64,input_shape=(64,),activation='relu'))
recog_right=recog
recog_right.add(Dense(64,input_shape=(64,),activation='relu'))
recog_right.add(Lambda(lambda x: x + K.exp(x / 2) * K.random_normal(shape=(1, 64), mean=0.,
std=epsilon_std), output_shape=(64,)))
recog_right.add(Highway())
recog_right.add(Activation('sigmoid'))
recog1=Sequential()
recog1.add(Merge([recog_left,recog_right],mode = 'ave'))
recog1.add(Dense(784))
#### HERE***
recog11=Sequential()
layer=Dense(64,init='glorot_uniform',input_shape=(784,))
layer.trainable=False
recog11.add(layer)
layer2=Dense(784, activation='sigmoid',init='glorot_uniform')
layer2.trainable=False
recog11.add(layer2)
recog11.layers[0].W.set_value(np.ones((784,64)).astype(np.float32))
recog11.compile(loss='mean_squared_error', optimizer=sgd,metrics = ['mae'])
recog11.get_weights()[0].shape
gan_input = Input(batch_shape=(1,784))
gan_level2 = recog11(recog1(gan_input))
X.append([char_to_int[char] for char in sequence])
Y.append(char_to_int[label])
# reshaping, normalizing and one hot encoding
X_modified = numpy.reshape(X, (len(X), 50, 1))
X_modified = X_modified / float(len(unique_chars))
Y_modified = np_utils.to_categorical(Y)
# defining the LSTM model
model = Sequential()
model.add(
LSTM(300,
input_shape=(X_modified.shape[1], X_modified.shape[2]),
return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(300))
model.add(Dropout(0.2))
model.add(Dense(Y_modified.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')
# fitting the model
model.fit(X_modified, Y_modified, epochs=1, batch_size=500)
# picking a random seed
start_index = numpy.random.randint(0, len(X) - 1)
new_string = X[start_index]
# generating characters
for i in range(50):
x = numpy.reshape(new_string, (1, len(new_string), 1))
x = x / float(len(unique_chars))
