Upload 5 files

.gitattributes

@@ -36,3 +36,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 MicroGenerativeTeks/Decoder_Model.keras filter=lfs diff=lfs merge=lfs -text
 MicroGenerativeTeks/Encoder_Model.keras filter=lfs diff=lfs merge=lfs -text
 MicroGenerativeTeks/Projection_Model.keras filter=lfs diff=lfs merge=lfs -text
+Decoder_Model.keras filter=lfs diff=lfs merge=lfs -text

Decoder_Model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37eef0fa6c6dad97bfcd400d6a277827971793cbc16c7039049e9279c880d32b
+size 177537785

Decoders.py

@@ -0,0 +1,119 @@
+import tensorflow as tf
+from tensorflow import keras
+@keras.utils.register_keras_serializable()
+class BlockDecoder(keras.layers.Layer) :
+  def __init__(self,d_model,num_head,dff,drop_out=0.2,**kwargs) :
+    super(BlockDecoder,self).__init__(**kwargs)
+    self.self_attention = keras.layers.MultiHeadAttention(num_heads=num_head,key_dim=(d_model//num_head),dropout=drop_out)
+    self.cross_attention = keras.layers.MultiHeadAttention(num_heads=num_head,key_dim=(d_model//num_head),dropout=drop_out)
+    self.ffn = keras.Sequential([
+        keras.layers.Dense(dff,activation=keras.activations.gelu),
+        keras.layers.Dense(d_model)
+    ])
+    self.layernorm1 = keras.layers.LayerNormalization(epsilon=1e-6)
+    self.layernorm2 = keras.layers.LayerNormalization(epsilon=1e-6)
+    self.layernorm3 = keras.layers.LayerNormalization(epsilon=1e-6)
+    self.dropout = keras.layers.Dropout(drop_out)
+    self.d_model = d_model
+    self.num_head = num_head
+    self.dff = dff
+    self.name = "BlockGeneretiveDecoders"
+    self.drop_rate = drop_out
+
+  def call(self,x,training=False,with_encoder = False) :
+    dec_attn,enc_attn = x
+    attn1 = self.self_attention(dec_attn,dec_attn,dec_attn,training=training,use_causal_mask = True)
+    attn1 = self.layernorm1(attn1 + dec_attn,training=training)
+    if with_encoder is True:
+      cross_attn = self.cross_attention(attn1,enc_attn,enc_attn,training=training)
+      cross_attn = self.layernorm2(cross_attn + attn1,training=training)
+    else :
+      dummy_attn = tf.zeros_like(attn1)
+      dummy_attn = self.cross_attention(dummy_attn,dummy_attn,dummy_attn)
+      _ = tf.stop_gradient(dummy_attn)
+      cross_attn = attn1
+
+    ffn = self.ffn(cross_attn)
+    ffn = self.dropout(ffn,training=training)
+    ffn = self.layernorm3(ffn + cross_attn,training=training)
+    return ffn
+
+  def get_config(self) :
+    config = super(BlockDecoder,self).get_config()
+    config.update({
+        "d_model" : self.d_model,
+        "num_head" : self.num_head,
+        "dff" : self.dff,
+        "drop_rate" : self.drop_rate
+    })
+    return config
+  @classmethod
+  def from_config(cls,config) :
+    return cls(**config)
+
+@keras.utils.register_keras_serializable()
+class Decoder(keras.Model) :
+  def __init__(self,d_model=512,vocab_size=18191,dff=1024,num_head=16,max_pos=551,drop_out=0.05,**kwargs) :
+    super(Decoder,self).__init__(**kwargs)
+    self.d_model = d_model
+    self.dff = dff
+    self.num_head = num_head
+    self.max_pos = max_pos
+    self.drop_out = drop_out
+    self.name="DecodersModels"
+    self.vocab_size = vocab_size
+    self.Embedding = keras.layers.Embedding(self.vocab_size,self.d_model)
+    self.PositionalEncoding = keras.layers.Embedding(self.max_pos,self.d_model)
+    self.block1 = BlockDecoder(d_model,num_head,dff,drop_out)
+    self.block2 = BlockDecoder(d_model,num_head,dff,drop_out)
+    self.block3 = BlockDecoder(d_model,num_head,dff,drop_out)
+    self.block4 = BlockDecoder(d_model,num_head,dff,drop_out)
+    self.block5 = BlockDecoder(d_model,num_head,dff,drop_out)
+    self.block6 = BlockDecoder(d_model,num_head,dff,drop_out)
+    self.block7 = BlockDecoder(d_model,num_head,dff,drop_out)
+    self.block8 = BlockDecoder(d_model,num_head,dff,drop_out)
+    self.linear = keras.layers.Dense(vocab_size)
+    self.projection_enc = keras.layers.Dense(d_model)
+
+  def call(self,x,training=True,with_encoder = False) :
+    decod_token,enc_log = x
+    if with_encoder is True:
+      enc_log = self.projection_enc(enc_log)
+    else  :
+      enc_log = tf.zeros((tf.shape(decod_token)[0],tf.shape(decod_token)[1],self.d_model))
+      enc_log = self.projection_enc(enc_log)
+      _= tf.stop_gradient(enc_log)
+    seq_len = tf.shape(decod_token)[1]
+    decod_log = self.Embedding(decod_token)
+    decod_log *= tf.math.sqrt(tf.cast(self.d_model,tf.float32))
+    pos = tf.range(start=0,limit=seq_len,delta=1)
+    pos = tf.where(pos<self.max_pos,pos,self.max_pos-1)
+    pos = self.PositionalEncoding(pos)
+    pos = tf.expand_dims(pos,axis=0)
+    decod_log += pos
+    logits= self.block1([decod_log,enc_log],training=training,with_encoder = with_encoder)
+    logits = self.block2([logits,enc_log],training=training,with_encoder=with_encoder)
+    logits = self.block3([logits,enc_log],training=training,with_encoder=with_encoder)
+    logits = self.block4([logits,enc_log],training=training,with_encoder=with_encoder)
+    logits = self.block5([logits,enc_log],training=training,with_encoder=with_encoder)
+    logits = self.block6([logits,enc_log],training=training,with_encoder=with_encoder)
+    logits = self.block7([logits,enc_log],training=training,with_encoder=with_encoder)
+    logits = self.block8([logits,enc_log],training=training,with_encoder=with_encoder)
+    logits = self.linear(logits)
+    return logits
+
+  def get_config(self) :
+    config = super(Decoder,self).get_config()
+    config.update({
+        "d_model" : self.d_model,
+        "dff" : self.dff,
+        "num_head" : self.num_head,
+        "max_pos" : self.max_pos,
+        "drop_out" : self.drop_out,
+        "vocab_size" : self.vocab_size
+    })
+    return config
+
+  @classmethod
+  def from_config(cls,config) :
+    return cls(**config)

Tokenizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eeaf5a1a0d6859528b933a45d7e02550d77df9d82105bf4bd8fb660ca10adb84
+size 724960

config.json

@@ -0,0 +1,12 @@
+{
+    "model_type" :
+    "Micro-Generative-Transformers",
+    "architectures" :
+    ["MicroGenerativeTeks"],
+        "d_model" : 512,
+        "dff" : 1024,
+        "num_head" : 16,
+        "max_pos" : 250,
+        "drop_out" : 0.05,
+        "vocab_size" : 18191
+}

model_index.json

@@ -0,0 +1,6 @@
+{
+    "auto_map" : {
+        "AutoModel":
+        "Decoders.py::Decoder"
+    }
+}