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 #translation 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=[' ', '.', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'k', 'l', 'm', 'n', 'o', 'p', 'r', 's', 't', 'u', 'v', 'w', 'y'] target_characters=['\t', '\n', ' ', '.', 'ं', 'आ', 'उ', 'क', 'ख', 'ग', 'घ', 'च', 'ज', 'झ', 'ट', 'ड', 'ण', 'त', 'द', 'न', 'प', 'फ', 'ब', 'भ', 'म', 'य', 'र', 'ल', 'ळ', 'व', 'श', 'स', 'ह', 'ा', 'ि', 'ी', 'ु', 'ू', 'े', 'ो', '्'] num_en_chars = 24 num_dec_chars_translation = 40 max_input_length = 22 max_target_length = 36 cv=CountVectorizer(binary=True,tokenizer=lambda txt: txt.split(),stop_words=None,analyzer='char') #Inference model #load the model model = models.load_model("model_translation") #construct encoder model from the output of second layer #discard the encoder output and store only states. enc_outputs, state_h_enc, state_c_enc = model.layers[2].output #add input object and state from the layer. en_model = Model(model.input[0], [state_h_enc, state_c_enc]) #create Input object for hidden and cell state for decoder #shape of layer with hidden or latent dimension dec_state_input_h = Input(shape=(256,),name="input_4") dec_state_input_c = Input(shape=(256,),name="input_5") dec_states_inputs = [dec_state_input_h, dec_state_input_c] #add input from the encoder output and initialize with states. dec_lstm = model.layers[3] dec_outputs, state_h_dec, state_c_dec = dec_lstm( model.input[1], initial_state=dec_states_inputs ) dec_states = [state_h_dec, state_c_dec] dec_dense = model.layers[4] dec_outputs = dec_dense(dec_outputs) #create Model with the input of decoder state input and encoder input #and decoder output with the decoder states. dec_model = Model( [model.input[1]] + dec_states_inputs, [dec_outputs] + dec_states ) def decode_sequence_translation(input_seq): #create a dictionary with a key as index and value as characters. reverse_target_char_index = dict(enumerate(target_characters)) #get the states from the user input sequence states_value = en_model.predict(input_seq) #fit target characters and #initialize every first character to be 1 which is '\t'. #Generate empty target sequence of length 1. co=cv.fit(target_characters) target_seq=np.array([co.transform(list("\t")).toarray().tolist()],dtype="float32") #if the iteration reaches the end of text than it will be stop the it stop_condition = False #append every predicted character in decoded sentence decoded_sentence = "" while not stop_condition: #get predicted output and discard hidden and cell state. output_chars, h, c = dec_model.predict([target_seq] + states_value) #get the index and from the dictionary get the character. char_index = np.argmax(output_chars[0, -1, :]) text_char = reverse_target_char_index[char_index] decoded_sentence += text_char # Exit condition: either hit max length # or find a stop character. if text_char == "\n" or len(decoded_sentence) > max_target_length: stop_condition = True #update target sequence to the current character index. target_seq = np.zeros((1, 1, num_dec_chars)) target_seq[0, 0, char_index] = 1.0 states_value = [h, c] #return the decoded sentence return decoded_sentence def bagofcharacter_translation(input_t): cv=CountVectorizer(binary=True,tokenizer=lambda txt: txt.split(),stop_words=None,analyzer='char') en_in_data=[] ; pad_en=[1]+[0]*(len(input_characters)-1) cv_inp= cv.fit(input_characters) en_in_data.append(cv_inp.transform(list(input_t)).toarray().tolist()) if len(input_t)< max_input_length: for _ in range(max_input_length-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()