Download library/encoder_decoder.py from chhetri123/caption_generation_transformer: direct link, hf CLI and curl.
- Browser
- Download file 5.44 kB
-
https://huggingface.co/spaces/chhetri123/caption_generation_transformer/resolve/main/library/encoder_decoder.py
- Command line
-
hf download hf://spaces/chhetri123/caption_generation_transformer/library/encoder_decoder.py
-
curl -L -o encoder_decoder.py https://huggingface.co/spaces/chhetri123/caption_generation_transformer/resolve/main/library/encoder_decoder.py
5.44 kB
| import tensorflow as tf | |
| from library.Multihead_attention import MultiHeadAttention,point_wise_feed_forward_network | |
| from library.self_attention import positional_encoding_1d,positional_encoding_2d | |
| class EncoderLayer(tf.keras.layers.Layer): | |
| def __init__(self, d_model, num_heads, dff, rate=0.1): | |
| super(EncoderLayer, self).__init__() | |
| self.mha = MultiHeadAttention(d_model, num_heads) | |
| self.ffn = point_wise_feed_forward_network(d_model, dff) | |
| self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6) | |
| self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6) | |
| self.dropout1 = tf.keras.layers.Dropout(rate) | |
| self.dropout2 = tf.keras.layers.Dropout(rate) | |
| def call(self, x, training, mask=None): | |
| attn_output, _ = self.mha(x, x, x, mask) # (batch_size, input_seq_len, d_model) | |
| attn_output = self.dropout1(attn_output, training=training) | |
| out1 = self.layernorm1(x + attn_output) # (batch_size, input_seq_len, d_model) | |
| ffn_output = self.ffn(out1) # (batch_size, input_seq_len, d_model) | |
| ffn_output = self.dropout2(ffn_output, training=training) | |
| out2 = self.layernorm2(out1 + ffn_output) # (batch_size, input_seq_len, d_model) | |
| return out2 | |
| class DecoderLayer(tf.keras.layers.Layer): | |
| def __init__(self, d_model, num_heads, dff, rate=0.1): | |
| super(DecoderLayer, self).__init__() | |
| self.mha1 = MultiHeadAttention(d_model, num_heads) | |
| self.mha2 = MultiHeadAttention(d_model, num_heads) | |
| self.ffn = point_wise_feed_forward_network(d_model, dff) | |
| self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6) | |
| self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6) | |
| self.layernorm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6) | |
| self.dropout1 = tf.keras.layers.Dropout(rate) | |
| self.dropout2 = tf.keras.layers.Dropout(rate) | |
| self.dropout3 = tf.keras.layers.Dropout(rate) | |
| def call(self, x, enc_output, training, | |
| look_ahead_mask=None, padding_mask=None): | |
| # enc_output.shape == (batch_size, input_seq_len, d_model) | |
| # using look ahead mask so that during self attention current query dont consider future token | |
| attn1, attn_weights_block1 = self.mha1(x, x, x, look_ahead_mask) # (batch_size, target_seq_len, d_model) | |
| attn1 = self.dropout1(attn1, training=training) | |
| out1 = self.layernorm1(attn1 + x) | |
| # use padding mask to avoid padded values of both enc_output and dec_input | |
| attn2, attn_weights_block2 = self.mha2( | |
| enc_output, enc_output, out1, padding_mask) # (batch_size, target_seq_len, d_model) | |
| attn2 = self.dropout2(attn2, training=training) | |
| out2 = self.layernorm2(attn2 + out1) # (batch_size, target_seq_len, d_model) | |
| ffn_output = self.ffn(out2) # (batch_size, target_seq_len, d_model) | |
| ffn_output = self.dropout3(ffn_output, training=training) | |
| out3 = self.layernorm3(ffn_output + out2) # (batch_size, target_seq_len, d_model) | |
| return out3, attn_weights_block1, attn_weights_block2 | |
| class Encoder(tf.keras.layers.Layer): | |
| def __init__(self, num_layers, d_model, num_heads, dff, | |
| row_size,col_size,rate=0.1): | |
| super(Encoder, self).__init__() | |
| self.d_model = d_model | |
| self.num_layers = num_layers | |
| self.embedding = tf.keras.layers.Dense(self.d_model,activation='relu') | |
| self.pos_encoding = positional_encoding_2d(row_size,col_size, | |
| self.d_model) | |
| self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate) | |
| for _ in range(num_layers)] | |
| self.dropout = tf.keras.layers.Dropout(rate) | |
| def call(self, x, training, mask=None): | |
| # shape(x) = (batch_size,seq_len(H*W),features) | |
| seq_len = tf.shape(x)[1] | |
| # adding embedding and position encoding. | |
| x = self.embedding(x) # (batch_size, input_seq_len(H*W), d_model) | |
| x += self.pos_encoding[:, :seq_len, :] | |
| x = self.dropout(x, training=training) | |
| for i in range(self.num_layers): | |
| x = self.enc_layers[i](x, training, mask) | |
| return x # (batch_size, input_seq_len, d_model) | |
| class Decoder(tf.keras.layers.Layer): | |
| def __init__(self, num_layers, d_model, num_heads, dff, target_vocab_size, | |
| maximum_position_encoding, rate=0.1): | |
| super(Decoder, self).__init__() | |
| self.d_model = d_model | |
| self.num_layers = num_layers | |
| self.embedding = tf.keras.layers.Embedding(target_vocab_size, d_model) | |
| self.pos_encoding = positional_encoding_1d(maximum_position_encoding, d_model) | |
| self.dec_layers = [DecoderLayer(d_model, num_heads, dff, rate) | |
| for _ in range(num_layers)] | |
| self.dropout = tf.keras.layers.Dropout(rate) | |
| def call(self, x, enc_output, training, | |
| look_ahead_mask=None, padding_mask=None): | |
| seq_len = tf.shape(x)[1] | |
| attention_weights = {} | |
| x = self.embedding(x) # (batch_size, target_seq_len, d_model) | |
| x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32)) | |
| x += self.pos_encoding[:, :seq_len, :] | |
| x = self.dropout(x, training=training) | |
| for i in range(self.num_layers): | |
| x, block1, block2 = self.dec_layers[i](x, enc_output, training, | |
| look_ahead_mask, padding_mask) | |
| attention_weights['decoder_layer{}_block1'.format(i+1)] = block1 | |
| attention_weights['decoder_layer{}_block2'.format(i+1)] = block2 | |
| # x.shape == (batch_size, target_seq_len, d_model) | |
| return x, attention_weights |