CHAPTER 1

INTRODUCTION
1.1 INTRODUCTION
The Real-time Speech-to-Speech Translator with Machine Learning using Python
project aims to develop a system that can instantly translate spoken language from one
language to another. Leveraging the power of machine learning and the Python
programming language, this project seeks to bridge communication gaps and facilitate
seamless interaction between individuals speaking different languages.

In our rapidly globalizing world, effective communication across language barriers

is essential for collaboration, commerce, and cultural exchange. With advancements in
machine learning and natural language processing, real-time speech-to-speech
translation has become a reality. This project aims to demonstrate the power of Python
and machine learning in developing a real-time speech-to-speech translator.

1.2 UNDERSTANDING SPEECH-TO-SPEECH TRANSLATION

Speech-to-speech translation involves the conversion of spoken words from one

language to another in real-time. This process requires a deep understanding of both the
source and target languages, as well as the ability to accurately capture nuances in
speech, such as tone and context. Machine learning algorithms play a crucial role in
enabling this functionality by analyzing and interpreting spoken language patterns

1.3 LEVERAGING MACHINE LEARNING FOR TRANSLATION

Machine learning techniques, particularly deep learning models like recurrent

neural networks (RNNs) and transformer models, have revolutionized the field of
natural language processing (NLP). These models can learn complex linguistic patterns
from large datasets and generate accurate translations. By training these models on vast
corpora of multilingual speech data, we can develop robust speech-to-speech
translation systems

1.4 THE ROLE OF PYTHON IN SPEECH TRANSLATION

Python, with its extensive libraries and frameworks for machine learning and NLP,
serves as an ideal platform for developing speech translation systems. Libraries such as

1
TensorFlow, PyTorch, and Scikit-learn provide powerful tools for building and training
machine learning models. Additionally, libraries like SpeechRecognition and PyAudio
enable the capture and processing of audio data in real-time, facilitating seamless
speech translation.

The development of a real-time speech-to-speech translator using machine learning

and Python showcases the potential of technology to break down language barriers and
foster global connectivity. By leveraging advances in machine learning algorithms and
Python's versatility, we can create powerful tools that enable effective communication
across linguistic boundaries. This project represents a significant step towards realizing
the vision of a world where language is no longer a barrier to understanding and
collaboration.

Real-time speech-to-speech translation has become increasingly vital in today's

globalized world. In this project, we present a novel approach utilizing machine
learning techniques implemented in Python for real-time speech-to-speech translation.
Leveraging the power of deep learning and natural language processing, our system
aims to bridge the communication gap between individuals speaking different
languages.
Our system comprises several key components, including speech recognition,
machine translation, and speech synthesis. We employ state-of-the-art deep learning
models such as Convolutional Neural Networks (CNNs), Recurrent Neural Networks
(RNNs), and Transformer architectures to achieve accurate and efficient speech
recognition and translation. Furthermore, we utilize pre-trained language models and
transfer learning techniques to enhance the translation quality and adapt to diverse
linguistic contexts.
To facilitate real-time performance, we optimize our system for speed and
efficiency, leveraging techniques such as parallelization, model compression, and
hardware acceleration using libraries like TensorFlow and PyTorch. Additionally, we
design a user-friendly interface for seamless interaction, enabling users to input speech
in their native language and receive translated speech in real-time.

We evaluate the performance of our system through comprehensive

experiments on various datasets and real-world scenarios. Our results demonstrate the

2
effectiveness and robustness of the proposed approach in achieving accurate and timely
speech translation across different languages. Finally, we discuss potential applications,
limitations, and future directions for improving real-time speech-to-speech translation
systems using machine learning.

3
 CHAPTER 2

LITERATURE SURVEY

2.1 RELATED WORKS

1. Google Translate: Google Translate is one of the most widely used

translation services that offers speech-to-speech translation capabilities. It employs
machine learning algorithms to translate spoken words in real-time across multiple
languages. Google's system utilizes a combination of neural machine translation and
speech recognition technologies to achieve accurate translations.
2. Microsoft Translator: Microsoft Translator is another popular platform that
provides speech translation services. It utilizes deep learning models to recognize and
translate spoken words with high accuracy. Microsoft's system also supports real-time
translation across various languages and offers integration with third-party applications
through APIs.
3. IBM Watson Language Translator: IBM Watson Language Translator is a
cloud-based service that offers speech-to-speech translation capabilities. It utilizes deep
learning techniques, including recurrent neural networks (RNNs) and transformers, to
perform language translation tasks. IBM's system is highly customizable and allows
developers to train their models for specific domains or languages.
4. OpenNMT: OpenNMT is an open-source neural machine translation
framework that can be used to build custom translation models. It supports speech-to-
speech translation by integrating with speech recognition libraries such as Kaldi.
OpenNMT provides flexibility in model architecture and training data, making it
suitable for research and development purposes.
5. Mozilla DeepSpeech: Mozilla DeepSpeech is an open-source speech
recognition engine that utilizes deep learning techniques to transcribe spoken audio
into text. While not directly a translation tool, it can be combined with machine
translation models to achieve speech-to-speech translation. DeepSpeech offers pre-
trained models and allows fine-tuning on custom datasets for improved accuracy.

2.2 AUTOMATIC SPEECH RECOGNITION (ASR) TECHNIQUES

Automatic Speech Recognition (ASR) serves as the foundation for speech-to-

speech translation systems. Various techniques have been employed for ASR, ranging

4
from traditional Hidden Markov Models (HMMs) to modern deep learning-based
approaches such as Convolutional Neural Networks (CNNs) and Recurrent Neural
Networks (RNNs). Researchers have extensively explored different architectures and
training methodologies to improve the accuracy and robustness of ASR systems

Machine translation models play a crucial role in translating the recognized

speech into the target language. Traditional statistical approaches have been largely
replaced by neural machine translation (NMT) models, which have shown superior
performance in capturing complex linguistic patterns. Transformer-based architectures,
such as the Transformer model and its variants like BERT and GPT, have been
particularly successful in achieving state-of-the-art translation accuracy.

Real-time speech-to-speech translation using machine learning and Python has

witnessed significant advancements in recent years, driven by breakthroughs in ASR,
machine translation, and end-to-end modeling. While challenges such as latency
reduction and model optimization remain, ongoing research efforts continue to push the
boundaries of performance and scalability in speech translation systems. By leveraging
the latest techniques and open-source tools, developers can build robust and efficient
solutions to enable seamless communication across language barriers in diverse real-
world scenarios.

Automatic Speech Recognition (ASR) techniques involve a variety of

methodologies and technologies aimed at converting spoken language into text. Here
are some common techniques used in ASR:

1. Acoustic Modeling: This technique involves analyzing the audio signal to identify
phonetic units, such as phones or phonemes. Acoustic models typically use Hidden
Markov Models (HMMs), Gaussian Mixture Models (GMMs), or deep neural networks
(DNNs) to map acoustic features to these phonetic units.

2. Language Modeling: Language modeling helps the ASR system predict the
likelihood of a sequence of words occurring together. Techniques such as n-gram
models, recurrent neural networks (RNNs), or transformers are commonly used for
language modeling.

5
3. Feature Extraction: ASR systems often use techniques to extract features from the
audio signal that are relevant for speech recognition. Common features include Mel-
frequency cepstral coefficients (MFCCs), filter banks, or deep learning-based features
extracted by convolutional neural networks (CNNs).

4. Decoding Algorithms: Once acoustic and language models are trained, decoding
algorithms are used to find the most likely sequence of words given the input audio.
Popular decoding algorithms include Viterbi decoding, beam search, or connectionist
temporal classification (CTC) for end-to-end ASR systems.

5. Training Data: ASR systems require large amounts of annotated training data to learn
acoustic and language models. This data is used to train models to accurately recognize
speech across various speakers, accents, and environmental conditions.

6. Adaptation Techniques: ASR systems often incorporate adaptation techniques to

improve performance for specific speakers or environments. Techniques such as
speaker adaptation, domain adaptation, or unsupervised adaptation help customize the
ASR system to individual users or specific application domains.

7. End-to-End Models: In recent years, there has been a trend towards end-to-end ASR
systems, where a single neural network directly maps the input audio to text without
explicitly modeling intermediate linguistic units. These models often use architectures
such as recurrent neural networks (RNNs), transformers, or hybrid approaches
combining convolutional and recurrent layers.

8. Post-Processing: After the initial transcription, ASR systems may apply post-
processing techniques to improve the accuracy of the output text. Techniques such as
language model rescoring, confidence estimation, or error correction algorithms can
help refine the transcription.

6
 CHAPTER 3

SYSTEM ANALYSIS

3.1 AIM

The primary aim of this project is to create a robust and efficient speech-to-
speech translation system that can accurately interpret and translate spoken language in
real-time.

3.2 OBJECTIVES:
• Develop a speech recognition module capable of accurately transcribing
spoken language.
• Implement a machine learning algorithm to translate the transcribed text into
the desired language.
• Integrate the translation algorithm with a speech synthesis module to produce
understandable speech output.
• Ensure real-time functionality to enable instant translation during live
conversations.
3.3 SCOPE OF THE PROJECT:
The scope of this project encompasses the development of a comprehensive
system that can handle various languages and dialects, providing users with a versatile
tool for cross-language communication. Additionally, the system will be designed to
operate in real-time, making it suitable for both personal and professional use cases.
3.4 EXISTING SYSTEM:
The current landscape of speech translation systems often faces limitations in
accuracy, speed, and language support. Existing solutions may rely on pre-defined
translation models or lack the ability to adapt to diverse linguistic nuances.
3.4.1 Disadvantages of Existing System:
• Limited language support.
• Lack of real-time translation capabilities.
• Inaccurate translations, especially for complex or context-dependent speech.
• Dependency on internet connectivity for cloud-based systems.

7
3.5 PROPOSED SYSTEM:
The proposed system addresses the shortcomings of existing solutions by
leveraging machine learning techniques for improved accuracy and adaptability. By
utilizing Python as the programming language, the system aims to provide a flexible
and customizable platform for speech translation.
Real-time speech-to-speech translation offers numerous advantages, including
enabling seamless communication between speakers of different languages, facilitating
international collaboration, and enhancing accessibility for individuals with hearing
impairments. Moreover, such systems find applications in diverse fields such as travel,
hospitality, international business, and healthcare, where effective communication is
paramount.
3.5.1Advantages of Proposed System:
• Enhanced accuracy through machine learning algorithms.
• Real-time translation capabilities for seamless communication.
• Support for multiple languages and dialects.
• Offline functionality for improved accessibility and privacy.

8
 CHAPTER 4

SYSTEM DESIGN

4.1 SYSTEM ARCHITECTURE

The system architecture consists of several key components working together
to facilitate real-time translation:

4.1.1. Speech Input

The system receives speech input from users in their native languages. This
input is captured through microphones or other audio input devices and serves as the
raw data for the translation process.

4.1.2. Preprocessing
The incoming speech data undergoes preprocessing to enhance its quality and
prepare it for the subsequent stages of the translation pipeline. Preprocessing may
include noise reduction, normalization, and feature extraction to extract relevant
information from the audio signal.

4.1.3. Speech Recognition

Using machine learning models such as deep learning-based acoustic models or
Hidden Markov Models (HMMs), the system performs speech recognition to convert
the audio input into text. This step involves identifying spoken words and transcribing
them into the corresponding textual representation.

4.1.4. Machine Translation

Once the speech input has been transcribed into text, the system applies machine
translation techniques to convert the text from the source language to the target
language. This involves employing neural machine translation models or statistical
methods to generate accurate translations.

9
4.1.5. Text-to-Speech Synthesis
After the translation step, the system converts the translated text back into speech in the
target language. Text-to-speech synthesis techniques are utilized to generate natural-
sounding speech output that closely resembles human speech.

4.1.6. Speech Output

The synthesized speech is delivered as output to the users, allowing them to hear
the translated content in real-time. This output can be played through speakers or other
audio output devices, enabling seamless communication across languages.

4.2. MACHINE LEARNING MODELS

Key machine learning models utilized in the system include:

4.2.1. Deep Learning Models

Deep learning architectures such as recurrent neural networks (RNNs),
convolutional neural networks (CNNs), and transformer models are employed for tasks
such as speech recognition and machine translation. These models are trained on large
datasets to learn complex patterns in speech and text data.

4.2.2. Statistical Models

Statistical machine translation models, including phrase-based models and
language models, are utilized for generating translations based on statistical patterns
observed in bilingual corpora.

4.3 IMPLEMENTATION IN PYTHON

Python serves as the primary programming language for implementing the real-
time speech-to-speech translator. The following libraries and frameworks are
commonly used:

4.3.1. Speech Recognition Libraries

Libraries such as SpeechRecognition provide easy-to-use interfaces for
performing speech recognition tasks, allowing developers to transcribe speech input
into text efficiently.

10
4.3.2. Machine Translation Libraries
Frameworks like OpenNMT and TensorFlow's Seq2Seq models enable
developers to build custom machine translation systems using neural network
architectures.

4.3.3. Text-to-Speech Libraries

Python libraries such as pyttsx3 and gTTS facilitate text-to-speech synthesis,
allowing developers to convert translated text into natural-sounding speech output.

4.3.4. Audio Processing Libraries

Libraries like librosa and Pyaudio offer functionalities for audio processing and
manipulation, supporting tasks such as noise reduction and audio format conversion.

11
 CHAPTER 5

SYSTEM SPECIFICATION
5.1 FUNCTIONAL REQUIREMENTS

Speech Recognition:

● The system should be able to capture audio input from the microphone.
● It should process the audio data to recognize spoken words accurately.
Translation:

● The system should translate the recognized text from one language to another
in real-time.
● It should support translation between multiple languages.
● The translation should preserve the tone and emotion of the speaker.
User Interface:

● The system should have a user-friendly graphical interface for language

selection and interaction.
● It should display translated text in real-time during conversations.
Audio Handling:

● The system should support audio output to play translated speech.

● It should manage audio input/output devices effectively.
5.2 NON-FUNCTIONAL REQUIREMENTS

Performance:

● The system should provide low-latency translation to maintain conversational

flow.
● It should be able to handle simultaneous translation for multiple users in a
conversation.
Accuracy:

● The speech recognition component should accurately transcribe spoken words.

● The translation component should provide accurate translations between
languages.

12
Compatibility:

● The software should be compatible with popular desktop operating systems,

including Windows, macOS, and Linux.
Usability:

● The user interface should be intuitive and easy to navigate.

● The system should require minimal user configuration to start translating.
Reliability:

● The software should be stable and reliable, with minimal crashes or errors
during operation.
● It should handle unexpected inputs or conditions gracefully.

5.3 HARDWARE REQUIREMENTS

● Processor: Multi-core processor (Intel Core i5 or equivalent recommended)

● RAM: 8GB or higher
● Storage: 100MB available space for the application and additional space for
language models
● Audio Input/Output: Compatible microphone and speakers/headphones
● Internet Connection: Required for initial setup and language model downloads
5.4 SOFTWARE REQUIREMENTS

Operating System:

● Windows 10 or later
● macOS 10.12 or later
● Linux distribution with ALSA support (Ubuntu 18.04 LTS or later
recommended)
● Python: Version <=3.11
Virtual Environment Tool: Python's venv module (for creating virtual environments)

Dependencies:

● gTTS
● Pyaudio
● playsound==1.2.2
13
 ● Deep-translator
● SpeechRecognition
● Google-transliteration-api
● cx-Freeze
Executable Builder:

● cx_Freeze (for creating executable files)

Software Environment:

● Python Environment: Virtual environment recommended for dependency

management and isolation
● Development Environment: Any text editor or IDE compatible with Python
development
Build Environment:

● Windows: Python environment with cx_Freeze installed for building MSI

installer
● Linux: Python environment with cx_Freeze installed for building RPM
package
● macOS: Python environment with cx_Freeze installed for building macOS
application package

14
 CHAPTER 6

SYSTEM IMPLEMENTATION
6.1 PROGRAM FLOW

Initialization:

● Create and activate a virtual environment.

● Install dependencies using pip.
Execution:

● Run main.py to start the Real-Time Speech Translator application.

● Select the desired languages for translation.
● Speak into the microphone for real-time translation.
Build Installer:

● Customize build settings by modifying the setup.py file.

● Build installer for Windows using python setup.py bdist_msi.
● Build installer for Linux using python setup.py bdist_rpm.
● Build installer for macOS using python setup.py bdist_mac
Additional Notes:

● Internet connection is required for initial setup and downloading language

models.
● Ensure microphone and speakers/headphones are properly configured and
compatible with the system.
● Regularly update Python and dependencies for security and performance
enhancements.
● Test the application on different platforms to ensure compatibility and optimal
performance.
● Provide user-friendly error handling and feedback for smooth user experience.
● Consider localization and internationalization for broader usability.
● Document the installation process, usage instructions, and troubleshooting tips
for users.
● Continuously monitor and update the application to incorporate new features
and improvements.

15
6.2 SYSTEM IMPLEMENTATION

Implementing the Real-Time Speech Translator system involves several steps,

including setting up the development environment, coding the application logic,
integrating necessary libraries, building the user interface, and testing the functionality.
Here's a basic outline of the implementation process:

1. Development Environment Setup:

● Install Python (version <= 3.11) on your system.

● Set up a virtual environment using venv:

Activate the virtual environment:

● Windows: env\Scripts\activate
● Linux/MacOS: source env/bin/activate
Install necessary dependencies:

Application Logic:
Create Python scripts for the main application logic:

16
 ● Define functions for speech recognition using SpeechRecognition library.
● Implement translation functionality using deep-translator or Google Translate
API.
● Handle audio input/output using pyaudio and playsound libraries.
● Ensure proper error handling and exception catching.

User Interface:
● Design and implement the user interface for language selection and
interaction.
● You can use libraries like Tkinter for desktop GUI or Flask/Django for web-
based interfaces.
● Integrate language selection options and buttons for starting/stopping
translation.

Build Executable:
Use cx_Freeze to build executable files for different platforms:
● Customize build settings in setup.py as needed.

Build installer for Windows:

Build installer for Linux:

Build installer for macOS:

17
6.3 SYSTEM MODULES

To implement the Real-Time Speech Translator system effectively, you can

organize your code into several modules, each responsible for specific functionalities.
Here's a suggestion for the modular structure of your system:

1. Speech_recognition.py:

● Module Purpose: Handle speech recognition functionality.

Functions:

● start_recognition(): Start listening for audio input from the microphone.

● stop_recognition(): Stop listening for audio input.
● process_audio(audio_data): Process the audio data for speech recognition.
● get_detected_text(): Get the recognized text from the audio.
2. translator.py:

● Module Purpose: Implement translation functionality.

Functions:

● translate_text(text, source_language, target_language): Translate text from

one language to another.
● detect_language(text): Detect the language of the input text.
3. Audio_handling.py:

● Module Purpose: Manage audio input/output.

Functions:

● play_audio(audio_data): Play audio output.

● record_audio(): Record audio input from the microphone.
4. gui.py:

● Module Purpose: Create and manage the graphical user interface.

Functions:

● create_main_window(): Create the main application window.

● update_translation_output(text): Update the GUI with translated text.
● handle_language_selection(): Handle user language selection inputs.
18
5. main.py:

● Module Purpose: Entry point of the application.

Functions:

● main(): Main function to initialize and run the application.

● initialize_app(): Initialize the application components (GUI, speech
recognition, etc.).

6. setup.py:

Module Purpose: Configuration for building executable files.

Functions:

● build_windows_installer(): Build installer for Windows platform.

● build_linux_installer(): Build installer for Linux platform.
● build_mac_installer(): Build installer for macOS platform.
7. utils.py:

● Module Purpose: Define utility functions used across the system.

Functions:

● validate_language_input(language): Validate user language inputs.

● handle_error(error_message): Handle and log errors.
8. config.py:

● Module Purpose: Store configuration parameters/constants.

Variables:

● SUPPORTED_LANGUAGES: List of supported languages.

● DEFAULT_SOURCE_LANGUAGE: Default source language for
translation.
● DEFAULT_TARGET_LANGUAGE: Default target language for translation.
9. Requirements.txt:

● Module Purpose: List of dependencies required for the project.

19
10. README.md:

● Module Purpose: Documentation for the project, including installation

instructions, usage guidelines, and project overview.

20
 CHAPTER 7

RESULTS AND DISCUSSION

Real-time speech translation is a groundbreaking application leveraging deep neural
networks to facilitate seamless cross-lingual communication. This section delves into
the hardware and software requirements, as well as the software environment, essential
for the successful deployment and operation of the Real-Time Voice Translator.

Hardware Requirements:

The hardware requirements for the Real-Time Voice Translator are relatively
modest, ensuring accessibility across a wide range of devices. The application runs
smoothly on standard desktop or laptop computers with the following specifications:

Processor: Intel Core i3 or equivalent

RAM: 4GB or higher

Storage: At least 100MB of free disk space

Sound Input/Output: Functional microphone and speakers or headphones

Software Requirements:

The Real-Time Voice Translator is designed to be versatile, supporting multiple

operating systems to accommodate diverse user preferences. The software requirements
include:

Operating System: Windows, Linux, or MacOS

Python: Version <=3.11

Dependencies: gTTS, pyaudio, playsound==1.2.2, deep-translator, SpeechRecognition,

google-transliteration-api, cx-Freeze

Software Environment:

The Real-Time Voice Translator operates within a Python environment,

utilizing various libraries and frameworks to enable real-time voice translation. The
software environment is optimized for efficiency and ease of use, ensuring a seamless
user experience. Key components of the software environment include:

21
Python: The programming language used for developing the application, providing
flexibility and scalability.

gTTS (Google Text-to-Speech): Utilized for converting translated text into speech
output, enhancing the user experience by enabling natural vocalization.

PyAudio: Facilitates audio input and output functionalities, enabling the application to
capture and playback speech in real time.

SpeechRecognition: Employs speech recognition technology to transcribe spoken

words into text, forming the basis for language translation.

Deep-translator: Harnesses deep learning algorithms to perform language translation

tasks with high accuracy and efficiency.

cx-Freeze: Enables the creation of executable files for distribution across different
operating systems, enhancing accessibility and usability.

DISCUSSION

The Real-Time Voice Translator represents a significant advancement in the

field of machine learning, offering a practical solution for overcoming language barriers
in real-time communication scenarios. By leveraging deep neural networks and
sophisticated speech recognition technology, the application is capable of providing
instantaneous translations while preserving the tone and emotion of the speaker.

One of the key strengths of the Real-Time Voice Translator is its versatility, as
it supports multiple operating systems, making it accessible to a wide range of users.
Additionally, the application's ease of use enhances its appeal, allowing users to initiate
translations effortlessly by selecting the desired languages and speaking directly into
the microphone.

Moreover, the Real-Time Voice Translator demonstrates the power of open-

source development, as it relies on a range of Python libraries and frameworks to deliver
its functionality. By leveraging existing tools and technologies, the application benefits
from continuous improvement and refinement within the developer community.

22
 Overall, the Real-Time Voice Translator represents a significant milestone in
the quest for seamless cross-lingual communication, offering a user-friendly and
efficient solution for overcoming language barriers in real-time conversations. As
advancements in machine learning and natural language processing continue to evolve,
the potential for further enhancements and refinements in real-time speech translation
technology remains promising.

23
 CHAPTER 8

CONCLUSION AND FUTURE ENHANCEMENT

8.1 CONCLUSION

The Real-Time Voice Translator represents a significant advancement in the

realm of cross-lingual communication. By leveraging deep neural networks and
machine learning techniques, it offers users the ability to seamlessly translate speech in
real time while preserving the nuances of tone and emotion. Its ease of use and support
for multiple operating systems make it accessible to a wide range of users.

8.2 FUTURE ENHANCEMENTS

Improved Accuracy: Continuously refining the underlying machine learning

models can enhance translation accuracy, especially for complex sentences and less
common languages.

Expanded Language Support: Adding support for additional languages will broaden
the application's utility and make it more inclusive for users across the globe.

Integration of Advanced Features: Incorporating features such as automatic language

detection, text-to-speech synthesis, and personalized language models can enhance the
overall user experience.

Enhanced User Interface: Improving the user interface to be more intuitive and
customizable can further streamline the translation process and cater to diverse user
preferences.

Optimization for Resource Efficiency: Optimizing the application's resource usage,

such as memory and processing power, will ensure smooth performance even on low-
spec hardware devices.

Integration with Online Services: Integrating with online translation services can
provide access to up-to-date language models and ensure seamless operation across
different network environments.

24
Feedback Mechanism: Implementing a feedback mechanism where users can report
translation errors or provide suggestions for improvement can help in continuous
refinement of the application.

Security and Privacy Features: Implementing robust security measures to protect user
data and ensuring compliance with privacy regulations will build trust and confidence
among users.

25
APPENDIX A

26
 APPENDIX B
Source Code
import os
import threading
import tkinter as tk
from gtts import gTTS
from tkinter import ttk
import speech_recognition as sr
from playsound import playsound
from deep_translator import GoogleTranslator
from google.transliteration import transliterate_text

# Create an instance of Tkinter frame or window

win= tk.Tk()

# Set the geometry of tkinter frame

win.geometry("700x450")
win.title("Real-Time Voice🎙️ Translator🔊")
icon = tk.PhotoImage(file="icon.png")
win.iconphoto(False, icon)

# Create labels and text boxes for the recognized and translated
text
input_label = tk.Label(win, text="Recognized Text ⮯")
input_label.pack()
input_text = tk.Text(win, height=5, width=50)
input_text.pack()

output_label = tk.Label(win, text="Translated Text ⮯")

output_label.pack()
output_text = tk.Text(win, height=5, width=50)
output_text.pack()

blank_space = tk.Label(win, text="")

blank_space.pack()

# Create a dictionary of language names and codes

language_codes = {
"English": "en",
"Hindi": "hi",
"Bengali": "bn",
"Spanish": "es",
"Chinese (Simplified)": "zh-CN",
"Russian": "ru",
"Japanese": "ja",
"Korean": "ko",
"German": "de",
"French": "fr",
"Tamil": "ta",
"Telugu": "te",
"Kannada": "kn",
"Gujarati": "gu",

27
 "Punjabi": "pa"
}

language_names = list(language_codes.keys())

# Create dropdown menus for the input and output languages

input_lang_label = tk.Label(win, text="Select Input Language:")

input_lang_label.pack()

input_lang = ttk.Combobox(win, values=language_names)

def update_input_lang_code(event):
selected_language_name = event.widget.get()
selected_language_code =
language_codes[selected_language_name]
# Update the selected language code
input_lang.set(selected_language_code)
input_lang.bind("<<ComboboxSelected>>", lambda e:
update_input_lang_code(e))
if input_lang.get() == "": input_lang.set("auto")
input_lang.pack()

down_arrow = tk.Label(win, text="▼")

down_arrow.pack()

output_lang_label = tk.Label(win, text="Select Output Language:")

output_lang_label.pack()

output_lang = ttk.Combobox(win, values=language_names)

def update_output_lang_code(event):
selected_language_name = event.widget.get()
selected_language_code =
language_codes[selected_language_name]
# Update the selected language code
output_lang.set(selected_language_code)
output_lang.bind("<<ComboboxSelected>>", lambda e:
update_output_lang_code(e))
if output_lang.get() == "": output_lang.set("en")
output_lang.pack()

blank_space = tk.Label(win, text="")

blank_space.pack()

keep_running = False

def update_translation():
global keep_running

if keep_running:
r = sr.Recognizer()

with sr.Microphone() as source:

print("Speak Now!\n")
audio = r.listen(source)

28
 try:
speech_text = r.recognize_google(audio)
# print(speech_text)
speech_text_transliteration =
transliterate_text(speech_text, lang_code=input_lang.get()) if
input_lang.get() not in ('auto', 'en') else speech_text
input_text.insert(tk.END,
f"{speech_text_transliteration}\n")
if speech_text.lower() in {'exit', 'stop'}:
keep_running = False
return

translated_text =
GoogleTranslator(source=input_lang.get(),
target=output_lang.get()).translate(text=speech_text_transliterat
ion)
# print(translated_text)

voice = gTTS(translated_text,
lang=output_lang.get())
voice.save('voice.mp3')
playsound('voice.mp3')
os.remove('voice.mp3')

output_text.insert(tk.END, translated_text +
"\n")

except sr.UnknownValueError:
output_text.insert(tk.END, "Could not
understand!\n")
except sr.RequestError:
output_text.insert(tk.END, "Could not request
from Google!\n")

win.after(100, update_translation)

def run_translator():
global keep_running

if not keep_running:
keep_running = True
update_translation_thread =
threading.Thread(target=update_translation) # using multi
threading for efficient cpu usage
update_translation_thread.start()

def kill_execution():
global keep_running
keep_running = False

def open_about_page(): # about page

about_window = tk.Toplevel()
about_window.title("About")
about_window.iconphoto(False, icon)

# Create a link to the GitHub repository

29
 github_link = ttk.Label(about_window, text="Final Cse",
underline=True, foreground="blue", cursor="hand2")
github_link.bind("<Button-1>", lambda e: open_webpage(""))
github_link.pack()

# Create a text widget to display the about text

about_text = tk.Text(about_window, height=10, width=50)
about_text.insert("1.0", """
A machine learning project that translates voice from one
language to another in real time while preserving the tone and
emotion of the speaker, and outputs the result in MP3 format.
Choose input and output languages from the dropdown menu and
start the translation!
""")
about_text.pack()

# Create a "Close" button

close_button = tk.Button(about_window, text="Close",
command=about_window.destroy)
close_button.pack()

def open_webpage(url): # Opens a web page in the user's

default web browser.
import webbrowser
webbrowser.open(url)

# Create the "Run" button

run_button = tk.Button(win, text="Start Translation",
command=run_translator)
run_button.place(relx=0.25, rely=0.9, anchor="c")

# Create the "Kill" button

kill_button = tk.Button(win, text="Kill Execution",
command=kill_execution)
kill_button.place(relx=0.5, rely=0.9, anchor="c")

# Open about page button

about_button = tk.Button(win, text="About this project",
command=open_about_page)
about_button.place(relx=0.75, rely=0.9, anchor="c")

# Run the Tkinter event loop

win.mainloop()

30