DemoRepo / LangTransGui.py

Initial

75487c0 over 2 years ago

No virus

11.7 kB

	import tkinter
	from tkinter import messagebox
	from tkinter import *
	import pickle
	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
	import speech_recognition as sr
	import pyttsx3

	BG_GRAY = "#ABB2B9"
	BG_COLOR = "#000"
	TEXT_COLOR = "#000"
	FONT = "Melvetica 14"
	FONT_BOLD = "Melvetica 13 bold"

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


	class LangTRans:
	def __init__(self):
	# initialize tkinter window and load the file
	self.window = Tk()
	self.demo_window()
	self.datafile()

	def datafile(self):
	# get all datas from datafile and load the model.
	datafile = pickle.load(open("training_data.pkl", "rb"))
	self.input_characters = datafile['input_characters']
	self.target_characters = datafile['target_characters']
	self.max_input_length = datafile['max_input_length']
	self.max_target_length = datafile['max_target_length']
	self.num_en_chars = datafile['num_en_chars']
	self.num_dec_chars = datafile['num_dec_chars']
	self.loadmodel()

	# runwindow
	def run(self):
	self.window.mainloop()

	def run2(self):
	self.window.mainloop()

	def demo_window(self):
	self.window.title("Language Translator")
	self.window.resizable(width=False, height=False)
	self.window.configure(width=800, height=300)

	# head_label.place(relwidth=1)
	# line = Label(self.window,width=450,bg=BG_COLOR)
	# line.place(relwidth=1,rely=0.07,relheight=0.012)
	self.myText = StringVar()
	head_label = Label(self.window, text="Translate to french Language!", font=FONT_BOLD, pady=10)
	head_label.grid(row=0, column=3, padx=20, pady=20, columnspan=5)
	head_label.grid_rowconfigure(1, weight=1)
	head_label.grid_columnconfigure(1, weight=1)

	Label(self.window, text="Input Text:").grid(row=1, padx=10, pady=10)
	self.e1 = Entry(self.window)
	self.e1.grid(row=2, column=1)
	send_button2 = Button(self.window, text="Voice", font=FONT_BOLD, width=2, bg="Red",
	command=lambda: self.voice_input(None))
	send_button2.grid(row=3, column=1, sticky=W + E + N + S, padx=20, pady=20)
	Label(self.window, text="Translated text in French:").grid(row=1, column=4,sticky="W")
	self.output_box = Label(self.window, width=20, text="", textvariable=self.myText)
	self.output_box.grid(row=2, column=5)
	self.e1 = Entry(self.window)
	self.e1.grid(row=1, column=1)
	send_button = Button(self.window, text="Translate", font=FONT_BOLD, width=2, bg="blue", command=lambda: self.on_enter(None))
	send_button.grid(row=3, column=3, sticky=W + E + N + S, padx=20, pady=20)

	send_button1 = Button(self.window, text="Voice Output", font=FONT_BOLD, bg="Red",
	command=lambda: self.on_enter_voice(None))
	send_button1.grid(row=3, column=4, sticky=W + E + N + S, padx=20, pady=20)

	def main_window(self):
	# add title to window and configure it
	self.window.title("Language Translator")
	self.window.resizable(width=False, height=False)
	self.window.configure(width=520, height=520, bg=BG_COLOR)

	head_label = Label(self.window, bg=BG_COLOR, fg=TEXT_COLOR, text="Translate to french Language!",
	font=FONT_BOLD, pady=10)
	head_label.place(relwidth=1)
	line = Label(self.window, width=450, bg=BG_COLOR)
	line.place(relwidth=1, rely=0.07, relheight=0.012)

	# create text widget where input and output will be displayed
	self.text_widget = Text(self.window, width=20, height=2, bg="#fff", fg="#000", font=FONT, padx=5, pady=5)
	self.text_widget.place(relheight=0.745, relwidth=1, rely=0.08)
	self.text_widget.configure(cursor="arrow", state=DISABLED)

	# create scrollbar
	scrollbar = Scrollbar(self.text_widget)
	scrollbar.place(relheight=1, relx=0.974)
	scrollbar.configure(command=self.text_widget.yview)

	# create bottom label where text widget will placed
	bottom_label = Label(self.window, bg=BG_GRAY, height=80)
	bottom_label.place(relwidth=1, rely=0.825)
	# this is for user to put english text
	self.msg_entry = Entry(bottom_label, bg="#2C3E50", fg=TEXT_COLOR, font=FONT)
	self.msg_entry.place(relwidth=0.65, relheight=0.06, rely=0.008, relx=0.008)
	self.msg_entry.focus()
	self.msg_entry.bind("<Return>", self.on_enter)
	# send button which will call on_enter function to send the text
	send_button2 = Button(bottom_label, text="Voice\n Input", font=FONT_BOLD, width=2, bg="Red",
	command=lambda: self.voice_input(None))
	send_button2.place(relx=0.66, rely=0.008, relheight=0.06, relwidth=0.1325)

	# send button which will call on_enter function to send the text
	send_button = Button(bottom_label, text="Only Text", font=FONT_BOLD, width=8, bg="Red",
	command=lambda: self.on_enter(None))
	send_button.place(relx=0.80, rely=0.008, relheight=0.03, relwidth=0.20)
	# send button which will call on_enter function to send the text
	send_button1 = Button(bottom_label, text="Voice", font=FONT_BOLD, width=2, bg="Red",
	command=lambda: self.on_enter_voice(None))
	send_button1.place(relx=0.80, rely=0.04, relheight=0.027, relwidth=0.20)

	def loadmodel(self):
	# Inference model
	# load the model
	model = models.load_model("s2s")
	# 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 # lstm_1
	# add input object and state from the layer.
	self.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_3")
	dec_state_input_c = Input(shape=(256,), name="input_4")
	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.
	self.dec_model = Model(
	[model.input[1]] + dec_states_inputs, [dec_outputs] + dec_states
	)

	def decode_sequence(self, input_seq):
	# create dict object to get character from the index.
	reverse_target_char_index = dict(enumerate(self.target_characters))
	# get the states from the user input sequence
	states_value = self.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(self.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 = self.dec_model.predict([target_seq] + states_value)

	# get the index and from dictionary get character from it.
	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 stop character.
	if text_char == "\n" or len(decoded_sentence) > self.max_target_length:
	stop_condition = True
	# update target sequence to the current character index.
	target_seq = np.zeros((1, 1, self.num_dec_chars))
	target_seq[0, 0, char_index] = 1.0
	states_value = [h, c]
	# return the decoded sentence
	return decoded_sentence

	def on_enter(self, event):
	# get user query and bot response
	msg = self.e1.get()
	# self.my_msg(msg, "English")
	self.deocded_output(msg)

	def on_enter_voice(self, event):
	# get user query and bot response
	msg = self.output_box["text"]
	# self.my_msg(msg, "English")
	self.deocded_output_voice(msg)

	def voice_input(self, event):
	r = sr.Recognizer()
	with sr.Microphone() as source:
	audio = r.listen(source,phrase_time_limit=5)

	try:
	msg = r.recognize_google(audio)
	# print(msg)
	self.e1.insert(0, msg)
	# self.msg_entry.insert(0,msg)

	except:
	print("Not working")
	# tkinter.messagebox.showerror(title="Error", message="Sorry could not recognize what you said.")

	def bagofcharacters(self, input_t):
	cv = CountVectorizer(binary=True, tokenizer=lambda txt: txt.split(), stop_words=None, analyzer='char')
	en_in_data = [];
	pad_en = [1] + [0] * (len(self.input_characters) - 1)

	cv_inp = cv.fit(self.input_characters)
	en_in_data.append(cv_inp.transform(list(input_t)).toarray().tolist())

	if len(input_t) < self.max_input_length:
	for _ in range(self.max_input_length - len(input_t)):
	en_in_data[0].append(pad_en)

	return np.array(en_in_data, dtype="float32")

	def deocded_output(self, msg):
	# self.text_widget.configure(state=NORMAL)
	# en_in_data = self.bagofcharacters(msg.lower() + ".")
	# self.text_widget.insert(END, str(sender) + " : " + self.decode_sequence(en_in_data)
	# + "\n\n")
	# self.text_widget.configure(state=DISABLED)
	# self.text_widget.see(END)
	en_in_data = self.bagofcharacters(msg.lower())
	# print(self.decode_sequence(en_in_data))
	self.myText.set(self.decode_sequence(en_in_data))

	def deocded_output_voice(self, msg):
	# self.text_widget.configure(state=NORMAL)
	# en_in_data = self.bagofcharacters(msg.lower() + ".")
	# self.text_widget.insert(END, str(sender) + " : " + self.decode_sequence(en_in_data)
	# + "\n\n")
	engine = pyttsx3.init()
	engine.setProperty("rate", 135)
	engine.say(msg)
	engine.runAndWait()
	# self.text_widget.configure(state=DISABLED)
	# self.text_widget.see(END)

	def my_msg(self, msg, sender):
	if not msg:
	return
	self.msg_entry.delete(0, END)
	self.text_widget.configure(state=NORMAL)
	self.text_widget.insert(END, str(sender) + " : " + str(msg) + "\n")
	self.text_widget.configure(state=DISABLED)


	# run the file
	if __name__ == "__main__":
	LT = LangTRans()
	LT.run2()