Updated Data Processing module. Seq2Seq model added (unverified)

src/pipes/data.py

@@ -1,6 +1,5 @@
 import random
-import utils
-import const
+from pipes import utils, const
 
 
 class Sentence:

src/pipes/models.py

@@ -0,0 +1,71 @@
+import tensorflow as tf
+
+
+class Seq2Seq:
+    def __init__(self,
+                 input_vocab_size,
+                 output_vocab_size,
+                 embedding_dim,
+                 hidden_units):
+        self.epochs = 10
+        self.batch_size = 64
+        self.metrics = ['accuracy']
+        self.loss = tf.keras.losses.SparseCategoricalCrossentropy()
+        self.optimizer = tf.keras.optimizers.Adam()
+        self.model = None
+        self.embedding_dim = embedding_dim
+        self.hidden_units = hidden_units
+        self.input_vocab_size = input_vocab_size
+        self.output_vocab_size = output_vocab_size
+        self.encoder_embedding = tf.keras.layers.Embedding(self.input_vocab_size, self.embedding_dim)
+        self.encoder = tf.keras.layers.LSTM(self.hidden_units, return_sequences=True, return_state=True)
+        self.decoder_embedding = tf.keras.layers.Embedding(self.output_vocab_size, self.embedding_dim)
+        self.decoder = tf.keras.layers.LSTM(self.hidden_units, return_sequences=True, return_state=True)
+        self.output_layer = tf.keras.layers.Dense(self.output_vocab_size, activation='softmax')
+
+    def build(self):
+        encoder_inputs = tf.keras.Input(shape=(None,))
+        encoder_embedding = self.encoder_embedding(encoder_inputs)
+        encoder_outputs, state_h, state_c = self.encoder(encoder_embedding)
+        encoder_states = [state_h, state_c]
+        decoder_inputs = tf.keras.Input(shape=(None,))
+        decoder_embedding = self.decoder_embedding(decoder_inputs)
+        decoder_outputs, _, _ = self.decoder(decoder_embedding, initial_state=encoder_states)
+        outputs = self.output_layer(decoder_outputs)
+        self.model = tf.keras.Model([encoder_inputs, decoder_inputs], outputs)
+
+    def run(self, encoder_input_data, decoder_input_data, val_encoder_input_data, val_decoder_input_data):
+        self.model.compile(
+            optimizer=self.optimizer,
+            loss=self.loss,
+            metrics=self.metrics
+        )
+
+        decoder_target_data = [[sentence[1:] + [0]] for sentence in decoder_input_data]
+        val_decoder_target_data = [[sentence[1:] + [0]] for sentence in val_decoder_input_data]
+
+        self.model.fit(
+            ([encoder_input_data, decoder_input_data]),
+            decoder_target_data,
+            batch_size=self.batch_size,
+            epochs=self.epochs,
+            validation_data=([val_encoder_input_data, val_decoder_input_data], val_decoder_target_data)
+        )
+
+    def get(self):
+        return self.model
+
+    def set_epochs(self, epochs):
+        self.epochs = epochs
+
+    def set_batch_size(self, batch_size):
+        self.batch_size = batch_size
+
+    def set_loss(self, loss):
+        self.loss = loss
+
+    def set_optimizer(self, optimizer):
+        self.optimizer = optimizer
+
+    def set_metric(self, metrics):
+        self.metrics = metrics

src/seq2seqtrainer.py

@@ -0,0 +1,24 @@
+from pipes import models, utils, const
+from pipes.data import Dataset
+
+if __name__ == "__main__":
+    input_lang = 'gr'
+    output_lang = 'bn'
+
+    dataset_object = Dataset([input_lang, output_lang])
+    dataset_object.pack()
+    dataset_object.process()
+    dataset_dict = dataset_object.get_dict()
+
+    seq2seq = models.Seq2Seq(
+        input_vocab_size=dataset_dict[input_lang]["vocab_size"],
+        output_vocab_size=dataset_dict[output_lang]["vocab_size"],
+        embedding_dim=256,
+        hidden_units=64)
+    seq2seq.build()
+    seq2seq.run(
+        encoder_input_data=dataset_dict[input_lang]["train"],
+        decoder_input_data=dataset_dict[output_lang]["train"],
+        val_encoder_input_data=dataset_dict[input_lang]["val"],
+        val_decoder_input_data=dataset_dict[output_lang]["val"],
+    )