PHASE 4

Real-Time Language Translation Using Neural Machine Translation

Phase 4: Model Deployment and Interface Development

College Name: Vivekananda Institute of Technology, Bangalore

Group Member:
▪ Name: : N Dishanth Naik
▪ CAN ID Number: CAN 33401527

▪ Name: Shashank MS
▪ CAN ID Number: CAN_33497484

▪ Name: Punith V
▪ CAN ID Number: CAN_33467315

▪ Name: Insia Sarwath

▪ CAN ID Number: CAN_33442031

Roles and responsibilities

Name: : N Dishanth Naik CAN ID Number: CAN 33401527 (Responsible for Data Collection &
Preprocessing)
• Tasks:
o Collect multilingual parallel datasets (e.g., from OpenSubtitles, Europarl, WMT datasets).
o Clean and preprocess the text data (tokenization, normalization, removing noise).
o Align sentences and ensure correct formatting for training.
o Split data into training, validation, and test sets.
• Tools:
o Python, NLTK, spaCy, Moses toolkit, TensorFlow Datasets
o Libraries: sentencepiece, re, pandas

Name: Shashank MS CAN ID Number: CAN_33497484 Responsible for Neural Machine Translation
Model)
• Tasks:
o Select the model architecture (Transformer-based, seq2seq with attention, or pretrained
models like mBART, T5).
o Train and fine-tune the model using TensorFlow/Keras or PyTorch.
o Optimize hyperparameters for better translation accuracy.
o Evaluate the model using BLEU, METEOR, and other NLP metrics.
• Tools:
o TensorFlow, PyTorch, Hugging Face transformers
o Libraries: torch, transformers, tensorflow, fairseq

Name: Punith V CAN ID Number: CAN_33467315 (Responsible for Real-Time Processing & Integration)

• Tasks:

o Develop an API (Flask/FastAPI) to handle input text and return translated output.
 PHASE 4
o Integrate the trained NMT model into the backend.

o Optimize for real-time translation performance.

o Ensure API security and scalability for deployment.

• Tools:

o Flask, FastAPI, Django REST Framework

o Libraries: requests, uvicorn, gunicorn

Name: Insia Sarwath CAN ID Number: CAN_33442031 (Responsible for User Interface &
Deployment)
• Tasks:
o Design an intuitive UI for users to input text/audio for translation.
o Implement WebSocket for real-time translation responses.
o Integrate the backend API with the frontend.
o Deploy the application (using cloud platforms like AWS/GCP/Azure).
• Tools:
o React.js, Vue.js, or Angular
o WebSockets, Bootstrap, Tailwind CSS
o Deployment: AWS Lambda, Google Cloud Functions, Docker

Overview of Model Deployment and Interface Development

Real-time language translation requires a well-integrated system that includes a trained Neural
Machine Translation (NMT) model, an interactive web interface, and a cloud-based deployment
environment for scalability and efficiency.

• Model Deployment: Hosting the NMT model in a cloud or edge environment for real-time
inference.

• Interface Development: Creating a user-friendly front-end for users to input and receive
translated text/audio.

• Collaboration & Integration: Combining AI models with external APIs, databases, and third-
party services.

Deploying the Model

1. Model Optimization

• Convert the trained model into a lightweight, optimized format (e.g., ONNX, TensorRT) for faster
inference.
• Use quantization and pruning to reduce computational overhead.

2. Choosing a Deployment Strategy

• On-premise: Running the model locally for low-latency translation (e.g., edge AI devices).
• Cloud-based: Deploying on cloud platforms such as AWS, Google Cloud, or Azure for scalability.
•
 PHASE 4

• Hybrid approach: Using both local processing and cloud fallback when required.

3. Deployment Pipelines

• Use Docker containers and Kubernetes for efficient microservice-based deployment.

• Set up a CI/CD pipeline for automatic updates and scaling.
• Expose the model as a REST API or gRPC service for easy integration with web and mobile apps.

4. Real-Time Inference Considerations

• Implement caching mechanisms to reduce redundant translation requests.

• Use load balancing to distribute translation tasks efficiently.
• Integrate batch processing for large text inputs.

# Real-Time Language Translation using NMT

## Project Overview
This project is a real-time language translation system using **Neural Machine Translation (NMT)**
models from the **Hugging Face Transformers library**. It utilizes **Google T5 (Text-to-Text Transfer
Transformer)** for multilingual translation and **Helsinki-NLP's OPUS-MT** models for specific
language pairs.

## Features
- Translates text from English to multiple languages, including **French, German, and Spanish**.
- Uses **Google T5 (t5-base)** for general multilingual translation.
- Uses **Helsinki-NLP OPUS-MT** for specific language pairs (e.g., English to Spanish).
- Streamlit-based UI for user-friendly interaction (coming soon!).

## Technologies Used
- Python
- Hugging Face **Transformers**
- **T5-base** for multilingual translation
- **Helsinki-NLP OPUS-MT** for specific translations
- **Streamlit** for UI (upcoming feature)

## Installation
### **1. Clone the Repository**
```sh
git clone https://github.com/yourusername/Real-Time-Language-Translation-NMT.git
cd Real-Time-Language-Translation-NMT
```

### **2. Set Up a Virtual Environment**

```sh
python -m venv venv
source venv/bin/activate # On macOS/Linux
venv\Scripts\activate # On Windows
```

### **3. Install Dependencies**

```sh
pip install -r requirements.txt
 PHASE 4
```

### **4. Install Additional Libraries (if needed)**

```sh
pip install transformers sacremoses sentencepiece
```

## Usage
Run the Python script to translate text:
```sh
python translation.py
```

## Code Structure
```
Real-Time-Language-Translation-NMT/
├── translation.py # Main script for translation
├── app.py # Streamlit UI (coming soon)
├── requirements.txt # Required Python packages
├── README.md # Project documentation
└── venv/ # Virtual environment (not included in repo)
```

## Example Output
```sh
Translated to French: Comment vous êtes-vous ?
Translated to German: Wie läuft es Ihnen?
Translated to Spanish: ¿Cómo estás?
```

## Streamlit UI (Upcoming Feature)

A **web-based UI** using Streamlit will be added to allow users to input text and select target
languages for translation in an interactive interface.

To run the Streamlit UI (once implemented):

```sh
streamlit run ui.py
```

## Troubleshooting
### **1. Model Loading Issues**
If you get an error related to **model loading**, ensure you have an internet connection and that the
model name is correctly spelled. Try manually downloading the model:
```python
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
model = AutoModelForSeq2SeqLM.from_pretrained("Helsinki-NLP/opus-mt-en-es")
tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-es")
```

### **2. Multiprocessing Issues on Windows**

Ensure that your script runs inside the `if __name__ == "__main__":` block.
 PHASE 4
a. ### **3. Missing `sacremoses` Warning**
b. Install `sacremoses` manually:
c. ```sh
d. pip install sacremoses

Developing the Web Interface

1. User Interface (UI) Design

• A simple and interactive UI allowing users to input text/audio for translation.
• Speech-to-text integration for real-time spoken translations.
• Dropdown menus for selecting source and target languages.

2. API Integration
• Connect the web interface to the NMT model API for seamless communication.
• Implement error handling for unsupported languages or failed translations.
• Use WebSockets for real-time translation feedback.

3. Mobile & Web App Development

• Use React.js, Vue.js, or Angular for a responsive web interface.
• Develop a mobile version using Flutter or React Native.
• Ensure cross-platform compatibility for Android, iOS, and web users

import streamlit as st
from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer

# Load M2M100 model - better for multilingual translation

tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_418M")
model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_418M")

def translate_text(text, src_lang, tgt_lang):

lang_codes = {
"English": "en",
"French": "fr",
"German": "de",
"Spanish": "es"
}

tokenizer.src_lang = lang_codes[src_lang]
encoded = tokenizer(text, return_tensors="pt")
generated_tokens = model.generate(
**encoded,
forced_bos_token_id=tokenizer.get_lang_id(lang_codes[tgt_lang])
)
return tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]

# Streamlit UI
st.title("Multi-Language Translator")
 PHASE 4
source_text = st.text_area("Enter text to translate:")
source_lang = st.selectbox("Source Language", ["English", "French", "German", "Spanish"])
target_lang = st.selectbox("Target Language", ["English", "French", "German", "Spanish"])

if st.button("Translate"):
if source_text:
translation = translate_text(source_text, source_lang, target_lang)
st.success(f"Translated Text: {translation}")
else:
st.error("Please enter text to translate!")

Cloud Platform Considerations

1. Choosing the Right Cloud Provider

• AWS Lambda + S3 + API Gateway for serverless deployment.

• Google Cloud AI for leveraging Google’s NMT models.
• Azure Machine Learning for scalable model hosting.

2. Scalability & Latency Optimization

• Use CDN (Content Delivery Network) to reduce latency.

• Implement serverless functions (AWS Lambda, Google Cloud Functions) for quick execution.
• Monitor GPU acceleration using TPUs/GPUs for better performance.

3. Security & Compliance

• Ensure end-to-end encryption for sensitive translation data.

• Use OAuth2 and JWT authentication for user access control.
• Follow GDPR and data privacy laws for international users.

Collaboration and Integration Efforts

1. Partnering with AI & NLP Experts

• Work with linguists and AI researchers to improve translation accuracy.

• Collaborate with universities for model training on diverse datasets.

2. Integrating with Existing Platforms

• Add translation capabilities to platforms like Slack, Microsoft Teams, Zoom, and WhatsApp.
• Connect with customer service chatbots for multilingual support.

3. Community Contributions & Open Source

• Contribute to open-source translation models like MarianNMT or OpenNMT.

• Allow developers to build custom plugins for specific languages.
 PHASE 4

Conclusion: Impact and Future Scope

Impact

• Breaks language barriers, enabling better global communication.

• Enhances business expansion by supporting multilingual customers.
• Helps in education, allowing students to access learning material in their native languages.

Future Scope

• Real-time video translation using AI-driven subtitles.

• Neural-based voice synthesis for natural speech translation.
• Integration with AR/VR for real-time translated conversations.
• Federated Learning for Personalization, allowing models to learn user preferences while maintaining
privacy.

Final Thoughts
Deploying a real-time language translation system requires a well-structured approach involving model
optimization, cloud hosting, UI/UX development, and collaboration with experts. Future advancements in
AI, deep learning, and cloud computing will continue to improve translation accuracy, speed, and
accessibility, making global communication more seamless than ever.

Github Repository Links for Respective Team Members:

▪ Name: : N Dishanth Naik

▪ CAN ID Number: CAN 33401527 https://github.com/DishanthNaik19/Real-time-
language-translation-using-neutral-machine-translation-/tree/main

▪ Name: Shashank MS
▪ CAN ID Number: CAN_33497484 https://github.com/ms-shashank/Real-Time-
Language-Translation-NMT

▪ Name: Punith V
▪ CAN ID Number: CAN_33467315 https://github.com/Punithv2003

▪ Name: Insia Sarwath

▪ CAN ID Number: CAN_33442031 https://github.com/sarwath183

Youtube Video Link: https://youtu.be/kpNTqqucsVg?si=nLIB7MIaSxNKD1eU

PHASE 4