Hugging Face's logo

Spaces:
AmineDubs
/
Scripts_translation_to_arabic
Running

App Files Community
Scripts_translation_to_arabic / project_report.md
amine_dubs
Enhanced prompt engineering with cultural sensitivity and multi-language support
dbe4e2f
preview code
|
raw
history blame
17.5 kB

AI-Powered Translation Web Application - Project Report

Date: April 27, 2025

Author: [Your Name/Team Name]

1. Introduction

This report details the development process of an AI-powered web application designed for translating text and documents between various languages and Arabic (Modern Standard Arabic - Fusha). The application features a RESTful API backend built with FastAPI and a user-friendly frontend using HTML, CSS, and JavaScript. It is designed for deployment on Hugging Face Spaces using Docker.

2. Project Objectives

  • Develop a functional web application with AI translation capabilities.
  • Deploy the application on Hugging Face Spaces using Docker.
  • Build a RESTful API backend using FastAPI.
  • Integrate Hugging Face LLMs/models for translation.
  • Create a user-friendly frontend for interacting with the API.
  • Support translation for direct text input and uploaded documents (PDF, DOCX, XLSX, PPTX, TXT).
  • Focus on high-quality Arabic translation, emphasizing meaning and eloquence (Balagha) over literal translation.
  • Document the development process comprehensively.

3. Backend Architecture and API Design

3.1. Framework and Language

  • Framework: FastAPI
  • Language: Python 3.9+

3.2. Directory Structure 

/
|-- backend/
|   |-- Dockerfile
|   |-- main.py         # FastAPI application logic, API endpoints
|   |-- requirements.txt # Python dependencies
|-- static/
|   |-- script.js       # Frontend JavaScript
|   |-- style.css       # Frontend CSS
|-- templates/
|   |-- index.html      # Frontend HTML structure
|-- uploads/            # Temporary storage for uploaded files (created by app)
|-- project_report.md   # This report
|-- deployment_guide.md # Deployment instructions
|-- project_details.txt # Original project requirements

3.3. API Endpoints

  • GET /
    • Description: Serves the main HTML frontend page (index.html).
    • Response: HTMLResponse containing the rendered HTML.
  • POST /translate/text
    • Description: Translates a snippet of text provided in the request body.
    • Request Body (Form Data):
      • text (str): The text to translate.
      • source_lang (str): The source language code (e.g., 'en', 'fr', 'ar'). 'auto' might be supported depending on the model.
      • target_lang (str): The target language code (currently fixed to 'ar').
    • Response (JSONResponse):
      • translated_text (str): The translated text.
      • source_lang (str): The detected or provided source language.
    • Error Responses: 400 Bad Request (e.g., missing text), 500 Internal Server Error (translation failure), 501 Not Implemented (if required libraries missing).
  • POST /translate/document
    • Description: Uploads a document, extracts its text, and translates it.
    • Request Body (Multipart Form Data):
      • file (UploadFile): The document file (.pdf, .docx, .xlsx, .pptx, .txt).
      • source_lang (str):
      • target_lang (str): The target language code (currently fixed to 'ar').
    • Response (JSONResponse):
      • original_filename (str): The name of the uploaded file.
      • detected_source_lang (str): The detected or provided source language.
      • translated_text (str): The translated text extracted from the document.
    • Error Responses: 400 Bad Request (e.g., no file, unsupported file type), 500 Internal Server Error (extraction or translation failure), 501 Not Implemented (if required libraries missing).

3.4. Dependencies

Key Python libraries used:

  • fastapi: Web framework.
  • uvicorn: ASGI server.
  • python-multipart: For handling form data (file uploads).
  • jinja2: For HTML templating.
  • transformers: For interacting with Hugging Face models.
  • torch (or tensorflow): Backend for transformers.
  • sentencepiece, sacremoses: Often required by translation models.
  • PyMuPDF: For PDF text extraction.
  • python-docx: For DOCX text extraction.
  • openpyxl: For XLSX text extraction.
  • python-pptx: For PPTX text extraction.

(List specific versions from requirements.txt if necessary)

3.5. Data Flow

  1. User Interaction: User accesses the web page served by GET /.
  2. Text Input: User enters text, selects languages, and submits the text form.
  3. Text API Call: Frontend JS sends a POST request to /translate/text with form data.
  4. Text Backend Processing: FastAPI receives the request, calls the internal translation function (using the AI model via transformers), and returns the result.
  5. Document Upload: User selects a document, selects languages, and submits the document form.
  6. Document API Call: Frontend JS sends a POST request to /translate/document with multipart form data.
  7. Document Backend Processing: FastAPI receives the file, saves it temporarily, extracts text using appropriate libraries (PyMuPDF, python-docx, etc.), calls the internal translation function, cleans up the temporary file, and returns the result.
  8. Response Handling: Frontend JS receives the JSON response and updates the UI to display the translation or an error message.

4. Prompt Engineering and Translation Quality Control

4.1. Desired Translation Characteristics

The core requirement is to translate from a source language to Arabic (MSA Fusha) with a focus on meaning and eloquence (Balagha), avoiding overly literal translations. These goals typically fall under the umbrella of prompt engineering when using general large language models.

4.2. Approach with Instruction-Tuned LLM (FLAN-T5)

Due to persistent loading issues with the specialized Helsinki-NLP model and the desire to have more direct control over the translation process, the project switched to using google/flan-t5-small, an instruction-tuned language model.

4.2.1 Explicit Prompt Engineering

The translation process uses carefully crafted prompts to guide the model toward high-quality Arabic translations. The translate_text_internal function in main.py constructs an enhanced prompt with the following components:

prompt = f"""Translate the following {source_lang_name} text into Modern Standard Arabic (Fusha).
Focus on conveying the meaning elegantly using proper Balagha (Arabic eloquence).
Adapt any cultural references or idioms appropriately rather than translating literally.
Ensure the translation reads naturally to a native Arabic speaker.

Text to translate:
{text}"""

This prompt explicitly instructs the model to:

  • Use Modern Standard Arabic (Fusha) as the target language register
  • Emphasize eloquence (Balagha) in the translation style
  • Handle cultural references and idioms appropriately for an Arabic audience
  • Prioritize natural-sounding output over literal translation

4.2.2 Multi-Language Support

The system supports multiple source languages through a language mapping system that converts ISO language codes to full language names for better model comprehension:

language_map = {
    "en": "English",
    "fr": "French",
    "es": "Spanish",
    "de": "German",
    "zh": "Chinese",
    "ru": "Russian",
    "ja": "Japanese",
    "hi": "Hindi",
    "pt": "Portuguese",
    "tr": "Turkish",
    "ko": "Korean",
    "it": "Italian"
    # Additional languages can be added as needed
}

Using full language names in the prompt (e.g., "Translate the following French text...") helps the model better understand the translation task compared to using language codes.

4.2.3 Generation Parameter Optimization

To further improve translation quality, the model's generation parameters have been fine-tuned:

outputs = model.generate(
    **inputs,
    max_length=512,     # Sufficient length for most translations
    num_beams=5,        # Wider beam search for better quality
    length_penalty=1.0, # Slightly favor longer, more complete translations
    top_k=50,           # Consider diverse word choices
    top_p=0.95,         # Focus on high-probability tokens for coherence
    early_stopping=True
)

These parameters work together to encourage:

  • More natural-sounding translations through beam search
  • Better handling of nuanced expressions
  • Appropriate length for preserving meaning
  • Balance between creativity and accuracy

4.3. Testing and Refinement Process

  • Prompt Iteration: The core refinement process involves testing different prompt phrasings with various text samples across supported languages. Each iteration aims to improve the model's understanding of:

    • What constitutes eloquent Arabic (Balagha)
    • How to properly adapt culturally-specific references
    • When to prioritize meaning over literal translation

  • Cultural Sensitivity Testing: Sample texts containing culturally-specific references, idioms, and metaphors from each supported language are used to evaluate how well the model adapts these elements for an Arabic audience.

  • Evaluation Metrics:

    • Human Evaluation: Native Arabic speakers assess translations for:

      • Eloquence (Balagha): Does the translation use appropriately eloquent Arabic?
      • Cultural Adaptation: Are cultural references appropriately handled?
      • Naturalness: Does the text sound natural to native speakers?
      • Accuracy: Is the meaning preserved despite non-literal translation?

    • Automated Metrics: While useful as supplementary measures, metrics like BLEU are used with caution as they tend to favor more literal translations.

  • Model Limitations: The current implementation with FLAN-T5-small shows promise but has limitations:

    • It may struggle with very specialized technical content
    • Some cultural nuances from less common language pairs may be missed
    • Longer texts may lose coherence across paragraphs

    Future work may explore larger model variants if these limitations prove significant.

5. Frontend Design and User Experience

5.1. Design Choices

  • Simplicity: A clean, uncluttered interface with two main sections: one for text translation and one for document translation.
  • Standard HTML Elements: Uses standard forms, labels, text areas, select dropdowns, and buttons for familiarity.
  • Clear Separation: Distinct forms and result areas for text vs. document translation.
  • Feedback: Provides visual feedback during processing (disabling buttons, changing text) and displays results or errors clearly.
  • Responsiveness (Basic): Includes basic CSS media queries for better usability on smaller screens.

5.2. UI/UX Considerations

  • Workflow: Intuitive flow – select languages, input text/upload file, click translate, view result.
  • Language Selection: Dropdowns for selecting source and target languages. Includes common languages and an option for Arabic as a source (for potential future reverse translation). 'Auto-Detect' is included but noted as not yet implemented.
  • File Input: Standard file input restricted to supported types (accept attribute).
  • Error Handling: Displays clear error messages in a dedicated area if API calls fail or validation issues occur.
  • Result Display: Uses <pre><code> for potentially long translated text, preserving formatting and allowing wrapping. Results for Arabic are displayed RTL. Document results include filename and detected source language.

5.3. Interactivity (JavaScript)

  • Handles form submissions asynchronously using fetch.
  • Prevents default form submission behavior.
  • Provides loading state feedback on buttons.
  • Parses JSON responses from the backend.
  • Updates the DOM to display translated text or error messages.
  • Clears previous results/errors before new submissions.

6. Deployment and Scalability

6.1. Dockerization

  • Base Image: Uses an official python:3.9-slim image for a smaller footprint.
  • Dependency Management: Copies requirements.txt and installs dependencies early to leverage Docker caching.
  • Code Copying: Copies the necessary application code (backend, templates, static) into the container.
  • Directory Creation: Ensures necessary directories (templates, static, uploads) exist within the container.
  • Port Exposure: Exposes port 8000 (used by uvicorn).
  • Entrypoint: Uses uvicorn to run the FastAPI application (backend.main:app), making it accessible on 0.0.0.0.

(See backend/Dockerfile for the exact implementation)

6.2. Hugging Face Spaces Deployment

  • Method: Uses the Docker Space SDK option.
  • Configuration: Requires creating a README.md file in the repository root with specific Hugging Face metadata (e.g., sdk: docker, app_port: 8000).
  • Repository: The project code (including the Dockerfile and the README.md with HF metadata) needs to be pushed to a Hugging Face Hub repository (either model or space repo).
  • Build Process: Hugging Face Spaces automatically builds the Docker image from the Dockerfile in the repository and runs the container.

(See deployment_guide.md for detailed steps)

6.3. Scalability Considerations

  • Stateless API: The API endpoints are designed to be stateless (apart from temporary file storage during upload processing), which aids horizontal scaling.
  • Model Loading: The translation model is intended to be loaded once on application startup (currently placeholder) rather than per-request, improving performance. However, large models consume significant memory.
  • Hugging Face Spaces Resources: Scalability on HF Spaces depends on the chosen hardware tier. Free tiers have limited resources (CPU, RAM). Larger models or high traffic may require upgrading to paid tiers.
  • Async Processing: FastAPI's asynchronous nature allows handling multiple requests concurrently, improving I/O bound performance. CPU-bound tasks like translation itself might still block the event loop if not handled carefully (e.g., running in a separate thread pool if necessary, though transformers pipelines often manage this).
  • Database: No database is currently used. If user accounts or saved translations were added, a database would be needed, adding another scaling dimension.
  • Load Balancing: For high availability and scaling beyond a single container, a load balancer and multiple container instances would be required (typically managed by orchestration platforms like Kubernetes, which is beyond the basic HF Spaces setup).

7. Challenges and Future Work

7.1. Challenges

  • Model Selection: Finding the optimal balance between translation quality (especially for Balagha), performance (speed/resource usage), and licensing.
  • Prompt Engineering: Iteratively refining the prompt to consistently achieve the desired non-literal, eloquent translation style across diverse inputs.
  • Resource Constraints: Large translation models require significant RAM and potentially GPU resources, which might be limiting on free deployment tiers.
  • Document Parsing Robustness: Handling variations and potential errors in different document formats and encodings.
  • Language Detection: Implementing reliable automatic source language detection if the 'auto' option is fully developed.

7.2. Future Work

  • Implement Actual Translation: Replace placeholder logic with a real Hugging Face transformers pipeline using a selected model.
  • Implement Reverse Translation: Add functionality and models to translate from Arabic to other languages.
  • Improve Error Handling: Provide more specific user feedback for different error types.
  • Add User Accounts: Allow users to save translation history.
  • Implement Language Auto-Detection: Integrate a library (e.g., langdetect, fasttext) for the 'auto' source language option.
  • Enhance UI/UX: Improve visual design, add loading indicators, potentially show translation progress for large documents.
  • Optimize Performance: Profile the application and optimize bottlenecks, potentially exploring model quantization or different model architectures if needed.
  • Add More Document Types: Support additional formats if required.
  • Testing: Implement unit and integration tests for backend logic.

Project Log / Updates

  • 2025-04-28: Updated project requirements to explicitly include the need for the translation model to respect cultural differences and nuances in its output.
  • 2025-04-28: Switched translation model from Helsinki-NLP/opus-mt-en-ar to google/flan-t5-small due to persistent loading errors in the deployment environment and to enable direct prompt engineering for translation tasks.

8. Conclusion

This project successfully lays the foundation for an AI-powered translation web service focusing on high-quality Arabic translation. The FastAPI backend provides a robust API, and the frontend offers a simple interface for text and document translation. Dockerization ensures portability and simplifies deployment to platforms like Hugging Face Spaces. Key next steps involve integrating a suitable translation model and refining the prompt engineering based on real-world testing.