# coding: utf-8 from __future__ import absolute_import from __future__ import division from __future__ import print_function import copy import tensorflow as tf from models import func from utils import util, dtype def encoder(source, mask, params, in_text=False, to_gloss=False): # - in_text: if true, source is word ids and we need an embedding layer to extract source input # if false, source is sign video features # - to_gloss: if true, translation into glosses # if false, translation into text # we append an indicator vector to guide the model where to generate hidden_size = params.hidden_size initializer = tf.random_normal_initializer(0.0, hidden_size ** -0.5) if not in_text: # project sign video features to the embedding space features = func.linear(source, hidden_size, scope="premapper") else: mask = dtype.tf_to_float(tf.cast(source, tf.bool)) embed_name = "embedding" if params.shared_source_target_embedding \ else "src_embedding" src_emb = tf.get_variable(embed_name, [params.src_vocab.size(), params.embed_size], initializer=initializer) src_bias = tf.get_variable("bias", [params.embed_size]) inputs = tf.gather(src_emb, source) * (hidden_size ** 0.5) features = tf.nn.bias_add(inputs, src_bias) # handle text or gloss generation gloss_indicator = tf.get_variable("gloss", [1, params.embed_size]) trans_indicator = tf.get_variable("trans", [1, params.embed_size]) indicator = gloss_indicator if to_gloss else trans_indicator # adding indicator in front of the inputs mask = tf.pad(mask, [[0, 0], [1, 0]], constant_values=1) ishp = util.shape_list(features) features = tf.concat([util.expand_tile_dims(indicator, ishp[0], axis=0), features], 1) inputs = func.add_timing_signal(features) inputs = func.layer_norm(inputs) inputs = util.valid_apply_dropout(inputs, params.dropout) with tf.variable_scope("encoder"): x = inputs for layer in range(params.num_encoder_layer): if params.deep_transformer_init: layer_initializer = tf.variance_scaling_initializer( params.initializer_gain * (layer + 1) ** -0.5, mode="fan_avg", distribution="uniform") else: layer_initializer = None # modality-specific layers: # - when layer <= sep_layer, we apply different encoder layers to sign videos and texts with tf.variable_scope( "layer_{}".format(layer) if layer > params.sep_layer else "layer_{}_{}".format(layer, 'mt' if in_text else 'st'), initializer=layer_initializer): with tf.variable_scope("self_attention"): y = func.dot_attention( x, None, func.attention_bias(mask, "masking"), hidden_size, num_heads=params.num_heads, dropout=params.attention_dropout, ) y = y['output'] x = func.residual_fn(x, y, dropout=params.residual_dropout) x = func.layer_norm(x) with tf.variable_scope("feed_forward"): y = func.ffn_layer( x, params.filter_size, hidden_size, dropout=params.relu_dropout, ) x = func.residual_fn(x, y, dropout=params.residual_dropout) x = func.layer_norm(x) source_encodes = x batch_size = tf.shape(x)[0] cache_shape = tf.stack([ batch_size, tf.constant(0, dtype=batch_size.dtype), tf.constant(hidden_size, dtype=batch_size.dtype), ]) def _empty_cache(): # ensure zero states are created with dynamic batch size without touching NumPy return dtype.tf_to_float(tf.zeros(cache_shape)) return { "encodes": source_encodes, "decoder_initializer": { "layer_{}".format(l): { "k": _empty_cache(), "v": _empty_cache(), } for l in range(params.num_decoder_layer) }, "mask": mask } def decoder(target, state, params, labels=None, is_img=None, collect_attention=False): mask = dtype.tf_to_float(tf.cast(target, tf.bool)) hidden_size = params.hidden_size initializer = tf.random_normal_initializer(0.0, hidden_size ** -0.5) is_training = ('decoder' not in state) # Collect cross-attention weights for analysis (only during inference) cross_attention_weights = [] if (collect_attention and not is_training) else None embed_name = "embedding" if params.shared_source_target_embedding \ else "tgt_embedding" tgt_emb = tf.get_variable(embed_name, [params.tgt_vocab.size(), params.embed_size], initializer=initializer) tgt_bias = tf.get_variable("bias", [params.embed_size]) inputs = tf.gather(tgt_emb, target) * (hidden_size ** 0.5) inputs = tf.nn.bias_add(inputs, tgt_bias) # shift if is_training: inputs = tf.pad(inputs, [[0, 0], [1, 0], [0, 0]]) inputs = inputs[:, :-1, :] inputs = func.add_timing_signal(inputs) else: inputs = tf.cond(tf.reduce_all(tf.equal(target, params.tgt_vocab.pad())), lambda: tf.zeros_like(inputs), lambda: inputs) mask = tf.ones_like(mask) inputs = func.add_timing_signal(inputs, time=dtype.tf_to_float(state['time'])) inputs = util.valid_apply_dropout(inputs, params.dropout) with tf.variable_scope("decoder"): x = inputs for layer in range(params.num_decoder_layer): if params.deep_transformer_init: layer_initializer = tf.variance_scaling_initializer( params.initializer_gain * (layer + 1) ** -0.5, mode="fan_avg", distribution="uniform") else: layer_initializer = None with tf.variable_scope("layer_{}".format(layer), initializer=layer_initializer): with tf.variable_scope("self_attention"): y = func.dot_attention( x, None, func.attention_bias(tf.shape(mask)[1], "causal"), hidden_size, num_heads=params.num_heads, dropout=params.attention_dropout, cache=None if is_training else state['decoder']['state']['layer_{}'.format(layer)], ) if not is_training: # k, v state['decoder']['state']['layer_{}'.format(layer)].update(y['cache']) y = y['output'] x = func.residual_fn(x, y, dropout=params.residual_dropout) x = func.layer_norm(x) with tf.variable_scope("cross_attention"): y = func.dot_attention( x, state['encodes'], func.attention_bias(state['mask'], "masking"), hidden_size, num_heads=params.num_heads, dropout=params.attention_dropout, cache=None if is_training else state['decoder']['state']['layer_{}'.format(layer)], ) if not is_training: # mk, mv state['decoder']['state']['layer_{}'.format(layer)].update(y['cache']) # Collect cross-attention weights (last layer only, averaged over heads) if cross_attention_weights is not None and layer == params.num_decoder_layer - 1: # y['weights']: [batch, num_heads, tgt_len, src_len] # Average over heads: [batch, tgt_len, src_len] cross_attention_weights.append(tf.reduce_mean(y['weights'], axis=1)) y = y['output'] x = func.residual_fn(x, y, dropout=params.residual_dropout) x = func.layer_norm(x) with tf.variable_scope("feed_forward"): y = func.ffn_layer( x, params.filter_size, hidden_size, dropout=params.relu_dropout, ) x = func.residual_fn(x, y, dropout=params.residual_dropout) x = func.layer_norm(x) feature = x embed_name = "tgt_embedding" if params.shared_target_softmax_embedding \ else "softmax_embedding" embed_name = "embedding" if params.shared_source_target_embedding \ else embed_name softmax_emb = tf.get_variable(embed_name, [params.tgt_vocab.size(), params.embed_size], initializer=initializer) feature = tf.reshape(feature, [-1, params.embed_size]) logits = tf.matmul(feature, softmax_emb, False, True) logits = tf.cast(logits, tf.float32) soft_label, normalizer = util.label_smooth( target, util.shape_list(logits)[-1], factor=params.label_smooth) centropy = tf.nn.softmax_cross_entropy_with_logits_v2( logits=logits, labels=soft_label ) centropy -= normalizer centropy = tf.reshape(centropy, tf.shape(target)) mask = tf.cast(mask, tf.float32) per_sample_loss = tf.reduce_sum(centropy * mask, -1) / tf.reduce_sum(mask, -1) # for sign-related tasks, we need is_img to distinguish which examples are sign examples if is_img is None: loss = tf.reduce_mean(per_sample_loss) else: loss = tf.reduce_sum(per_sample_loss * is_img) / (tf.reduce_sum(is_img) + 1e-8) # computing CTC regularization term # note we only retrain sign2text's CTC regularizer if is_training and params.ctc_enable and labels is not None: assert labels is not None # batch x seq x dim encoding = state['encodes'] enc_logits = func.linear(encoding, params.src_vocab.size() + 1, scope="ctc_mapper") # seq dimension transpose enc_logits = tf.transpose(enc_logits, (1, 0, 2)) enc_logits = tf.to_float(enc_logits) with tf.name_scope('loss'): ctc_loss = tf.nn.ctc_loss( labels, enc_logits, tf.cast(tf.reduce_sum(state['mask'], -1), tf.int32), ignore_longer_outputs_than_inputs=True, preprocess_collapse_repeated=params.ctc_repeated) ctc_loss /= tf.reduce_sum(mask, -1) if is_img is None: ctc_loss = tf.reduce_mean(ctc_loss) else: ctc_loss = tf.reduce_sum(ctc_loss * is_img) / (tf.reduce_sum(is_img) + 1e-8) loss = params.ctc_alpha * ctc_loss + loss # Return attention weights if collected if cross_attention_weights is not None and len(cross_attention_weights) > 0: # Shape: [batch, 1, src_len] (only last token's attention) state['cross_attention'] = cross_attention_weights[0] return loss, logits, state, per_sample_loss def train_fn(features, params, initializer=None): with tf.variable_scope(params.scope_name or "model", initializer=initializer, reuse=tf.AUTO_REUSE, dtype=tf.as_dtype(dtype.floatx()), custom_getter=dtype.float32_variable_storage_getter): # features contains five items # - image: [batch, sign_video_len, feature_dim] (float) extracted sign video features based on SMKD # - mask : [batch, sign_video_len] (float) mask for sign video features # - source: [batch, src_seq_len] (int, ids) gloss or MT source inputs # - target: [batch, tgt_seq_len] (int, ids) gloss translation or MT target # - is_img: [batch] (float, like mask, 0.0 or 1.0) indicate whether the example comes from SLT # note SLT example contains sign videos; but MT doesn't # for SLT examples, the training data is a triple (sign video, gloss, text) # for MT examples, the training data is also a triple (dummy video, source, target) # sign translation: sign2text state = encoder(features['image'], features['mask'], params, in_text=False, to_gloss=False) loss_trans, *others = decoder( features['target'], state, params, labels=features['label'] if params.ctc_enable else None, is_img=features["is_img"]) # sign recognition: sign2gloss state = encoder(features['image'], features['mask'], params, in_text=False, to_gloss=True) # note we only add one CTC objective in sing2text, here we directly set labels `None` loss_gloss, *others = decoder( features['source'], state, params, labels=None, is_img=features["is_img"]) # gloss2text translation & machine translation: both are text-to-text tasks state = encoder(features['source'], None, params, in_text=True, to_gloss=False) loss_g2t, *others = decoder(features['target'], state, params, labels=None, is_img=None) # note included in the final objective # # text2gloss translation # state = encoder(features['target'], None, params, in_text=True, to_gloss=True) # loss_t2g, *others = decoder( # features['source'], state, params, labels=None, is_img=features["is_img"]) # sum-up all loss terms loss = loss_trans + loss_gloss + loss_g2t return { "loss": loss } def infer_fn(params): params = copy.copy(params) params = util.closing_dropout(params) def encoding_fn(image, mask): with tf.variable_scope(params.scope_name or "model", reuse=tf.AUTO_REUSE, dtype=tf.as_dtype(dtype.floatx()), custom_getter=dtype.float32_variable_storage_getter): eval_task = params.eval_task if eval_task == 'sign2text': state = encoder(image, mask, params, in_text=False, to_gloss=False) elif eval_task == 'sign2gloss': state = encoder(image, mask, params, in_text=False, to_gloss=True) elif eval_task == 'gloss2text': state = encoder(image, mask, params, in_text=True, to_gloss=False) else: raise NotImplementedError(f"Not supporting {eval_task}") state["decoder"] = { "state": state["decoder_initializer"] } return state def decoding_fn(target, state, time): with tf.variable_scope(params.scope_name or "model", reuse=tf.AUTO_REUSE, dtype=tf.as_dtype(dtype.floatx()), custom_getter=dtype.float32_variable_storage_getter): state['time'] = time # Enable attention collection if requested via params collect_attn = getattr(params, 'collect_attention_weights', False) step_loss, step_logits, step_state, _ = decoder( target, state, params, collect_attention=collect_attn) del state['time'] return step_logits, step_state return encoding_fn, decoding_fn