Rename app.py to main.py

app.py

@@ -1,64 +0,0 @@
-from fastapi import FastAPI, Request
-from pydantic import BaseModel
-import numpy as np
-import tensorflow as tf
-import json
-import os
-
-app = FastAPI()
-
-# Load model files
-encoder_model = tf.keras.models.load_model("saved_models/encoder.h5")
-decoder_model = tf.keras.models.load_model("saved_models/decoder.h5")
-
-# Load token files
-with open("saved_models/input_token_index.json", "r") as f:
-    input_token_index = json.load(f)
-
-with open("saved_models/target_token_index.json", "r") as f:
-    target_token_index = json.load(f)
-
-with open("saved_models/reverse_target_char_index.json", "r") as f:
-    reverse_target_char_index = json.load(f)
-
-max_encoder_seq_length = 20  # adjust based on your training
-num_decoder_tokens = len(target_token_index)
-
-class InputText(BaseModel):
-    text: str
-
-def decode_sequence(input_seq):
-    # Convert input text to one-hot
-    encoder_input_data = np.zeros((1, max_encoder_seq_length, len(input_token_index)))
-    for t, char in enumerate(input_seq):
-        if char in input_token_index:
-            encoder_input_data[0, t, input_token_index[char]] = 1.0
-
-    states_value = encoder_model.predict(encoder_input_data)
-
-    target_seq = np.zeros((1, 1, num_decoder_tokens))
-    target_seq[0, 0, target_token_index["\t"]] = 1.0
-
-    stop_condition = False
-    decoded_sentence = ""
-    while not stop_condition:
-        output_tokens, h, c = decoder_model.predict([target_seq] + states_value)
-
-        sampled_token_index = np.argmax(output_tokens[0, -1, :])
-        sampled_char = reverse_target_char_index[str(sampled_token_index)]
-        decoded_sentence += sampled_char
-
-        if sampled_char == "\n" or len(decoded_sentence) > max_encoder_seq_length:
-            stop_condition = True
-
-        target_seq = np.zeros((1, 1, num_decoder_tokens))
-        target_seq[0, 0, sampled_token_index] = 1.0
-        states_value = [h, c]
-
-    return decoded_sentence.strip()
-
-@app.post("/translate")
-def translate_text(input: InputText):
-    roman_urdu = input.text.lower()
-    result = decode_sequence(roman_urdu)
-    return {"result": result}

main.py

@@ -0,0 +1,74 @@
+from fastapi import FastAPI, Request
+from pydantic import BaseModel
+from tensorflow.keras.models import load_model
+import numpy as np
+import pickle
+
+# Initialize FastAPI app
+app = FastAPI(title="Roman Urdu to Urdu Translator API")
+
+# Load models
+encoder_model = load_model('roman_to_urdu_encoder.keras')
+decoder_model = load_model('roman_to_urdu_decoder.keras')
+
+# Load token indices and dictionary
+with open('roman_urdu_dict.pkl', 'rb') as f:
+    translation_dict = pickle.load(f)
+
+with open('roman_urdu_indices.pkl', 'rb') as f:
+    data = pickle.load(f)
+
+input_token_index = data['input_token_index']
+target_token_index = data['target_token_index']
+reverse_target_char_index = data['reverse_target_char_index']
+max_encoder_seq_length = data['max_encoder_seq_length']
+max_decoder_seq_length = data['max_decoder_seq_length']
+
+# Input schema
+class TranslateRequest(BaseModel):
+    text: str
+
+# Decoder function
+def decode_sequence(input_seq):
+    states_value = encoder_model.predict(input_seq)
+    target_seq = np.zeros((1, 1, len(target_token_index)))
+    target_seq[0, 0, target_token_index['\t']] = 1.0
+
+    decoded_sentence = ""
+    while True:
+        output_tokens, h, c = decoder_model.predict([target_seq] + states_value)
+        sampled_token_index = np.argmax(output_tokens[0, -1, :])
+        sampled_char = reverse_target_char_index[sampled_token_index]
+        decoded_sentence += sampled_char
+
+        if sampled_char == "\n" or len(decoded_sentence) > max_decoder_seq_length:
+            break
+
+        target_seq = np.zeros((1, 1, len(target_token_index)))
+        target_seq[0, 0, sampled_token_index] = 1.0
+        states_value = [h, c]
+
+    return decoded_sentence.strip()
+
+# Translate single word
+def translate_single_word(word):
+    input_seq = np.zeros((1, max_encoder_seq_length, len(input_token_index)))
+    for t, char in enumerate(word):
+        if char in input_token_index:
+            input_seq[0, t, input_token_index[char]] = 1.0
+    return decode_sequence(input_seq)
+
+# Main translation function
+def translate_to_urdu(roman_input: str):
+    if roman_input in translation_dict:
+        return translation_dict[roman_input]
+    if ' ' in roman_input:
+        return ' '.join([translation_dict.get(word, translate_single_word(word)) for word in roman_input.split()])
+    return translate_single_word(roman_input)
+
+# API route
+@app.post("/translate")
+async def translate(request: TranslateRequest):
+    roman_text = request.text.strip()
+    urdu_output = translate_to_urdu(roman_text)
+    return {"urdu_translation": urdu_output}