def make_entity_start_model(bert_path, ckpt_file, max_seq_len, bert_dim):
model_ckpt = bert_path + ckpt_file
bert_params = params_from_pretrained_ckpt(bert_path)
bert_layer = BertModelLayer.from_params(bert_params,
name="bert",
trainable=True)
slice_fn = make_gather_entity_start_fn(bert_dim)
input_ids = Input(shape=(max_seq_len, ), dtype='int32')
index_ent1 = Input(shape=(2, ), dtype='int32')
index_ent2 = Input(shape=(2, ), dtype='int32')
bert_emb = bert_layer(input_ids)
ent1_start = Lambda(lambda x: slice_fn(x))([bert_emb, index_ent1])
ent2_start = Lambda(lambda x: slice_fn(x))([bert_emb, index_ent2])
concat = concatenate([ent1_start, ent2_start])
output = Dense(2, activation='softmax')(concat)
model = Model(inputs=[input_ids, index_ent1, index_ent2], outputs=output)
model.build(input_shape=(None, max_seq_len))
load_bert_weights(bert_layer, model_ckpt)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
def make_entity_border_encoder(bert_path, ckpt_file, max_seq_len, bert_dim):
model_ckpt = bert_path + ckpt_file
bert_params = params_from_pretrained_ckpt(bert_path)
bert_layer = BertModelLayer.from_params(bert_params,
name="bert",
trainable=False)
gather_fn = make_gather_entity_border_fn(bert_dim)
input_ids = Input(shape=(max_seq_len, ), dtype='int32')
index_border_ent1 = Input(shape=(2, ), dtype='int32')
index_border_ent2 = Input(shape=(2, ), dtype='int32')
bert_emb = bert_layer(input_ids)
ent1_avg_emb = Lambda(lambda x: gather_fn(x))(
[bert_emb, index_border_ent1])
ent2_avg_emb = Lambda(lambda x: gather_fn(x))(
[bert_emb, index_border_ent2])
ent1_flatten = Flatten()(ent1_avg_emb)
ent2_flatten = Flatten()(ent2_avg_emb)
output = concatenate([ent1_flatten, ent2_flatten])
model = Model(inputs=[input_ids, index_border_ent1, index_border_ent2],
outputs=output)
model.build(input_shape=(None, max_seq_len))
load_bert_weights(bert_layer, model_ckpt)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
def build_model(self):
x = Input(shape=(self.input_shape, ))
outputs = self.regime(x, self.num_stages, self.hidden_size,
self.num_class, self.graph_model,
self.graph_param)
model = Model(inputs=[x], outputs=[outputs])
model.build(input_shape=[self.input_shape])
return model
def build_critic_model(self, input_size, action_size, model_name='critic'):
"""
Returns Q(st+1 | a, s)
"""
inputs = [Input(shape=(input_size)), Input(shape=(action_size, ))]
concat = Concatenate(axis=-1)(inputs)
x = Dense(24, name="hidden_1", activation='tanh')(concat)
x = Dense(48, name="hidden_2", activation='tanh')(x)
output = Dense(1, name="Out")(x)
model = Model(inputs=inputs, outputs=output, name=model_name)
model.build(input_shape=[(input_size, ), (action_size, )])
return model
def make_cls_encoder(bert_path, ckpt_file, max_seq_len, bert_dim):
model_ckpt = bert_path + ckpt_file
bert_params = params_from_pretrained_ckpt(bert_path)
bert_layer = BertModelLayer.from_params(bert_params,
name="bert",
trainable=False)
input_ids = Input(shape=(max_seq_len, ), dtype='int32')
bert_emb = bert_layer(input_ids)
output = Lambda(lambda x: tf.gather(x, indices=0, axis=1))(bert_emb)
model = Model(inputs=input_ids, outputs=output)
model.build(input_shape=(None, max_seq_len))
load_bert_weights(bert_layer, model_ckpt)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
def encoder_df(self):
""" DFL SAE DF Encoder Network"""
global TPU_ADDRESS
input_ = Input(shape=self.input_shape)
dims = self.input_shape[-1] * self.config["encoder_dims"]
lowest_dense_res = self.input_shape[0] // 16
var_x = input_
var_x = self.blocks.conv(var_x, dims)
var_x = self.blocks.conv(var_x, dims * 2)
var_x = self.blocks.conv(var_x, dims * 4)
var_x = self.blocks.conv(var_x, dims * 8)
var_x = Dense(self.ae_dims)(Flatten()(var_x))
var_x = Dense(lowest_dense_res * lowest_dense_res *
self.ae_dims)(var_x)
var_x = Reshape(
(lowest_dense_res, lowest_dense_res, self.ae_dims))(var_x)
var_x = self.blocks.upscale(var_x, self.ae_dims)
gpu_model = KerasModel(input_, var_x)
gpu_model.build(self.input_shape)
return gpu_model
def create_text_model(max_seq_len,
bert_ckpt_file,
bert_config_file,
NUM_CLASS,
overwriteLayerAndEmbeddingSize=False,
isPreTrained=False,
pathToBertModelWeights=None,
isTrainable=True):
with GFile(bert_config_file, "r") as reader:
bc = StockBertConfig.from_json_string(reader.read())
if overwriteLayerAndEmbeddingSize:
bc.max_position_embeddings = max_seq_len
bert_params = map_stock_config_to_params(bc)
bert_params.adapter_size = None
bert = BertModelLayer.from_params(bert_params, name="bert")
input_ids = Input(shape=(max_seq_len, ), dtype='int32', name="input_ids")
bert_output = bert(input_ids)
print("bert shape", bert_output.shape)
cls_out = Lambda(lambda seq: seq[:, 0, :],
name='bert_output_layer_768')(bert_output)
cls_out = Dropout(0.5)(cls_out)
output = Dense(NUM_CLASS, activation="softmax")(cls_out) #
model_bert = Model(inputs=input_ids, outputs=output, name='BERT')
model_bert.build(input_shape=(None, max_seq_len))
if not isPreTrained:
load_stock_weights(bert, bert_ckpt_file)
return model_bert
else:
model_bert.load_weights(pathToBertModelWeights)
if not isTrainable:
for layer in model_bert.layers:
layer.trainable = False
return model_bert, 2
def HPE(num_modules=4):
layers_dict = dict()
inputs = Input(shape=(256, 256, 3),
batch_size=16,
sparse=False,
ragged=False)
#base part
conv1 = layers.Conv2D(64, (7, 7), padding='same', strides=2)
bn1 = layers.BatchNormalization()
conv2 = ConvBlock(64, 128)
conv3 = ConvBlock(128, 128)
conv4 = ConvBlock(128, 256)
# Stacking part
for hg_module in range(num_modules):
layers_dict['m' + str(hg_module)] = HourGlass(1, 4, 256)
layers_dict['top_m_' + str(hg_module)] = ConvBlock(256, 256)
layers_dict['conv_last' + str(hg_module)] = layers.Conv2D(
256, (1, 1), padding='valid', strides=1)
layers_dict['bn_end' + str(hg_module)] = layers.BatchNormalization()
layers_dict['l' + str(hg_module)] = layers.Conv2D(
16, (1, 1), padding='valid', strides=1) # 16 heatmaps
if hg_module < num_modules - 1:
layers_dict['bl' + str(hg_module)] = layers.Conv2D(256, (1, 1),
padding='valid',
strides=1)
layers_dict['al' + str(hg_module)] = layers.Conv2D(256, (1, 1),
padding='valid',
strides=1)
# Call
x = tf.nn.relu(bn1(conv1(inputs)))
x = conv2(x)
x = layers.AveragePooling2D((2, 2), strides=2)(x)
x = conv3(x)
x = conv4(x)
previous = x
outputs = []
for i in range(num_modules):
hg = layers_dict['m' + str(i)](previous)
ll = hg
ll = layers_dict['top_m_' + str(i)](ll)
ll = tf.nn.relu(layers_dict['bn_end' + str(i)](
layers_dict['conv_last' + str(i)](ll)))
# Predict heatmaps
tmp_out = layers_dict['l' + str(i)](ll)
outputs.append(tmp_out)
if i < num_modules - 1:
ll = layers_dict['bl' + str(i)](ll)
tmp_out_ = layers_dict['al' + str(i)](tmp_out)
previous = previous + ll + tmp_out_
opt = tf.keras.optimizers.Adam(learning_rate=1e-03)
model = models.Model(inputs=inputs, outputs=outputs[-1], name='HPE')
model.compile(optimizer=opt, loss=HeatmapLoss)
model.build((None, 256, 256, 3))
model.summary()
return model
def decoder(self):
""" DFL SAE Decoder Network"""
global TPU_ADDRESS
if self.architecture == "liae":
input_shape = np.array(
self.networks["intermediate"].output_shapes[0][1:]) * (1, 1, 2)
else:
input_shape = self.networks["encoder"].output_shapes[0][1:]
input_ = Input(shape=input_shape)
outputs = list()
dims = self.input_shape[-1] * self.config["decoder_dims"]
var_x = input_
var_x1 = self.blocks.upscale(var_x, dims * 8, res_block_follows=True)
var_x1 = self.blocks.res_block(var_x1, dims * 8)
var_x1 = self.blocks.res_block(var_x1, dims * 8)
if self.multiscale_count >= 3:
outputs.append(
self.blocks.conv2d(var_x1,
3,
kernel_size=5,
padding="same",
activation="sigmoid",
name="face_out_32"))
var_x2 = self.blocks.upscale(var_x1, dims * 4, res_block_follows=True)
var_x2 = self.blocks.res_block(var_x2, dims * 4)
var_x2 = self.blocks.res_block(var_x2, dims * 4)
if self.multiscale_count >= 2:
outputs.append(
self.blocks.conv2d(var_x2,
3,
kernel_size=5,
padding="same",
activation="sigmoid",
name="face_out_64"))
var_x3 = self.blocks.upscale(var_x2, dims * 2, res_block_follows=True)
var_x3 = self.blocks.res_block(var_x3, dims * 2)
var_x3 = self.blocks.res_block(var_x3, dims * 2)
outputs.append(
self.blocks.conv2d(var_x3,
3,
kernel_size=5,
padding="same",
activation="sigmoid",
name="face_out_128"))
if self.use_mask:
var_y = input_
var_y = self.blocks.upscale(var_y, self.config["decoder_dims"] * 8)
var_y = self.blocks.upscale(var_y, self.config["decoder_dims"] * 4)
var_y = self.blocks.upscale(var_y, self.config["decoder_dims"] * 2)
var_y = self.blocks.conv2d(var_y,
1,
kernel_size=5,
padding="same",
activation="sigmoid",
name="mask_out")
outputs.append(var_y)
gpu_model = KerasModel(input_, outputs=outputs)
gpu_model.build(input_shape)
return gpu_model
