app.py

import gradio as gr
import numpy as np


from sklearn.feature_extraction.text import CountVectorizer
from tensorflow.keras.models import Model
from tensorflow.keras import models
from tensorflow.keras.layers import Input,LSTM,Dense
input_texts_translation=['again.', 'arrive.', 'bathroom.', 'believe.', 'can.', 'deaf.', 'fine.', 'go.', 'hello.', 'help.', 'home.', 'how.', 'hungury.', 'sorry.', 'call.', 'later.', 'learn.', 'like.', 'live.', 'meet.', 'my.', 'name.', 'nice.', 'no.', 'please.', 'see.', 'share.', 'sign.', 'slow.', 'takecare.', 'talk.', 'thank you.', 'time.', 'understand.', 'we.', 'what.', 'when.', 'where.', 'who.', 'yes.', 'you.', 'you.', 'you.', 'you.', 'name.', 'good.', 'everning.', 'night.', 'how you.', 'you name what.', 'my name.', 'you live where.', 'i.', 'live.', 'you help.', 'yes help me.', 'you understand.', 'i hungry.', 'good everning.', 'good night.', 'pleased.', 'nice meet you.', 'i fine.', 'home arrive when.', 'where bathroom.', 'believe my.', 'call.', 'call.','deaf.', 'i call later.', 'i deaf.', 'what time.', 'i sorry.', 'on my.', 'my.', 'believe.', 'learn.', 'learn.', 'what are you learning.', 'you learn sign where.', 'i go home.', 'i.', 'i.', 'see you later.', 'meet.', 'meet.', 'we meet.', 'like.', 'i like.', 'talk later.', 'later.', 'later.']
input_characters_translation=[' ', '.', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'k', 'l', 'm', 'n', 'o', 'p', 'r', 's', 't', 'u', 'v', 'w', 'y']
target_characters_translation=['\t', '\n', ' ', 'ं', 'आ', 'उ', 'क', 'ख', 'ग', 'घ', 'च', 'ज', 'झ', 'ट', 'ड', 'ण', 'त', 'द', 'न', 'प', 'फ', 'ब', 'भ', 'म', 'य', 'र', 'ल', 'ळ', 'व', 'श', 'स', 'ह', 'ा', 'ि', 'ी', 'ु', 'ू', 'े', 'ो', '्']

num_en_chars_translation = 24
num_dec_chars_translation = 40

max_input_length_translation = 22
max_target_length_translation = 36

cv_translation=CountVectorizer(binary=True,tokenizer=lambda txt: txt.split(),stop_words=None,analyzer='char') 

model_translation = models.load_model("model_translation")

enc_outputs_translation, state_h_enc_translation, state_c_enc_translation = model_translation.layers[2].output 

en_model_translation = Model(model_translation.input[0], [state_h_enc_translation, state_c_enc_translation])

dec_state_input_h_translation = Input(shape=(256,),name="input_3")
dec_state_input_c_translation = Input(shape=(256,),name="input_4")
dec_states_inputs_translation = [dec_state_input_h_translation, dec_state_input_c_translation]

dec_lstm_translation = model_translation.layers[3]
dec_outputs_translation, state_h_dec_translation, state_c_dec_translation = dec_lstm_translation(
    model_translation.input[1], initial_state=dec_states_inputs_translation
)
dec_states_translation = [state_h_dec_translation, state_c_dec_translation]
dec_dense_translation = model_translation.layers[4]
dec_outputs_translation = dec_dense_translation(dec_outputs_translation)

dec_model_translation = Model(
    [model_translation.input[1]] + dec_states_inputs_translation, [dec_outputs_translation] + dec_states_translation
)

def decode_sequence_translation(input_seq):
     
        reverse_target_char_index_translation = dict(enumerate(target_characters_translation))
        
        states_value_translation = en_model_translation.predict(input_seq)

      
        co_translation=cv_translation.fit(target_characters_translation) 
        target_seq_translation=np.array([co_translation.transform(list("\t")).toarray().tolist()],dtype="float32")

        stop_condition = False

        decoded_sentence_translation = ""

        while not stop_condition:
      
            output_chars_translation, h_translation, c_translation = dec_model_translation.predict([target_seq_translation] + states_value_translation)

            char_index_translation = np.argmax(output_chars_translation[0, -1, :])
            text_char_translation = reverse_target_char_index_translation[char_index_translation]
            decoded_sentence_translation += text_char_translation
             
            if text_char_translation == "\n" or len(decoded_sentence_translation) > max_target_length_translation:
                stop_condition = True
      
            target_seq_translation = np.zeros((1, 1, num_dec_chars_translation))
            target_seq_translation[0, 0, char_index_translation] = 1.0
            states_value_translation = [h_translation, c_translation]
     
        return decoded_sentence_translation
def bagofcharacter_translation(input_t):
        cv_translation=CountVectorizer(binary=True,tokenizer=lambda txt:
        txt.split(),stop_words=None,analyzer='char') 
        en_in_data=[] ; pad_en=[1]+[0]*(len(input_characters_translation)-1)
    
        cv_inp_translation= cv_translation.fit(input_characters_translation)
        en_in_data.append(cv_inp_translation.transform(list(input_t)).toarray().tolist())
    
        if len(input_t)< max_input_length_translation:
          for _ in range(max_input_length_translation-len(input_t)):
            en_in_data[0].append(pad_en)
    
        return np.array(en_in_data,dtype="float32")

#transliteration

input_characters_transliteration=[' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u','v', 'w', 'x', 'y', 'z']
target_characters_transliteration=['\t', '\n', 'ँ', 'ं', 'ः', 'अ', 'आ', 'इ', 'ई', 'उ', 'ऊ', 'ए', 'ऐ', 'ऑ', 'ओ', 'औ', 'क', 'ख', 'ग', 'घ', 'च', 'छ', 'ज', 'झ', 'ट', 'ठ', 'ड', 'ढ', 'ण', 'त', 'थ', 'द', 'ध', 'न', 'प', 'फ', 'ब', 'भ', 'म', 'य', 'र', 'ल', 'ळ', 'व', 'श', 'ष', 'स', 'ह', '़', 'ा', 'ि', 'ी', 'ु', 'ू', 'ृ', 'े','ै', 'ॉ', 'ो', 'ौ', '्', 'क़', 'ख़', 'ग़', 'ज़', 'ड़', 'ढ़', 'फ़']
num_en_chars_transliteration = 27
num_dec_chars_transliteration = 68
max_input_length_transliteration = 21
max_target_length_transliteration = 20
cv_transliteration=CountVectorizer(binary=True,tokenizer=lambda txt: txt.split(),stop_words=None,analyzer='char') 
model_transliteration = models.load_model("s2s_transliteration")

enc_outputs_transliteration, state_h_enc_transliteration, state_c_enc_transliteration = model_transliteration.layers[2].output 

en_model_transliteration = Model(model_transliteration.input[0], [state_h_enc_transliteration, state_c_enc_transliteration])

dec_state_input_h_transliteration = Input(shape=(256,), name="input_6")
dec_state_input_c_transliteration = Input(shape=(256,), name="input_7")
dec_states_inputs_transliteration = [dec_state_input_h_transliteration, dec_state_input_c_transliteration]
dec_lstm_transliteration = model_transliteration.layers[3]
dec_outputs_transliteration, state_h_dec_transliteration, state_c_dec_transliteration = dec_lstm_transliteration(
    model_transliteration.input[1], initial_state=dec_states_inputs_transliteration
)
dec_states_transliteration = [state_h_dec_transliteration, state_c_dec_transliteration]
dec_dense_transliteration = model_transliteration.layers[4]
dec_outputs_transliteration = dec_dense_transliteration(dec_outputs_transliteration)
dec_model_transliteration = Model(
    [model_transliteration.input[1]] + dec_states_inputs_transliteration, [dec_outputs_transliteration] + dec_states_transliteration
)
def decode_sequence_transliteration(input_seq):
       
        reverse_target_char_index_transliteration = dict(enumerate(target_characters_transliteration))
       
        states_value_transliteration = en_model_transliteration.predict(input_seq)

        co=cv_transliteration.fit(target_characters_transliteration) 
        target_seq_transliteration=np.array([co.transform(list("\t")).toarray().tolist()],dtype="float32")

        stop_condition = False  
        decoded_sentence = ""
        while not stop_condition:            
            output_chars, h, c = dec_model_transliteration.predict([target_seq_transliteration] + states_value_transliteration)
            char_index = np.argmax(output_chars[0, -1, :])
            text_char = reverse_target_char_index_transliteration[char_index]
            decoded_sentence += text_char

            if text_char == "\n" or len(decoded_sentence) > max_target_length_transliteration:
                stop_condition = True
           
            target_seq_transliteration = np.zeros((1, 1, num_dec_chars_transliteration))
            target_seq_transliteration[0, 0, char_index] = 1.0
            states_value_transliteration = [h, c]
      
        return decoded_sentence
def bagofcharacter_transliteration(input_t):
        cv_transliteration=CountVectorizer(binary=True,tokenizer=lambda txt:
        txt.split(),stop_words=None,analyzer='char') 
        en_in_data=[] ; pad_en=[1]+[0]*(len(input_characters_transliteration)-1)
        print("hi3")
         
        cv_inp= cv_transliteration.fit(input_characters_transliteration)
        en_in_data.append(cv_inp.transform(list(input_t)).toarray().tolist())
    
        if len(input_t)< max_input_length_transliteration:
          for _ in range(max_input_length_transliteration-len(input_t)):
            en_in_data[0].append(pad_en)
    
        return np.array(en_in_data,dtype="float32")


def translate_to_Konkani(sent):  
    
    input_text = sent.split(',') 
    
    output_texts=""
    for x in input_text:
        term=x+"."
        k=term.split(' ')
        
        if term in input_texts_translation :
            
            en_in_data = bagofcharacter_translation( x.lower()+".")    
            x=decode_sequence_translation(en_in_data)
            output_texts+=" "+ x 
    
        else:
        
            
            en_in_data = bagofcharacter_transliteration( x.lower()+".")    
            x=decode_sequence_transliteration(en_in_data)
            output_texts+=" "+ x   
         
    return output_texts

iface = gr.Interface(fn=translate_to_Konkani, inputs="text", outputs="text")
iface.launch()