def create_mem_network():
input_story = layers.Input(shape=(story_maxlen, ))
input_m_encoded = layers.Embedding(input_dim=vocab_size,
output_dim=64)(input_story)
input_m_encoded = layers.Dropout(0.3)(input_m_encoded)
input_c_encoded = layers.Embedding(input_dim=vocab_size,
output_dim=query_maxlen)(input_story)
input_c_encoded = layers.Dropout(0.3)(input_c_encoded)
input_ques = layers.Input(shape=(query_maxlen, ))
ques_encoded = layers.Embedding(input_dim=vocab_size,
output_dim=64,
input_length=query_maxlen)(input_ques)
ques_encoded = layers.Dropout(0.3)(ques_encoded)
# (samples, story_maxlen, query_maxlen)
match = layers.dot([input_m_encoded, ques_encoded], axes=(2, 2))
match = layers.Activation('softmax')(match)
response = layers.add([match, input_c_encoded
]) # (samples, story_maxlen, query_maxlen)
response = layers.Permute((2, 1))(response)
answer = layers.concatenate([response, ques_encoded])
answer = layers.LSTM(32)(answer)
answer = layers.Dropout(0.3)(answer)
answer = layers.Dense(vocab_size, activation=None)(answer)
return models.Model(inputs=[input_story, input_ques], outputs=answer)
def main():
vocabulary_size = 10000
maxlen = 24
model = Sequential()
model.add(layers.Embedding(vocabulary_size, 64, name="text"))
model.add(
layers.Conv1D(64, 4, padding='valid', activation='relu', strides=1))
model.add(layers.MaxPooling1D(pool_size=3))
model.add(layers.LSTM(64))
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
# # if use keras not tf.keras
# model = tf.keras.models.Model(model)
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['acc'])
estimator_model = tf.keras.estimator.model_to_estimator(keras_model=model)
data, labels = mr_load_data(max_word_num=vocabulary_size)
data = pad_sequences(data, padding="pre", maxlen=maxlen)
labels = np.asarray(labels).reshape(-1, 1)
print(labels.shape)
x_train, y_train = data, labels
input_dict = {"text_input": x_train}
input_fn = train_input_fn(input_dict, y_train, batch_size=32)
print(input_fn)
#
# estimator_model.train(input_fn=input_fn, steps=10000)
estimator_model.train(input_fn=input_function(input_dict, y_train),
steps=10000)
def define_generator(latent_dim=50, nclasses=10):
label = layers.Input(shape=(1, ))
li = layers.Embedding(nclasses, 50)(label)
li = layers.Dense(7 * 7 * 1, activation="relu")(li)
li = layers.Reshape((7, 7, 1))(li)
noise = layers.Input(shape=(latent_dim, ))
n = layers.Dense(7 * 7 * 384, activation="relu")(noise)
n = layers.Reshape((7, 7, 384))(n)
input = layers.concatenate([n, li], axis=-1)
x = layers.Conv2DTranspose(filters=192,
kernel_size=5,
strides=2,
padding="same")(input)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2DTranspose(filters=1,
kernel_size=5,
strides=2,
padding="same",
activation="tanh")(x)
model = tf.keras.Model([noise, label], x)
return model
def build_bigru_model(self, embedding_matrix) -> Tuple[Model, Model]:
"""
build and return multi-headed BiGru model
with 1) MLM output from first GRU layer
2) standard toxicity classification output from second
:param embedding_matrix:
:return:
"""
token_input = layers.Input(shape=(self.max_seq_len,))
embedding_layer = layers.Embedding(self.vocab_size + 1,
self.embedding_dims,
weights=[embedding_matrix],
trainable=False)
embedded_input = embedding_layer(token_input)
gru1_output = layers.Bidirectional(layers.CuDNNGRU(self.num_neurons,
return_sequences=True))(embedded_input)
aux_output = layers.Dense(self.vocab_size + 1, 'softmax', name='aux_output')(gru1_output)
gru2_output = layers.Bidirectional(layers.CuDNNGRU(self.num_neurons))(gru1_output)
main_output = layers.Dense(6, activation='sigmoid', name='main_output')(gru2_output)
training_model = Model(inputs=token_input, outputs=[main_output, aux_output])
mlm_loss = MaskedPenalizedSparseCategoricalCrossentropy(CONFIDENCE_PENALTY)
training_model.compile(optimizer=optimizers.Adam(),
loss={'main_output': MaskedBinaryCrossedentropy(),
'aux_output': mlm_loss})
inference_model = Model(inputs=token_input, outputs=main_output)
print('generated bigru model...')
print(training_model.summary())
return training_model, inference_model
def __init__(self, units):
super(MyRNN, self).__init__()
# transform text to embedding representation
self.embedding = layers.Embedding(hp.total_words,
hp.embedding_len,
input_length=hp.max_sentence_len)
# two layer rnn
# normal rnn
self.rnn = Sequential([
layers.SimpleRNN(units=units,
dropout=0.5,
return_sequences=True,
unroll=True),
layers.SimpleRNN(units=units, dropout=0.5, unroll=True)
])
# # lstm rnn
# self.rnn = Sequential([
# layers.LSTM(units=units, dropout=0.5, return_sequences=True, unroll=True),
# layers.LSTM(units=units, dropout=0.5, unroll=True)
# ])
# # gru rnn
# self.rnn = Sequential([
# layers.GRU(units=units, dropout=0.5, return_sequences=True, unroll=True),
# layers.GRU(units=units, dropout=0.5, unroll=True)
# ])
self.fc = layers.Dense(1, activation=tf.nn.sigmoid)
def create_mem_network():
sentence = layers.Input(shape=(story_maxlen,), dtype=tf.int32)
encoded_sentence = layers.Embedding(input_dim=vocab_size, output_dim=50)(sentence)
encoded_sentence = layers.Dropout(0.3)(encoded_sentence)
question = layers.Input(shape=(query_maxlen,), dtype=tf.int32)
encoded_ques = layers.Embedding(input_dim=vocab_size, output_dim=50)(question)
encoded_ques = layers.Dropout(0.3)(encoded_ques)
encoded_ques = layers.LSTM(50)(encoded_ques)
encoded_ques = layers.RepeatVector(story_maxlen)(encoded_ques)
merged = layers.add([encoded_sentence, encoded_ques])
merged = layers.LSTM(50)(merged)
merged = layers.Dropout(0.3)(merged)
preds = layers.Dense(vocab_size, activation=None)(merged)
return models.Model(inputs=[sentence, question], outputs=preds)
def build_bigru_model(self, embedding_matrix) -> Model:
"""
build and return BiGru model using standard optimizer and loss
:param embedding_matrix:
:return:
"""
token_input = layers.Input(shape=(self.max_seq_len, ))
embedding_layer = layers.Embedding(self.vocab_size + 1,
self.embedding_dims,
weights=[embedding_matrix],
trainable=False)
embedded_input = embedding_layer(token_input)
gru_output = layers.Bidirectional(
layers.CuDNNGRU(self.num_neurons,
return_sequences=True))(embedded_input)
gru_output = layers.Bidirectional(layers.CuDNNGRU(
self.num_neurons))(gru_output)
dense_output = layers.Dense(6, activation='sigmoid')(gru_output)
bigru_model = Model(token_input, dense_output)
bigru_model.compile(optimizer=optimizers.Adam(),
loss=losses.binary_crossentropy)
print('generated bigru model...')
return bigru_model
def build_cnn_model():
#Instantiate a Keras tensor
sequences= layers.Input(shape = (max_length, ))
#Turns positive integers (indexes) into dense vectors of fixed size
embedded = layers.Embedding(12000, 64) (sequences)
#Convolution kernel is convoled with the layer to produce a tensor of outputs
#(output_space, kernel_size, linear_unit_activation_function)
x = layers.Conv1D(64, 3, activation='relu') (embedded)
#Normalize and scale inputs or activations
x = layers.BatchNormalization() (x)
#Downsamples the input representation by taking the maximum value over the window
x = layers.MaxPool1D(3) (x)
x = layers.Conv1D(64, 5, activation='relu') (x)
x = layers.BatchNormalization() (x)
x = layers.MaxPool1D(5) (x)
x = layers.Conv1D(64, 5, activation='relu') (x)
#Downsamples the input representation by taking the maximum value over the time dimension
x = layers.GlobalMaxPool1D() (x)
x = layers.Flatten() (x)
#First parameter represents the dimension of the output space
x = layers.Dense(100, activation='relu') (x)
#Sigmoid function: values <-5 => value close to 0; values >5 => values close to 1
predictions = layers.Dense(1, activation='sigmoid') (x)
model = models.Model(inputs = sequences, outputs = predictions)
model.compile(
optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['binary_accuracy']
)
return model
def test_variable_not_casted_for_int_inputs(self, strategy_fn):
x = constant_op.constant([[1]], dtype=dtypes.int32)
with strategy_fn().scope():
with policy.policy_scope('infer_float32_vars'):
layer = layers.Embedding(input_dim=10, output_dim=32)
y = layer(x)
self.assertEqual(layer.embeddings.dtype, dtypes.float32)
self.assertEqual(y.dtype, dtypes.float32)
def __init__(self):
super(Model, self).__init__()
self.main = tf.keras.Sequential([
layers.Embedding(vocab_size, embedding_dim, input_length=maxlen),
layers.GlobalAveragePooling1D(),
layers.Dense(16, activation=tf.nn.relu),
layers.Dense(1, activation=tf.nn.sigmoid)
])
def __init__(self, units, vocab_size, name):
super(Embedding, self).__init__(name=name + 'embed')
self.model_dim = units
self.embdding = layers.Embedding(input_dim=vocab_size,
output_dim=units,
mask_zero=False)
# self.lookup = self.add_weight(name='lookup', shape=[vocab_size, self.model_dim], initializer="random_normal")
self.scale = math.sqrt(self.model_dim)
def create_dialog_network(time_steps, classes_num):
vocab_size = 60
vec_size = 20
model = Sequential()
model.add(layers.Embedding(vocab_size, vec_size, input_length=time_steps))
model.add(layers.LSTM(vec_size, dropout=0.2, recurrent_dropout=0.2))
model.add(layers.Dense(classes_num, activation='softmax'))
return model
def __init__(self, cfg=Args, vocab=40558, n_ctx=512):
super(TransformerModel, self).__init__()
self.vocab = vocab
self.embed = layers.Embedding(vocab, cfg.n_embed)
# 构造输入embed的位置信息
self.embed.build([1])
self.drop = layers.Dropout(cfg.embed_pdrop)
self.h = [Block(n_ctx, cfg, scale=False) for _ in range(cfg.n_layer)]
def create_lstm():
model = tf.keras.Sequential()
model.add(layers.Embedding(MAX_WORDS, 64, input_length=MAX_LEN))
model.add(layers.Conv1D(32, 3, padding='same', activation='relu'))
model.add(layers.MaxPooling1D(pool_size=4))
model.add(layers.LSTM(64))
model.add(layers.Dense(250, activation='relu'))
model.add(layers.Dense(1, activation="sigmoid"))
return model
def create_model(self):
input_text = Input(shape=self.max_sequence_length)
input_image = Input(shape=(self.img_height, self.img_width,
self.num_channels))
embedded_id = layers.Embedding(self.vocab_size,
self.embedding_size)(input_text)
embedded_id = layers.Flatten()(embedded_id)
embedded_id = layers.Dense(units=input_image.shape[1] *
input_image.shape[2])(embedded_id)
embedded_id = layers.Reshape(target_shape=(input_image.shape[1],
input_image.shape[2],
1))(embedded_id)
x = layers.Concatenate(axis=3)([input_image, embedded_id])
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=(2, 2),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(0.3)(x)
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=(2, 2),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(rate=0.3)(x)
# x = layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='same')(x)
# x = layers.LeakyReLU()(x)
# x = layers.Dropout(rate=0.3)(x)
#
# x = layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same')(x)
# x = layers.LeakyReLU()(x)
# x = layers.Dropout(rate=0.3)(x)
x = layers.Conv2D(filters=128,
kernel_size=(3, 3),
strides=(2, 2),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(rate=0.3)(x)
x = layers.Flatten()(x)
x = layers.Dense(units=1000)(x)
x = layers.LeakyReLU()(x)
x = layers.Dense(units=1)(x)
model = Model(name='discriminator',
inputs=[input_text, input_image],
outputs=x)
return model
def __init__(self, vocab_size, embedding_size, hidden_size, batch_size,
intent_size):
super(TestModel, self).__init__()
self.embedding = layers.Embedding(input_dim=vocab_size,
output_dim=embedding_size,
embeddings_initializer='uniform',
name='embedding')
# initialize encoder and decoder
self.encoder = Encoder(self.embedding, hidden_size, batch_size)
self.decoder = Decoder(intent_size)
def multi_input_model():
text_vocabulary_size = 10000
question_vocabulary_size = 10000
answer_vocabulary_size = 500
text_input = Input(shape=(None,), dtype='int32', name='text')
embedded_text = layers.Embedding(
text_vocabulary_size, 64)(text_input)
encoded_text = layers.CuDNNLSTM(32)(embedded_text)
question_input = Input(shape=(None,),
dtype='int32',
name='question')
embedded_question = layers.Embedding(
question_vocabulary_size, 32)(question_input)
encoded_question = layers.CuDNNLSTM(16)(embedded_question)
# 注意这里将两个输入合并
# 设axis=i，则沿着第i个下标变化的方向进行操作，-1代表倒数第一个加起来
concatenated = layers.concatenate([encoded_text, encoded_question],
axis=-1)
answer = layers.Dense(answer_vocabulary_size,
activation='softmax')(concatenated)
model = Model([text_input, question_input], answer)
'''
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['acc'])
num_samples = 1000
max_length = 100
text = np.random.randint(1, text_vocabulary_size,
size=(num_samples, max_length))
question = np.random.randint(1, question_vocabulary_size,
size=(num_samples, max_length))
answers = np.random.randint(answer_vocabulary_size, size=(num_samples))
answers = to_categorical(answers, answer_vocabulary_size)
model.fit([text, question], answers, epochs=10, batch_size=128)
model.fit({'text': text, 'question': question}, answers,
epochs=10, batch_size=128)
'''
return model
def build_rnn_model():
sequences = layers.Input(shape=(MAX_LENGTH, ))
embedded = layers.Embedding(MAX_FEATURES, 64)(sequences)
x = layers.LSTM(128, return_sequences=True)(embedded)
x = layers.LSTM(128)(x)
x = layers.Dense(32, activation='relu')(x)
x = layers.Dense(100, activation='relu')(x)
predictions = layers.Dense(1, activation='sigmoid')(x)
model = models.Model(inputs=sequences, outputs=predictions)
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['binary_accuracy'])
return model
def multi_output_model():
vocabulary_size = 50000
num_income_groups = 10
posts_input = Input(shape=(None,), dtype='int32', name='posts')
embedded_posts = layers.Embedding(256, vocabulary_size)(posts_input)
x = layers.Conv1D(128, 5, activation='relu')(embedded_posts)
x = layers.MaxPooling1D(5)(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.MaxPooling1D(5)(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.Conv1D(256, 5, activation='relu')(x)
x = layers.GlobalMaxPooling1D()(x)
x = layers.Dense(128, activation='relu')(x)
# 两个输出
age_prediction = layers.Dense(1, name='age')(x)
income_prediction = layers.Dense(num_income_groups,
activation='softmax',
name='income')(x)
gender_prediction = layers.Dense(1, activation='sigmoid', name='gender')(x)
model = Model(posts_input,
[age_prediction, income_prediction, gender_prediction])
'''
#编译时选择多个损失标准
model.compile(optimizer='rmsprop',
loss=['mse', 'categorical_crossentropy', 'binary_crossentropy'])
model.compile(optimizer='rmsprop',
loss={'age': 'mse',
'income': 'categorical_crossentropy',
'gender': 'binary_crossentropy'})
model.compile(optimizer='rmsprop',
loss=['mse', 'categorical_crossentropy', 'binary_crossentropy'],
loss_weights=[0.25, 1., 10.])
model.compile(optimizer='rmsprop',
loss={'age': 'mse',
'income': 'categorical_crossentropy',
'gender': 'binary_crossentropy'},
loss_weights={'age': 0.25,
'income': 1.,
'gender': 10.})
model.fit(posts, [age_targets, income_targets, gender_targets],
epochs=10, batch_size=64)
model.fit(posts, {'age': age_targets,
'income': income_targets,
'gender': gender_targets},
epochs=10, batch_size=64)
'''
return model
def make_generator_model(input_tensor=None,
input_shape=(noise_dim,)):
"""
Returns:
tf.keras.Model
"""
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = layers.Dense(7 * 7 * 256,
activation=tf.nn.relu,
use_bias=False,
name='fc1')(img_input)
x = layers.Reshape(target_shape=(7, 7, 128), name='reshape1')(x)
x = layers.BatchNormalization(momentum=0.8, name='bn1')(x)
x = layers.UpSampling2D(name='upsampling1')(x)
x = layers.Conv2D(128, (3, 3),
activation=tf.nn.relu,
padding="same",
use_bias=False,
name='conv1')(x)
x = layers.BatchNormalization(momentum=0.8, name='bn2')(x)
x = layers.UpSampling2D(name='upsampling2')(x)
x = layers.Conv2D(64, (3, 3),
activation=tf.nn.relu,
padding="same",
use_bias=False,
name='conv2')(x)
x = layers.BatchNormalization(momentum=0.8, name='bn3')(x)
x = layers.Conv2D(1, (3, 3),
activation=tf.nn.tanh,
use_bias=False,
name='conv3')(x)
noise = layers.Input(shape=(noise_dim,))
label = layers.Input(shape=(1,), dtype='int32')
label_embedding = layers.Flatten()(layers.Embedding(num_classes, 100)(label))
x = layers.multiply([noise, label_embedding])(x)
return models.Model([noise, label], x)
def __init__(self, vocab_size, embedding_size, max_sentence_len):
self.vocab_size = vocab_size
self.embedding_size = embedding_size
# create model
self.model = models.Sequential()
self.model.add(
layers.Embedding(vocab_size, embedding_size, max_sentence_len))
self.model.add(layers.GlobalAveragePooling1D())
self.model.add(layers.Dense(units=1, activation='sigmoid'))
# 损失和优化器选择
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
self.model.summary()
def create_dem_bc_aug(self, kernel_initializer = 'he_normal', img_flat_len = 1024, only_emb = False):
attr_input = layers.Input(shape = (self.attr_len,), name = 'attr')
word_emb = layers.Input(shape = (self.wv_len,), name = 'wv')
img_input = layers.Input(shape = (self.pixel, self.pixel, 3))
label = layers.Input(shape = (1,), name = 'label')
# img_flat_model = Model(inputs = self.img_model[0].inputs, outputs = self.img_model[0].get_layer(name = 'avg_pool').output)
imag_classifier = self.img_flat_model(img_input)
if self.attr_emb_transform == 'flat':
attr_emb = layers.Embedding(294, self.attr_emb_len)(attr_input)
attr_dense = layers.Flatten()(attr_emb) #layers.GlobalAveragePooling1D()(attr_emb)
elif self.attr_emb_transform == 'dense':
attr_dense = layers.Dense(self.attr_emb_len, use_bias = True, kernel_initializer=kernel_initializer,
kernel_regularizer = l2(1e-4), name = 'attr_dense')(attr_input)
if only_emb:
attr_word_emb = word_emb
else:
attr_word_emb = layers.Concatenate(name = 'attr_word_emb')([word_emb, attr_dense])
attr_word_emb_dense = self.full_connect_layer(attr_word_emb, hidden_dim = [
# int(img_flat_len * 4),
int(img_flat_len * 2),
int(img_flat_len * 1.5),
int(img_flat_len * 1.25),
# int(img_flat_len * 1.125),
int(img_flat_len)
], \
activation = 'relu', resnet = False, drop_out_ratio = 0.2)
# attr_word_emb_dense = self.full_connect_layer(attr_word_emb_dense, hidden_dim = [img_flat_len],
# activation = 'relu')
attr_x_img = layers.Lambda(lambda x: x[0] * x[1], name = 'attr_x_img')([attr_word_emb_dense, imag_classifier])
# attr_x_img = layers.Concatenate(name = 'attr_x_img')([attr_word_emb_dense, imag_classifier])
attr_img_input = layers.Input(shape = (img_flat_len,), name = 'attr_img_input')
# attr_img_input = layers.Input(shape = (img_flat_len * 2,), name = 'attr_img_input')
proba = self.full_connect_layer(attr_img_input, hidden_dim = [1], activation = 'sigmoid')
attr_img_model = Model(inputs = attr_img_input, outputs = proba, name = 'attr_x_img_model')
out = attr_img_model([attr_x_img])
# dem_bc_model = self.create_dem_bc(kernel_initializer = 'he_normal',
# img_flat_len = img_flat_len,
# only_emb = only_emb)
# attr_word_emb_dense, out = dem_bc_model([imag_classifier, attr_input, word_emb, label])
bc_loss = K.mean(binary_crossentropy(label, out))
model = Model([img_input, attr_input, word_emb, label], outputs = [attr_word_emb_dense, out, imag_classifier])
model.add_loss(bc_loss)
model.compile(optimizer=Adam(lr=1e-4), loss=None)
return model
def test_generator_dynamic_shapes(self):
x = [
'I think juice is great',
'unknown is the best language since slicedbread',
'a a a a a a a',
'matmul'
'Yaks are also quite nice',
]
y = [1, 0, 0, 1, 1]
vocab = {
word: i + 1
for i, word in enumerate(
sorted(set(itertools.chain(*[i.split() for i in x]))))
}
def data_gen(batch_size=2):
np.random.seed(0)
data = list(zip(x, y)) * 10
np.random.shuffle(data)
def pack_and_pad(queue):
x = [[vocab[j] for j in i[0].split()] for i in queue]
pad_len = max(len(i) for i in x)
x = np.array([i + [0] * (pad_len - len(i)) for i in x])
y = np.array([i[1] for i in queue])
del queue[:]
return x, y[:, np.newaxis]
queue = []
for i, element in enumerate(data):
queue.append(element)
if not (i + 1) % batch_size:
yield pack_and_pad(queue)
if queue:
# Last partial batch
yield pack_and_pad(queue)
model = testing_utils.get_model_from_layers([
layers_module.Embedding(input_dim=len(vocab) + 1, output_dim=4),
layers_module.SimpleRNN(units=1),
layers_module.Activation('sigmoid')
],
input_shape=(None, ))
model.compile(loss=losses.binary_crossentropy, optimizer='sgd')
model.fit(data_gen(), epochs=1, steps_per_epoch=5)
def __init__(self, hidden_len=64):
super(MyLSTM, self).__init__()
self.embedding = layers.Embedding(hps.total_words,
hps.embedding_len,
input_length=hps.max_sentence_len)
self.state = [
tf.zeros(shape=[hps.batch_size, hidden_len]),
tf.zeros(shape=[hps.batch_size, hidden_len])
]
self.lstm_cell = MyLSTMCell(hidden_len=hidden_len)
self.drop = layers.Dropout(0.5)
self.fc = layers.Dense(1, activation=tf.nn.sigmoid)
def get_glove_model(vocab_size, glove_dimension, embed_matrix, max_length,
num_classes):
keras.backend.clear_session()
model = Sequential()
embed = layers.Embedding(vocab_size,
glove_dimension,
weights=[embed_matrix],
input_length=max_length,
trainable=False)
model.add(embed)
model.add(layers.Flatten())
model.add(layers.Dense(30, activation=tf.nn.relu)),
model.add(layers.Dropout(0.5))
model.add(layers.Dense(num_classes, activation=tf.nn.softmax))
return model
def define_model(self):
input_img = Input(shape=[
self.model_parameters.img_height,
self.model_parameters.img_width,
self.model_parameters.num_channels,
])
class_id = Input(shape=[1])
embedded_id = layers.Embedding(input_dim=10, output_dim=50)(class_id)
embedded_id = layers.Dense(units=input_img.shape[1] *
input_img.shape[2])(embedded_id)
embedded_id = layers.Flatten()(embedded_id)
x = layers.Conv2D(filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same')(input_img)
x = layers.BatchNormalization(momentum=0.9)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Conv2D(filters=128,
kernel_size=(4, 4),
strides=(2, 2),
padding='same')(x)
x = layers.BatchNormalization(momentum=0.9)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Conv2D(filters=128,
kernel_size=(4, 4),
strides=(2, 2),
padding='same')(x)
x = layers.BatchNormalization(momentum=0.9)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Flatten()(x)
x = layers.Concatenate()([x, embedded_id])
x = layers.Dense(units=512, activation='relu')(x)
x = layers.Dense(units=1)(x)
model = Model(name=self.model_name,
inputs=[input_img, class_id],
outputs=x)
return model
def build_model():
sequences = layers.Input(shape=(MAX_LENGTH, ))
embedded = layers.Embedding(MAX_FEATURES, 64)(sequences)
x = layers.Conv1D(64, 3, activation='relu')(embedded)
x = layers.BatchNormalization()(x)
x = layers.MaxPool1D(3)(x)
x = layers.Conv1D(64, 5, activation='relu')(x)
x = layers.BatchNormalization()(x)
x = layers.MaxPool1D(5)(x)
x = layers.Conv1D(64, 5, activation='relu')(x)
x = layers.GlobalMaxPool1D()(x)
x = layers.Flatten()(x)
x = layers.Dense(100, activation='relu')(x)
predictions = layers.Dense(1, activation='sigmoid')(x)
model = models.Model(inputs=sequences, outputs=predictions)
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['binary_accuracy'])
return model
def define_generator(latent_dim=50, nclasses=10):
label = layers.Input(shape=(1, ))
li = layers.Embedding(nclasses, 50)(label)
li = layers.Dense(7*7)(li)
li = layers.Reshape((7, 7, 1))(li)
in_lat = layers.Input((latent_dim,))
lat = layers.Dense(7*7*128)(in_lat)
lat = layers.Reshape((7, 7, 128))(lat)
x = layers.concatenate([li, lat], axis=-1)
x = layers.Conv2DTranspose(filters=128, kernel_size=4, strides=2, padding="same")(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Conv2DTranspose(filters=128, kernel_size=4, strides=2, padding="same")(x)
x = layers.LeakyReLU(alpha=0.2)(x)
out = layers.Conv2D(filters=1, kernel_size=7, activation="tanh", padding="same")(x)
model = tf.keras.Model([label, in_lat], out)
return model
def define_discriminator(in_shape=(28, 28, 1), nclasses=10):
label = layers.Input(shape=(1, ))
li = layers.Embedding(nclasses, 50)(label)
li = layers.Dense(in_shape[0]*in_shape[1])(li)
li = layers.Reshape(in_shape)(li)
image = layers.Input(shape=in_shape)
x = layers.concatenate([image, li], axis=-1)
x = layers.Conv2D(filters=128, kernel_size=3, strides=2, padding="same")(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Conv2D(filters=128, kernel_size=3, strides=2, padding="same")(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Flatten()(x)
x = layers.Dropout(0.4)(x)
out = layers.Dense(1, activation="sigmoid")(x)
model = tf.keras.Model([image, label], out)
return model
def build_lstm(num_filters, vocab_size, dropout, embedding_dim, maxlen,
optimizer):
sequential_lstm = Sequential()
sequential_lstm.add(
layers.Embedding(input_dim=vocab_size,
output_dim=embedding_dim,
input_length=maxlen))
sequential_lstm.add(layers.SpatialDropout1D(dropout))
sequential_lstm.add(
layers.LSTM(num_filters,
dropout=dropout,
recurrent_dropout=dropout,
return_sequences=True))
sequential_lstm.add(
layers.LSTM(num_filters, dropout=dropout, recurrent_dropout=dropout))
sequential_lstm.add(layers.Dense(6, activation='softmax'))
sequential_lstm.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
return sequential_lstm
