def build_part2_RNN(window_size, num_chars):
model = Sequential()
model.add(LSTM(200, input_shape=(window_size, num_chars)))
#model.add(Dropout(0.5))
model.add(Dense(num_chars, activation='softmax'))
return model
def create(self):
language_model = Sequential()
self.textual_embedding(language_model, mask_zero=True)
self.stacked_RNN(language_model)
language_model.add(self._config.recurrent_encoder(
self._config.hidden_state_dim,
return_sequences=False,
go_backwards=self._config.go_backwards))
self.language_model = language_model
visual_model_factory = \
select_sequential_visual_model[self._config.trainable_perception_name](
self._config.visual_dim)
visual_model = visual_model_factory.create()
visual_dimensionality = visual_model_factory.get_dimensionality()
self.visual_embedding(visual_model, visual_dimensionality)
#visual_model = Sequential()
#self.visual_embedding(visual_model)
self.visual_model = visual_model
if self._config.multimodal_merge_mode == 'dot':
self.add(Merge([language_model, visual_model], mode='dot', dot_axes=[(1,),(1,)]))
else:
self.add(Merge([language_model, visual_model], mode=self._config.multimodal_merge_mode))
self.add(Dropout(0.5))
self.add(Dense(self._config.output_dim))
self.add(RepeatVector(self._config.max_output_time_steps))
self.add(self._config.recurrent_decoder(
self._config.hidden_state_dim, return_sequences=True))
self.add(Dropout(0.5))
self.add(TimeDistributedDense(self._config.output_dim))
self.add(Activation('softmax'))
def create(self):
language_model = Sequential()
self.textual_embedding(language_model, mask_zero=True)
self.temporal_pooling(language_model)
language_model.add(DropMask())
#language_model.add(BatchNormalization(mode=1))
self.language_model = language_model
visual_model_factory = \
select_sequential_visual_model[self._config.trainable_perception_name](
self._config.visual_dim)
visual_model = visual_model_factory.create()
visual_dimensionality = visual_model_factory.get_dimensionality()
self.visual_embedding(visual_model, visual_dimensionality)
#visual_model.add(BatchNormalization(mode=1))
self.visual_model = visual_model
if self._config.multimodal_merge_mode == 'dot':
self.add(Merge([language_model, visual_model], mode='dot', dot_axes=[(1,),(1,)]))
else:
self.add(Merge([language_model, visual_model], mode=self._config.multimodal_merge_mode))
self.deep_mlp()
self.add(Dense(self._config.output_dim))
self.add(Activation('softmax'))
def encoders_m(self, inputs):
input_encoder_m = Sequential()
input_encoder_m.add(Embedding(input_dim=self.vocab_size,
output_dim=64))
input_encoder_m.add(Dropout(0.3))
encode_m = input_encoder_m(inputs)
return encode_m
def create(self):
language_model = Sequential()
self.textual_embedding(language_model, mask_zero=True)
self.language_model = language_model
visual_model_factory = \
select_sequential_visual_model[self._config.trainable_perception_name](
self._config.visual_dim)
visual_model = visual_model_factory.create()
visual_dimensionality = visual_model_factory.get_dimensionality()
self.visual_embedding(visual_model, visual_dimensionality)
#visual_model = Sequential()
#self.visual_embedding(visual_model)
# the below should contain all zeros
zero_model = Sequential()
zero_model.add(RepeatVector(self._config.max_input_time_steps)-1)
visual_model.add(Merge[visual_model, zero_model], mode='concat')
self.visual_model = visual_model
if self._config.multimodal_merge_mode == 'dot':
self.add(Merge([language_model, visual_model], mode='dot', dot_axes=[(1,),(1,)]))
else:
self.add(Merge([language_model, visual_model], mode=self._config.multimodal_merge_mode))
self.add(self._config.recurrent_encoder(
self._config.hidden_state_dim,
return_sequences=False,
go_backwards=self._config.go_backwards))
self.deep_mlp()
self.add(Dense(self._config.output_dim))
self.add(Activation('softmax'))
def define_model(lr, momentum):
# CONFIG
model = Sequential()
# Create Layers
# CONVNET
layers = []
#layers.append(GaussianNoise(0.02))
layers.append(Convolution2D(8, 9, 9, activation = "relu", input_shape=(1,100,100)))
layers.append(MaxPooling2D(pool_size=(2,2)))
layers.append(Convolution2D(16, 7, 7, activation = "relu"))
layers.append(MaxPooling2D(pool_size=(2,2)))
layers.append(Convolution2D(32, 5, 5, activation = "relu"))
layers.append(MaxPooling2D(pool_size=(2,2)))
layers.append(Convolution2D(64, 3, 3, activation = "relu"))
layers.append(MaxPooling2D(pool_size=(2,2)))
layers.append(Convolution2D(250, 3, 3, activation= "relu"))
# MLP
layers.append(Flatten())
layers.append(Dense(125, activation="relu"))
layers.append(Dense(2, activation="softmax"))
# Adding Layers
for layer in layers:
model.add(layer)
# COMPILE (learning rate, momentum, objective...)
sgd = SGD(lr=lr, momentum=momentum)
model.compile(loss="categorical_crossentropy", optimizer=sgd)
return model
def train_model():
# (X_train, Y_train, X_test, Y_test) = prapare_train()
X_ = []
with open('../data/train_matrix.out') as train_file:
X_train = json.load(train_file)
for x in X_train:
a = len(x)
print a/2
x1 = x[:a/2]
x2 = x[a/2:]
x3 = []
x3.append(x1)
x3.append(x2)
X_.append(x3)
# X_test = pickle.load('../data/test_matrix.out')
Y_train = [1,0,0]*3
# Y_test = [1,0,0]*3
# print len(X_train) - len(Y_train)
# print len(X_test) - len(Y_test)
model = Sequential()
model = get_nn_model()
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# model.fit(X_train, Y_train,
# batch_size=batch_size,
# nb_epoch=nb_epoch,
# validation_data=(X_test, Y_test))
#2
model.fit(X_, Y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
validation_split = 0.2)
print 'ok'
def getVggModel():
"""Pretrained VGG16 model with fine-tunable last two layers"""
input_image = Input(shape = (160,320,3))
model = Sequential()
model.add(Lambda(lambda x: x/255.0 -0.5,input_shape=(160,320,3)))
model.add(Cropping2D(cropping=((70,25),(0,0))))
base_model = VGG16(input_tensor=input_image, include_top=False)
for layer in base_model.layers[:-3]:
layer.trainable = False
W_regularizer = l2(0.01)
x = base_model.get_layer("block5_conv3").output
x = AveragePooling2D((2, 2))(x)
x = Dropout(0.5)(x)
x = BatchNormalization()(x)
x = Dropout(0.5)(x)
x = Flatten()(x)
x = Dense(4096, activation="elu", W_regularizer=l2(0.01))(x)
x = Dropout(0.5)(x)
x = Dense(2048, activation="elu", W_regularizer=l2(0.01))(x)
x = Dense(2048, activation="elu", W_regularizer=l2(0.01))(x)
x = Dense(1, activation="linear")(x)
return Model(input=input_image, output=x)
class QLearn:
def __init__(self, actions, epsilon, alpha, gamma):
# instead of a dictionary, we'll be using
# a neural network
# self.q = {}
self.epsilon = epsilon # exploration constant
self.alpha = alpha # discount constant
self.gamma = gamma # discount factor
self.actions = actions
# Build the neural network
self.network = Sequential()
self.network.add(Dense(50, init='lecun_uniform', input_shape=(4,)))
# self.network.add(Activation('sigmoid'))
#self.network.add(Dropout(0.2))
self.network.add(Dense(20, init='lecun_uniform'))
# self.network.add(Activation('sigmoid'))
# #self.network.add(Dropout(0.2))
self.network.add(Dense(2, init='lecun_uniform'))
# self.network.add(Activation('linear')) #linear output so we can have range of real-valued outputs
# rms = SGD(lr=0.0001, decay=1e-6, momentum=0.5) # explodes to non
rms = RMSprop()
# rms = Adagrad()
# rms = Adam()
self.network.compile(loss='mse', optimizer=rms)
# Get a summary of the network
self.network.summary()
def make_fc_model(self):
'''
creates a fully convolutional model from self.model
'''
# get index of first dense layer in model
behead_ix = self._get_behead_index(self.model_layer_names)
model_layers = self.model.layers[:behead_ix]
# shape of image entering FC layers
inp_shape = self.model.layers[behead_ix - 1].get_output_shape_at(-1)
# replace dense layers with convolutions
model = Sequential()
model_layers += [Convolution2D(2048, 1, 1)]
model_layers += [Activation('relu')]
model_layers += [Convolution2D(2048, 1, 1)]
model_layers += [Activation('relu')]
model_layers += [Convolution2D(self.nb_classes, inp_shape[-1], inp_shape[-1])]
# must be same shape as target vector (None, num_classes, 1)
model_layers += [Reshape((self.nb_classes-1,1))]
model_layers += [Activation('softmax')]
print 'Compiling Fully Convolutional Model...'
for process in model_layers:
model.add(process)
sgd = SGD(lr=self.lr_1, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer='sgd')
print 'Done.'
return model
def __init__(self, restore=None, session=None, Dropout=Dropout, num_labels=10):
self.num_channels = 1
self.image_size = 28
self.num_labels = num_labels
model = Sequential()
nb_filters = 64
layers = [Conv2D(nb_filters, (5, 5), strides=(2, 2), padding="same",
input_shape=(28, 28, 1)),
Activation('relu'),
Conv2D(nb_filters, (3, 3), strides=(2, 2), padding="valid"),
Activation('relu'),
Conv2D(nb_filters, (3, 3), strides=(1, 1), padding="valid"),
Activation('relu'),
Flatten(),
Dense(32),
Activation('relu'),
Dropout(.5),
Dense(num_labels)]
for layer in layers:
model.add(layer)
if restore != None:
model.load_weights(restore)
self.model = model
def __init__(self):
model = Sequential()
model.add(Embedding(115227, 50, input_length=75, weights=pre_weights))
model.compile(loss=MCE, optimizer="adadelta")
print "Build Network Completed..."
self.model = model
self.vocab = {"get_index":{}, "get_word":[]}
def Simple(layers, func, ipt):
model = Sequential()
#model.add(BatchNormalization(input_shape = [ipt]))
model.add(Dense(layers[0], input_dim = ipt, activation = func[0]))
for i in range(1, len(layers)):
model.add(Dense(layers[i], activation = func[i]))
return model
class trainCNN(object):
def __init__(self):
self.X = np.random.randn(200,1)
self.Y = 1.2*self.X**2 + 0.5
def defineCNN(self):
print("Setting up network...")
self.model = Sequential()
self.model.add(Dense(40, input_shape=(1,)))
self.model.add(Activation('tanh'))
self.model.add(Dense(1))
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
self.model.compile(loss='mse', optimizer='RMSprop')
def trainCNN(self, nIterations):
print("Training network...")
self.metrics = self.model.fit(self.X, self.Y, batch_size=20, nb_epoch=nIterations, validation_split=0.2, shuffle=False)
# self.model.fit(self.XTrainSet, self.YTrainSet, batch_size=self.batchSize, nb_epoch=self.nbEpoch, validation_split=0.2)
def testCNN(self):
train = self.model.predict(self.X)
pl.plot(self.X, self.Y, '.')
pl.plot(self.X, train, 'x')
def test_dropout(layer_class):
for unroll in [True, False]:
layer_test(layer_class,
kwargs={'units': units,
'dropout': 0.1,
'recurrent_dropout': 0.1,
'unroll': unroll},
input_shape=(num_samples, timesteps, embedding_dim))
# Test that dropout is applied during training
x = K.ones((num_samples, timesteps, embedding_dim))
layer = layer_class(units, dropout=0.5, recurrent_dropout=0.5,
input_shape=(timesteps, embedding_dim))
y = layer(x)
assert y._uses_learning_phase
y = layer(x, training=True)
assert not getattr(y, '_uses_learning_phase')
# Test that dropout is not applied during testing
x = np.random.random((num_samples, timesteps, embedding_dim))
layer = layer_class(units, dropout=0.5, recurrent_dropout=0.5,
unroll=unroll,
input_shape=(timesteps, embedding_dim))
model = Sequential([layer])
assert model.uses_learning_phase
y1 = model.predict(x)
y2 = model.predict(x)
assert_allclose(y1, y2)
def test_recurrent_wrapper__simple_rnn__output_model():
"""The hidden state is not returned, but mapped by an output model.
"""
def recurrent_layer():
hidden = Input((128,))
input = Input((10,))
x = Dense(128, activation='relu')(input)
x = merge([hidden, x], mode='sum')
new_hidden = Activation('sigmoid')(x)
output = Dense(64)(x)
return RecurrentWrapper(
input=[input],
output=[output],
bind={hidden: new_hidden},
return_sequences=True,
)
m = Sequential([
InputLayer(input_shape=(None, 10)),
recurrent_layer(),
])
assert m.predict(np.random.uniform(size=(30, 20, 10))).shape == (30, 20, 64)
def test_replace_with_mask_layer__no_mask():
m = Sequential([
ReplaceWithMaskLayer(input_shape=(None, 10)),
])
actual = m.predict(np.random.uniform(size=(30, 20, 10)))
expected = np.ones((30, 20, 1))
np.testing.assert_allclose(actual, expected)
def build_siamese(input_model_1, input_model_2, input_dim, output_dim):
"""
:param input_model_1:
:type input_model_1:
:param input_model_2:
:type input_model_2:
:param input_dim: last layer input
:type input_dim:
:param output_dim: last layer output
:type output_dim:
:return:
:rtype:
"""
inputs = [input_model_1, input_model_2]
layer = Dense(input_dim=input_dim, output_dim=output_dim)
model = Sequential()
# mode: one of {sum, mul, concat, ave, join, cos, dot}.
model.add(Siamese(layer, inputs, 'sum'))
# model.compile(loss='mse', optimizer='sgd')
return model
def create_mlp_network(input_dim):
seq = Sequential()
seq.add(SparseFullyConnectedLayer(300, input_dim = input_dim, activation = "relu"))
# seq.add(Dense(300, input_dim = input_dim, activation = "relu"))
seq.add(Dense(300, activation = "relu"))
seq.add(Dense(128, activation = "relu"))
return seq
def build(self, layers):
model = Sequential()
for layer in layers:
model.add(layer)
self.model = TimeDistributed(model)
def create_model(insert=None):
'''Create the basic model'''
model = Sequential()
layers = [Convolution2D(NB_FILTERS, NB_CONV, NB_CONV,
border_mode='valid',
input_shape=(1, IMGROWS, IMGCOLS)),
Activation('relu'),
MaxPooling2D(pool_size=(NB_POOL, NB_POOL)),
Dropout(0.25),
Flatten(),
Dense(128),
Activation('relu'),
Dropout(0.5),
Dense(NB_CLASSES),
Activation('softmax')]
if insert is not None:
for l in insert['layers']:
layers.insert(insert['insert_pos'], l)
for layer in layers:
model.add(layer)
return model
def build_part1_RNN(window_size):
model = Sequential()
model.add(LSTM(5, input_shape=(window_size,1) ))
#model.add(Dropout(0.5))
model.add(Dense(1))
return model
def encoders_c(self, inputs):
input_encoder_c = Sequential()
input_encoder_c.add(Embedding(input_dim=self.vocab_size,
output_dim=self.query_maxlen))
input_encoder_c.add(Dropout(0.3))
encoder_c = input_encoder_c(inputs)
return encoder_c
def build_partial_cnn1(img_rows, img_cols):
model = Sequential()
#model.add(Convolution2D(nb_filter=100, nb_row=5, nb_col=5,
model.add(Convolution2D(nb_filter=10, nb_row=2, nb_col=2,
init='glorot_uniform', activation='linear',
border_mode='valid',
input_shape=(1, img_rows, img_cols)))
model.add(Activation('relu'))
#model.add(MaxPooling2D(pool_size=(2, 2)))
#model.add(Convolution2D(nb_filter=100, nb_row=5, nb_col=5,
'''model.add(Convolution2D(nb_filter=512, nb_row=5, nb_col=5,
init='glorot_uniform', activation='linear',
border_mode='valid'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
#model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dropout(0.5))'''
return model
def create_model(kernel_regularizer=None, activity_regularizer=None):
model = Sequential()
model.add(Dense(num_classes,
kernel_regularizer=kernel_regularizer,
activity_regularizer=activity_regularizer,
input_shape=(data_dim,)))
return model
def get_item_subgraph(input_shape, latent_dim):
# Could take item metadata here, do convolutional layers etc.
model = Sequential()
model.add(Dense(latent_dim, input_shape=input_shape))
return model
def fork (model, n=2):
forks = []
for i in range(n):
f = Sequential()
f.add (model)
forks.append(f)
return forks
def conv2d_work(input_dim):
seq = Sequential()
assert self.config['num_conv2d_layers'] > 0
for i in range(self.config['num_conv2d_layers']):
seq.add(Conv2D(filters=self.config['2d_kernel_counts'][i], kernel_size=self.config['2d_kernel_sizes'][i], padding='same', activation='relu'))
seq.add(MaxPooling2D(pool_size=(self.config['2d_mpool_sizes'][i][0], self.config['2d_mpool_sizes'][i][1])))
return seq
def question_encoder(self, dropout=0.3):
question_encoder = Sequential()
question_encoder.add(Embedding(input_dim=vocab_size,
output_dim=64,
input_length=query_maxlen))
question_encoder.add(Dropout(dropout))
self._question_encoder = question_encoder
def test_recurrent_wrapper__simple_rnn__no_sequences():
"""Return only the latest step in the sequence
"""
def recurrent_layer():
hidden = Input((128,))
input = Input((10,))
x = Dense(128, activation='relu')(input)
x = merge([hidden, x], mode='sum')
new_hidden = Activation('sigmoid')(x)
return RecurrentWrapper(
input=[input],
output=[new_hidden],
bind={hidden: new_hidden},
return_sequences=False,
)
m = Sequential([
InputLayer(input_shape=(None, 10)),
recurrent_layer(),
])
result = m.predict(np.random.uniform(size=(30, 20, 10)))
# map into hidden state
assert result.shape == (30, 128)
def __init__(self, config, data):
self.config = config
self.data = data
self.model = Sequential()
self.build_model()
class Model_Truong:
def __init__(self, config, data):
#super(Model_CUI_CNN3, self).__init__()
self.config = config
self.data = data
self.model = Sequential()
self.build_model()
def build_model(self):
#nach Truong et al.
#input-layer is not added as a layer!
self.model.add(
Conv2D(64, (3, 3),
padding='same',
activation='relu',
input_shape=self.config["input_shape"]))
self.model.add(Conv2D(64, (3, 3), padding='same', activation='relu'))
# self.model.add(MaxPooling2D(pool_size=(2,2)))
self.model.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
self.model.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
# self.model.add(MaxPooling2D(pool_size=(2,2)))
self.model.add(Conv2D(256, (3, 3), padding='same', activation='relu'))
self.model.add(Conv2D(256, (3, 3), padding='same', activation='relu'))
self.model.add(Conv2D(256, (3, 3), padding='same', activation='relu'))
# self.model.add(MaxPooling2D(pool_size=(2,2)))
self.model.add(Conv2D(512, (3, 3), padding='same', activation='relu'))
self.model.add(Conv2D(512, (3, 3), padding='same', activation='relu'))
# self.model.add(MaxPooling2D(pool_size=(2,2)))
self.model.add(Conv2D(512, (3, 3), padding='same', activation='relu'))
# self.model.add(GlobalAveragePooling2D())
self.model.add(Flatten())
self.model.add(Dense(304, activation='relu'))
self.model.add(Dense(self.data.nClasses, activation='softmax'))
print('Model created successfully.')
class SuperSimpleLSTMClassifierRandomEmbedding:
def __init__(self, max_seq_len, n_classes):
nb_words = 17490
embed_dim = 1024
self.model = Sequential()
self.model.add(
Embedding(nb_words,
embed_dim,
input_length=max_seq_len,
trainable=True))
self.model.add(Dropout(0.5))
self.model.add(LSTM(128))
self.model.add(Dropout(0.5))
self.model.add(Dense(n_classes, activation='sigmoid'))
self.model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
self.model.summary()
class Model_Sharma_addConv:
def __init__(self, config, data):
self.config = config
self.data = data
self.model = Sequential()
self.build_model()
def build_model(self):
#nach Cui et al.
#input-layer is not added as a layer!
self.model.add(
Conv2D(
8,
(3, 3),
padding='same',
activation='relu',
#activity_regularizer=l2(0.001),
input_shape=self.config["input_shape"]))
self.model.add(
Conv2D(16, (3, 3), padding='same',
activation='relu')) #, activity_regularizer=l2(0.001)))
self.model.add(
Conv2D(32, (3, 3), padding='same',
activation='relu')) #, activity_regularizer=l2(0.001)))
self.model.add(
Conv2D(64, (3, 3), padding='same',
activation='relu')) #, activity_regularizer=l2(0.001)))
self.model.add(
Conv2D(128, (3, 3), padding='same',
activation='relu')) #, activity_regularizer=l2(0.001)))
self.model.add(Conv2D(264, (3, 3), padding='same', activation='relu'))
self.model.add(Flatten())
self.model.add(Dense(
(8 * 8 * 128),
activation='relu')) #, activity_regularizer=l2(0.001)))
#self.model.add(Dropout(0.5))
#classification in 2 classes
self.model.add(Dense(self.data.nClasses, activation='softmax'))
print('Model created successfully.')
#----------------------- Data Normalization
x_train = x_train.astype('float32')
x_val = x_val.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_val /= 255
x_test /= 255
#--------------------- Checks---------------------------
if K.image_data_format() != "channels_last":
K.set_image_data_format("channels_last")
# ----------------- MODEL ----------------------
input_shape = (img_size, img_size, 3)
model = Sequential()
model.add(Conv2D(32, (3, 3), padding='same', input_shape=input_shape))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
class BidirectionalLSTMClassifier:
def __init__(self, embedding_matrix, max_seq_len, n_classes):
nb_words = embedding_matrix.shape[0]
embed_dim = embedding_matrix.shape[1]
self.model = Sequential()
self.model.add(
Embedding(nb_words,
embed_dim,
weights=[embedding_matrix],
input_length=max_seq_len,
trainable=True))
self.model.add(Dropout(0.5))
self.model.add(Bidirectional(LSTM(128)))
self.model.add(Dropout(0.5))
self.model.add(Dense(n_classes, activation='sigmoid'))
self.model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
self.model.summary()
with h5py.File(''.join(['bitcoin2015to2017_close.h5']), 'r') as hf:
datas = hf['inputs'].value
labels = hf['outputs'].value
step_size = datas.shape[1]
units= 50
second_units = 30
batch_size = 8
nb_features = datas.shape[2]
epochs = 100
output_size=16
output_file_name='bitcoin2015to2017_close_LSTM_1_tanh_leaky_'
#split training validation
training_size = int(0.8* datas.shape[0])
training_datas = datas[:training_size,:]
training_labels = labels[:training_size,:,0]
validation_datas = datas[training_size:,:]
validation_labels = labels[training_size:,:,0]
#build model
model = Sequential()
model.add(LSTM(units=units,activation='tanh', input_shape=(step_size,nb_features),return_sequences=False))
model.add(Dropout(0.8))
model.add(Dense(output_size))
model.add(LeakyReLU())
model.compile(loss='mse', optimizer='adam')
model.fit(training_datas, training_labels, batch_size=batch_size,validation_data=(validation_datas,validation_labels), epochs = epochs, callbacks=[CSVLogger(output_file_name+'.csv', append=True),ModelCheckpoint('weights/'+output_file_name+'-{epoch:02d}-{val_loss:.5f}.hdf5', monitor='val_loss', verbose=1,mode='min')])
class CNNRandomEmbedding:
rep_max = -100000.0
rep_size = 0
def __init__(self,
max_seq_len,
n_classes,
num_filters=64,
weight_decay=1e-4):
nb_words = 17490
embed_dim = 1024
self.model = Sequential()
self.model.add(
Embedding(nb_words,
embed_dim,
input_length=max_seq_len,
trainable=True))
self.model.add(Dropout(0.25))
self.model.add(
Conv1D(num_filters, 7, activation='relu', padding='same'))
self.model.add(MaxPooling1D(2))
self.model.add(
Conv1D(num_filters, 7, activation='relu', padding='same'))
self.model.add(GlobalMaxPooling1D())
self.model.add(Dropout(0.5))
self.model.add(
Dense(32,
activation='relu',
kernel_regularizer=regularizers.l2(weight_decay)))
self.model.add(Dense(
n_classes, activation='sigmoid')) #multi-label (k-hot encoding)
adam = optimizers.Adam(lr=0.001,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
decay=0.0)
self.model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
self.model.summary()
def build_discriminator(self):
model = Sequential()
model.add(Flatten(input_shape=self.img_shape))
model.add(Dense(512))
model.add(LeakyReLU(alpha=0.2))
model.add(Dense(256))
model.add(LeakyReLU(alpha=0.2))
model.add(Dense(1, activation='sigmoid'))
model.summary()
img = Input(shape=self.img_shape)
validity = model(img)
return Model(img, validity)
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.layers import Embedding
from keras.layers import LSTM
from keras.layers import Conv1D, MaxPooling1D
from keras import optimizers
max_features = 26
embedding_size = 256
kernel_size = 5
filters = 250
pool_size = 2
lstm_output_size = 64
#print('Building model...')
model = Sequential()
model.add(Embedding(max_features, embedding_size))
model.add(Dropout(0.2))
model.add(Conv1D(filters, kernel_size,padding ='valid',activation = 'relu',strides = 1))
model.add(MaxPooling1D(pool_size = pool_size))
model.add(LSTM(lstm_output_size))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss = 'binary_crossentropy',optimizer = optimizers.Adam(),metrics = ['acc'])
X_test = numpy.array([[1] * 128] * (10 ** 2) + [[0] * 128] * (10 ** 2))
Y_train = numpy.array([True] * (10 ** 4) + [False] * (10 ** 4))
Y_test = numpy.array([True] * (10 ** 2) + [False] * (10 ** 2))
X_train = X_train.astype("float32")
X_test = X_test.astype("float32")
Y_train = Y_train.astype("bool")
Y_test = Y_test.astype("bool")
# build deep learning model
from keras.optimizers import RMSprop
from keras.models import Sequential
from keras.layers import Activation, Dense, Dropout
model = Sequential()
# takes a 128 vector as input and outputs a 50 node layer, densely connected
model.add(Dense(50, input_dim=128))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Dense(50))
model.add(Activation('relu'))
model.add(Dropout(0.2))
# model.add(Dense(1, init='normal')) # for regression - just end here, no sigmoid layer
model.add(Dense(1)) # for classification
model.add(Activation('sigmoid')) # for classification, must add this
rms = RMSprop()
model.compile(loss='binary_crossentropy', optimizer=rms, metrics=['accuracy'])
batch_size = 32
from keras.models import load_model
import sys
from keras.models import Sequential
from keras.models import load_model
sys.path.append('./utils')
from dense import myDense
from conv2d import myConv2d
from maxpool import maxpool
from sequence import DataGenerator
from os import listdir
from pycm import ConfusionMatrix
model = Sequential()
filelist = []
labels = []
for file in listdir('./encoded/NORMAL'):
filelist.append('./encoded/NORMAL/{}'.format(file))
labels.append(0)
for file in listdir('./encoded/PNEUMONIA'):
filelist.append('./encoded/PNEUMONIA/{}'.format(file))
labels.append(1)
generator = DataGenerator(filelist, labels)
model = load_model('./model.h5',
def generate_GRU_mode(number_classes):
model = Sequential()
model.add(Embedding(MAX_FEATURES, 128))
model.add(GRU(32, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))
model.add(GRU(64, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))
model.add(GRU(128, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(number_classes, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
return model
def build_generator(self):
model = Sequential()
model.add(Dense(256, input_dim=self.latent_dim))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Dense(512))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Dense(1024))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Dense(np.prod(self.img_shape), activation='tanh'))
model.add(Reshape(self.img_shape))
model.summary()
noise = Input(shape=(self.latent_dim,))
img = model(noise)
return Model(noise, img)
def run_experiment(max_len, dropout_rate, n_layers):
global dataset, train_ids, valid_ids, test_ids, mode, task, val_method, val_mode, use_PCA
# for PCA if set to True
visual_components = 25
audio_components = 20
text_components = 110
nodes = 100
epochs = 200
outfile = "MOSI_sweep/late_" + mode + "_" + str(task) + "_" + str(
n_layers) + "_" + str(max_len) + "_" + str(dropout_rate)
experiment_prefix = "late"
batch_size = 64
logs_path = "regression_logs/"
experiment_name = "{}_n_{}_dr_{}_nl_{}_ml_{}".format(
experiment_prefix, nodes, dropout_rate, n_layers, max_len)
# sort through all the video ID, segment ID pairs
train_set_ids = []
for vid in train_ids:
for sid in dataset['embeddings'][vid].keys():
if mode == "all" or mode == "AV":
if dataset['embeddings'][vid][sid] and dataset['facet'][vid][
sid] and dataset['covarep'][vid][sid]:
train_set_ids.append((vid, sid))
if mode == "AT" or mode == "A":
if dataset['embeddings'][vid][sid] and dataset['covarep'][vid][
sid]:
train_set_ids.append((vid, sid))
if mode == "VT" or mode == "V":
if dataset['embeddings'][vid][sid] and dataset['facet'][vid][
sid]:
train_set_ids.append((vid, sid))
if mode == "T":
if dataset['embeddings'][vid][sid]:
train_set_ids.append((vid, sid))
valid_set_ids = []
for vid in valid_ids:
for sid in dataset['embeddings'][vid].keys():
if mode == "all" or mode == "AV":
if dataset['embeddings'][vid][sid] and dataset['facet'][vid][
sid] and dataset['covarep'][vid][sid]:
valid_set_ids.append((vid, sid))
if mode == "AT" or mode == "A":
if dataset['embeddings'][vid][sid] and dataset['covarep'][vid][
sid]:
valid_set_ids.append((vid, sid))
if mode == "VT" or mode == "V":
if dataset['embeddings'][vid][sid] and dataset['facet'][vid][
sid]:
valid_set_ids.append((vid, sid))
if mode == "T":
if dataset['embeddings'][vid][sid]:
valid_set_ids.append((vid, sid))
test_set_ids = []
for vid in test_ids:
if vid in dataset['embeddings']:
for sid in dataset['embeddings'][vid].keys():
if mode == "all" or mode == "AV":
if dataset['embeddings'][vid][sid] and dataset['facet'][
vid][sid] and dataset['covarep'][vid][sid]:
test_set_ids.append((vid, sid))
if mode == "AT" or mode == "A":
if dataset['embeddings'][vid][sid] and dataset['covarep'][
vid][sid]:
test_set_ids.append((vid, sid))
if mode == "VT" or mode == "V":
if dataset['embeddings'][vid][sid] and dataset['facet'][
vid][sid]:
test_set_ids.append((vid, sid))
if mode == "T":
if dataset['embeddings'][vid][sid]:
test_set_ids.append((vid, sid))
# partition the training, valid and test set. all sequences will be padded/truncated to 15 steps
# data will have shape (dataset_size, max_len, feature_dim)
if mode == "all" or mode == "AV" or mode == "AT":
train_set_audio = np.stack([
pad(dataset['covarep'][vid][sid], max_len)
for (vid, sid) in train_set_ids if dataset['covarep'][vid][sid]
],
axis=0)
valid_set_audio = np.stack([
pad(dataset['covarep'][vid][sid], max_len)
for (vid, sid) in valid_set_ids if dataset['covarep'][vid][sid]
],
axis=0)
test_set_audio = np.stack([
pad(dataset['covarep'][vid][sid], max_len)
for (vid, sid) in test_set_ids if dataset['covarep'][vid][sid]
],
axis=0)
if mode == "all" or mode == "VT" or mode == "AV":
train_set_visual = np.stack([
pad(dataset['facet'][vid][sid], max_len)
for (vid, sid) in train_set_ids if dataset['facet'][vid][sid]
],
axis=0)
valid_set_visual = np.stack([
pad(dataset['facet'][vid][sid], max_len)
for (vid, sid) in valid_set_ids if dataset['facet'][vid][sid]
],
axis=0)
test_set_visual = np.stack([
pad(dataset['facet'][vid][sid], max_len)
for (vid, sid) in test_set_ids if dataset['facet'][vid][sid]
],
axis=0)
if mode == "all" or mode == "VT" or mode == "AT":
train_set_text = np.stack([
pad(dataset['embeddings'][vid][sid], max_len)
for (vid, sid) in train_set_ids if dataset['embeddings'][vid][sid]
],
axis=0)
valid_set_text = np.stack([
pad(dataset['embeddings'][vid][sid], max_len)
for (vid, sid) in valid_set_ids if dataset['embeddings'][vid][sid]
],
axis=0)
test_set_text = np.stack([
pad(dataset['embeddings'][vid][sid], max_len)
for (vid, sid) in test_set_ids if dataset['embeddings'][vid][sid]
],
axis=0)
if task == "SB":
# binarize the sentiment scores for binary classification task
y_train = np.array(
[sentiments[vid][sid] for (vid, sid) in train_set_ids]) > 0
y_valid = np.array(
[sentiments[vid][sid] for (vid, sid) in valid_set_ids]) > 0
y_test = np.array(
[sentiments[vid][sid] for (vid, sid) in test_set_ids]) > 0
if task == "SR":
y_train = np.array(
[sentiments[vid][sid] for (vid, sid) in train_set_ids])
y_valid = np.array(
[sentiments[vid][sid] for (vid, sid) in valid_set_ids])
y_test = np.array(
[sentiments[vid][sid] for (vid, sid) in test_set_ids])
if task == "S5":
y_train1 = np.array(
[sentiments[vid][sid] for (vid, sid) in train_set_ids])
y_valid1 = np.array(
[sentiments[vid][sid] for (vid, sid) in valid_set_ids])
y_test1 = np.array(
[sentiments[vid][sid] for (vid, sid) in test_set_ids])
y_train = convert_S5_hot(y_train1)
y_valid = convert_S5_hot(y_valid1)
y_test = convert_S5_hot(y_test1)
# normalize covarep and facet features, remove possible NaN values
if mode == "all" or mode == "AV" or mode == "VT":
visual_max = np.max(np.max(np.abs(train_set_visual), axis=0), axis=0)
visual_max[visual_max ==
0] = 1 # if the maximum is 0 we don't normalize
train_set_visual = train_set_visual / visual_max
valid_set_visual = valid_set_visual / visual_max
test_set_visual = test_set_visual / visual_max
train_set_visual[train_set_visual != train_set_visual] = 0
valid_set_visual[valid_set_visual != valid_set_visual] = 0
test_set_visual[test_set_visual != test_set_visual] = 0
if mode == "all" or mode == "AT" or mode == "AV":
audio_max = np.max(np.max(np.abs(train_set_audio), axis=0), axis=0)
train_set_audio = train_set_audio / audio_max
valid_set_audio = valid_set_audio / audio_max
test_set_audio = test_set_audio / audio_max
train_set_audio[train_set_audio != train_set_audio] = 0
valid_set_audio[valid_set_audio != valid_set_audio] = 0
test_set_audio[test_set_audio != test_set_audio] = 0
if use_PCA == True:
if mode == "all" or mode == "AV" or mode == "VT":
nsamples1, nx1, ny1 = train_set_visual.shape
train_set_visual = train_set_visual.reshape(nsamples1 * nx1, ny1)
nsamples2, nx2, ny2 = valid_set_visual.shape
valid_set_visual = valid_set_visual.reshape(nsamples2 * nx2, ny2)
nsamples3, nx3, ny3 = test_set_visual.shape
test_set_visual = test_set_visual.reshape(nsamples3 * nx3, ny3)
pca = decomposition.PCA(n_components=visual_components)
train_set_visual_pca = pca.fit_transform(train_set_visual)
valid_set_visual_pca = pca.transform(valid_set_visual)
test_set_visual_pca = pca.transform(test_set_visual)
train_set_visual = train_set_visual_pca.reshape(
nsamples1, nx1, visual_components)
valid_set_visual = valid_set_visual_pca.reshape(
nsamples2, nx2, visual_components)
test_set_visual = test_set_visual_pca.reshape(
nsamples3, nx3, visual_components)
if mode == "all" or mode == "AT" or mode == "AV":
nsamples1, nx1, ny1 = train_set_audio.shape
train_set_audio = train_set_audio.reshape(nsamples1 * nx1, ny1)
nsamples2, nx2, ny2 = valid_set_audio.shape
valid_set_audio = valid_set_audio.reshape(nsamples2 * nx2, ny2)
nsamples3, nx3, ny3 = test_set_audio.shape
test_set_audio = test_set_audio.reshape(nsamples3 * nx3, ny3)
pca = decomposition.PCA(n_components=audio_components)
train_set_audio_pca = pca.fit_transform(train_set_audio)
valid_set_audio_pca = pca.transform(valid_set_audio)
test_set_audio_pca = pca.transform(test_set_audio)
train_set_audio = train_set_audio_pca.reshape(
nsamples1, nx1, audio_components)
valid_set_audio = valid_set_audio_pca.reshape(
nsamples2, nx2, audio_components)
test_set_audio = test_set_audio_pca.reshape(
nsamples3, nx3, audio_components)
if mode == "all" or mode == "AT" or mode == "VT":
nsamples1, nx1, ny1 = train_set_text.shape
train_set_text = train_set_text.reshape(nsamples1 * nx1, ny1)
nsamples2, nx2, ny2 = valid_set_text.shape
valid_set_text = valid_set_text.reshape(nsamples2 * nx2, ny2)
nsamples3, nx3, ny3 = test_set_text.shape
test_set_text = test_set_text.reshape(nsamples3 * nx3, ny3)
pca = decomposition.PCA(n_components=text_components)
train_set_text_pca = pca.fit_transform(train_set_text)
valid_set_text_pca = pca.transform(valid_set_text)
test_set_text_pca = pca.transform(test_set_text)
train_set_text = train_set_text_pca.reshape(
nsamples1, nx1, text_components)
valid_set_text = valid_set_text_pca.reshape(
nsamples2, nx2, text_components)
test_set_text = test_set_text_pca.reshape(nsamples3, nx3,
text_components)
k = 3
m = 2
if task == "SB":
val_method = "val_acc"
val_mode = "max"
emote_final = 'sigmoid'
last_node = 1
if task == "SR":
val_method = "val_loss"
val_mode = "min"
emote_final = 'linear'
last_node = 1
if task == "S5":
val_method = "val_acc"
val_mode = "max"
emote_final = 'softmax'
last_node = 5
model = Sequential()
# AUDIO
if mode == "all" or mode == "AT" or mode == "AV":
model1_in = Input(shape=(max_len, train_set_audio.shape[2]))
model1_cnn = Conv1D(filters=64, kernel_size=k,
activation='relu')(model1_in)
model1_mp = MaxPooling1D(m)(model1_cnn)
model1_fl = Flatten()(model1_mp)
model1_dropout = Dropout(dropout_rate)(model1_fl)
model1_dense = Dense(nodes, activation="relu")(model1_dropout)
model1_out = Dense(last_node, activation=emote_final)(model1_dense)
# TEXT = BLSTM from unimodal
if mode == "all" or mode == "AT" or mode == "VT":
model2_in = Input(shape=(max_len, train_set_text.shape[2]))
model2_lstm = Bidirectional(LSTM(64))(model2_in)
model2_dropout = Dropout(dropout_rate)(model2_lstm)
model2_dense = Dense(nodes, activation="relu")(model2_dropout)
model2_out = Dense(last_node, activation=emote_final)(model2_dense)
# VIDEO - CNN from unimodal
if mode == "all" or mode == "AV" or mode == "VT":
model3_in = Input(shape=(max_len, train_set_visual.shape[2]))
model3_cnn = Conv1D(filters=64, kernel_size=k,
activation='relu')(model3_in)
model3_mp = MaxPooling1D(m)(model3_cnn)
model3_fl = Flatten()(model3_mp)
model3_dropout = Dropout(dropout_rate)(model3_fl)
model3_dense = Dense(nodes, activation="relu")(model3_dropout)
model3_out = Dense(last_node, activation=emote_final)(model3_dense)
if mode == "all":
concatenated = concatenate([model1_out, model2_out, model3_out])
if mode == "AV":
concatenated = concatenate([model1_out, model3_out])
if mode == "AT":
concatenated = concatenate([model1_out, model2_out])
if mode == "VT":
concatenated = concatenate([model2_out, model3_out])
out = Dense(last_node, activation=emote_final)(concatenated)
if mode == "all":
merged_model = Model([model1_in, model2_in, model3_in], out)
if mode == "AV":
merged_model = Model([model1_in, model3_in], out)
if mode == "AT":
merged_model = Model([model1_in, model2_in], out)
if mode == "VT":
merged_model = Model([model2_in, model3_in], out)
if task == "SB":
merged_model.compile('adam',
'binary_crossentropy',
metrics=['accuracy'])
if task == "S5":
merged_model.compile('adam',
'binary_crossentropy',
metrics=['accuracy'])
if task == "SR":
merged_model.compile('adam', loss='mean_absolute_error')
if mode == "all":
x_train = [train_set_audio, train_set_text, train_set_visual]
x_valid = [valid_set_audio, valid_set_text, valid_set_visual]
x_test = [test_set_audio, test_set_text, test_set_visual]
if mode == "AV":
x_train = [train_set_audio, train_set_visual]
x_valid = [valid_set_audio, valid_set_visual]
x_test = [test_set_audio, test_set_visual]
if mode == "AT":
x_train = [train_set_audio, train_set_text]
x_valid = [valid_set_audio, valid_set_text]
x_test = [test_set_audio, test_set_text]
if mode == "VT":
x_train = [train_set_text, train_set_visual]
x_valid = [valid_set_text, valid_set_visual]
x_test = [test_set_text, test_set_visual]
early_stopping = EarlyStopping(monitor=val_method,
min_delta=0,
patience=10,
verbose=1,
mode=val_mode)
callbacks_list = [early_stopping]
merged_model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=[x_valid, y_valid],
callbacks=callbacks_list)
preds = merged_model.predict(x_test)
out = open(outfile, "wb")
print "testing output before eval metrics calcs.."
print y_test[0]
print preds[0]
if task == "SR":
preds = np.concatenate(preds)
mae = sklearn.metrics.mean_absolute_error(y_test, preds)
r = scipy.stats.pearsonr(y_test, preds)
out.write("Test MAE: " + str(mae) + "\n")
out.write("Test CORR: " + str(r) + "\n")
if task == "S5":
preds = convert_pred_hot(preds)
acc = sklearn.metrics.accuracy_score(y_test, preds)
out.write("Test ACC: " + str(acc) + "\n")
if task == "SB":
acc = np.mean((preds > 0.5) == y_test.reshape(-1, 1))
preds = np.concatenate(preds)
preds = preds > 0.5
f1 = sklearn.metrics.f1_score(y_test, preds)
out.write("Test ACC: " + str(acc) + "\n")
out.write("Test F1: " + str(f1) + "\n")
out.write("use_PCA=" + str(use_PCA) + "\n")
out.write("dropout_rate=" + str(dropout_rate) + "\n")
out.write("n_layers=" + str(n_layers) + "\n")
out.write("max_len=" + str(max_len) + "\n")
out.write("nodes=" + str(nodes) + "\n")
out.write("task=" + str(task) + "\n")
out.write("mode=" + str(mode) + "\n")
out.write("num_train=" + str(len(train_set_ids)) + "\n")
out.write("num_valid=" + str(len(valid_set_ids)) + "\n")
out.write("num_test=" + str(len(test_set_ids)) + "\n")
out.close()
def generate_BiLSTM_model(number_classes):
model = Sequential()
model.add(Embedding(MAX_FEATURES, 128))
# model.add(Bidirectional(LSTM(32, dropout=0.2, recurrent_dropout=0.2, activation='tanh', return_sequences=True)))
model.add(Bidirectional(LSTM(64, activation='tanh'), merge_mode='concat'))
model.add(Dropout(0.5))
model.add(Dense(number_classes, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adamax', metrics=['accuracy'])
return model
def build_CNN(hparams):
img_size = 32
num_classes = 10
model = Sequential()
model.add(
Conv2D(filters=hparams[1],
kernel_size=(3, 3),
padding='same',
input_shape=(img_size, img_size, 3),
kernel_initializer='he_normal',
activation='relu'))
model.add(
Conv2D(filters=hparams[1],
kernel_size=(3, 3),
kernel_initializer='he_normal',
activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(hparams[6]))
model.add(
Conv2D(filters=hparams[2],
kernel_size=(3, 3),
padding='same',
kernel_initializer='he_normal',
activation='relu'))
model.add(
Conv2D(filters=hparams[2],
kernel_size=(3, 3),
kernel_initializer='he_normal',
activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(hparams[6]))
model.add(Flatten())
for i in range(hparams[3]):
model.add(Dense(hparams[4], activation=hparams[5])) #1
model.add(Dropout(hparams[6]))
model.add(Dense(num_classes, activation='softmax'))
optimizer = Adam(lr=hparams[0])
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def generate_LSTM_model(number_classes):
model = Sequential()
model.add(Embedding(MAX_FEATURES, 128))
model.add(LSTM(32,
dropout=0.2,
recurrent_dropout=0.2,
activation='tanh',
return_sequences=True))
model.add(LSTM(64,
dropout=0.2,
recurrent_dropout=0.2,
activation='tanh'))
model.add(Dense(number_classes, activation='sigmoid'))
model.compile(loss='categorical_crossentropy',
optimizer = 'rmsprop',
metrics=['accuracy'])
return model