(I have already submitted the Google Form for this submission ID, but I was not completely sure if I submitted the correct content, so I am submitting it once more. I appreciate your understanding.) We trained LLaMA-3.1-8B-Instruct using a multi-turn dialogue setup that incorporates function calls to: (1) identify key entities in the source text that require lookup via function calls (e.g., [search("The Great Gatsby")]) and (2) retrieve their corresponding entities in the target language using the Wikipedia API. These retrieved entities are then leveraged to generate the final translation. The system is capable of performing searches at test time, and this version utilizes real-time search to evaluate its performance in real-world conditions. Additionally, it integrates a validation dataset during training to further enhance accuracy.


Rakuten7b with Preference Optmization on paranames


A three-stage pipeline incorporating Chain-of-Thought (CoT) reasoning that extracts entities, generates queries for Wikidata search, and leverages returned candidate entity information to enhance LLM translation.


We prompt a state-of-the-art language model with instructions designed to increase the model's attention in the named entity. We incorporate information from WikiData into the prompt to suggest a translation of the entity, and also leverage in context learning.


See description for Submission ID 226303. This removes the LLM post-processing (i.e. only DB retrieval and NLLB translation).


The generated output from the model detailed (gpt-4o-mini-2024-07-18) was not edited (ie. was not fine-tuned, knowledge-augmented, etc). Along with the other models a system paper will explore and discuss areas of failure for machine translation by LLMs (transliteration, formality, etc).


I have fine tuned M2M100 model by first finding entities using universal NER and then have done the Instruction based fine tuning.


NER using standard libraries and LLM, and then the LLM ensemble to create a translation . The final translation is selected based on the metric and the additional model


This submission used an NER model and a Machine Translation model from huggingface. Just detected the NER's and ensured their proper replacement. Used spacy as NER model and NLLB as Machine Translation model.


The generated output from the model detailed (claude-3-5-haiku-20241022) was not edited (ie. was not fine-tuned, knowledge-augmented, etc). Along with the other models a system paper will explore and discuss areas of failure for machine translation by LLMs (transliteration, formality, etc).


Prompted GPT-4o to do the translation. We utilised RAGthoven preprocessor to include wikidata entity name and it's translation in the user prompt.


The generated output from the model detailed (gemini-1.5-pro) was not edited (ie. was not fine-tuned, knowledge-augmented, etc). Along with the other models a system paper will explore and discuss areas of failure for machine translation by LLMs (transliteration, formality, etc).


This MT approach involves a pipeline of multiple steps, where the control center is a LLM (Qwen-2.5), and uses an external Knowledge Base (Wikidata). It uses carefully designed prompts and few-shots examples for the following steps: 1. LLM detects NE and surrounds them with tags; 2. LLM translates the tagged sentence, leaving NE as they are; 3. NE translations are queried through Wikidata API by their detected name, and inserted into the sentence, replacing the tagged parts; 4. LLM checks for fluency and adequacy in the target language. Since instructions are involved, it is important to have a low temperature when sampling the model.


I have basically here used gpt 4o mini to do the machine translated.


The approach involves identifying named entities using the WikiNEuRal multilingual NER model, translating them with the Wikidata API for precision, and temporarily replacing them with placeholders. The remaining text is translated separately, after which the placeholders are reinserted with the translated entities. Finally, refinements are applied to ensure the output maintains grammatical correctness and contextual coherence.


The generated output from the model detailed (o1-2024-12-17) was not edited (ie. was not fine-tuned, knowledge-augmented, etc). Along with the other models a system paper will explore and discuss areas of failure for machine translation by LLMs (transliteration, formality, etc).


A prompt template was created to use the Gemini model in translating test data from English to the 10 languages. The template instructed the model to pay attention to entities while making the translations. For languages that had training data from the task repository, 10 examples were used from the said training data to guide the model on the expected result.


We made use of google translate to translate the training set to create a silver dataset. We then finetuned an encoder decoder model on this silver dataset. We used this finetuned encoder decoder model on the test set.


This submission implements a Spanish-English translation system using a fine-tuned MarianMT model, which was trained on a combination of general translation data and entity-specific translations obtained from Wikidata. The system includes a complete pipeline from data collection through model training to inference, with optimizations for handling large datasets and maintaining translation quality.


The generated output from the model detailed (gpt-4o-2024-08-06) was not edited (ie. was not fine-tuned, knowledge-augmented, etc). Along with the other models a system paper will explore and discuss areas of failure for machine translation by LLMs (transliteration, formality, etc).


Added the entity embedding to the cross attention and had our retrieved translated entity in the input.


The generated output from the model detailed (o1-mini-2024-09-12) was not edited (ie. was not fine-tuned, knowledge-augmented, etc). Along with the other models a system paper will explore and discuss areas of failure for machine translation by LLMs (transliteration, formality, etc).


We trained LLaMA-3.1-8B-Instruct using a multi-turn dialogue setup that incorporates function calls to: (1) identify key entities in the source text that require lookup via function calls (e.g., [search("The Great Gatsby")]) and (2) retrieve their corresponding entities in the target language using the Wikipedia API. These retrieved entities are then leveraged to generate the final translation. While the system is capable of performing searches at test time, this version utilizes “gold” information to achieve its highest possible performance.


Fine-tune qwen2.5-72b with lora and integrate zhconv package


The generated output from the model detailed (llama3:8b) was not edited (ie. was not fine-tuned, knowledge-augmented, etc). Along with the other models a system paper will explore and discuss areas of failure for machine translation by LLMs (transliteration, formality, etc).


The generated output from the model detailed (gemini-1.5-flash) was not edited (ie. was not fine-tuned, knowledge-augmented, etc). Along with the other models a system paper will explore and discuss areas of failure for machine translation by LLMs (transliteration, formality, etc).


See Submission 226303 for details. These are the results achieved when using the wikidataIDs provided with the test-dataset instead of using our retrieval mechanism. Translations are done using the same fine-tuned NLLB model. The LLM post-processing step is also omitted, as it was only introduced to fix wrong retrieval results.


Using qwen2.5-72B as the base model and wiki-id as the input, lora was used for training


Approach using a simple, heuristics driven, non-neural DB retrieval for the entities. Translation is done using a fine-tuned NLLB (Results appended @1), training on a mixture of the development dataset and a heavily filtered down version of the mintaka dataset (relevant languages only). With the usage of gpt-4o-mini provided with the src text, the retrieved candidates @3 and the translation for cleaning up obviously wrongly selected candidates.


We fine-tuned a Multilingual T5 model using specific prompting instructions. First, these instructions make the model aware of the relevant entities. Once the entities are identified, the model then proceeds with the translation. This approach helps ensure more accurate and contextually appropriate results.


I have used T5 instruction based fine tuning.


A prompt template was created to use the Gemini model in translating test data from English to the 10 languages. The template instructed the model to pay attention to entities while making the translations. This was a zero-shot approach so no sample translations were provided to the model.


Entity-aware machine translation task submission where we use an entity linking part to retrieve the correct translation of the critical entity and then insert this translation into the gemma-2-9b-it prompt


This system is based on GPT-4o and integrates named entity recognition (NER) and entity linking techniques to improve translation quality. The model ensures context-aware entity translations for French and Italian, leveraging fine-tuned prompts and re-ranking strategies to enhance performance.


We create an ensemble of three distinct translation methods, including in-context learning with a LLM, and two commercial MT systems. We select, for each instance, a system that accurately translates the named entity, using validation set performance to break ties. We provided GPT with translations of the given named entity. We also check that translations contained those NE translations, for ensembling purposes.


We prompt a state-of-the-art language model with instructions designed to increase the model's attention in the named entity. We also leverage in context learning to showcase example input output pairs in the prompt.


Due to the hardware limitation, I applied several standard common MT models. To handle the models complexity and overfitting, I tried the Low Rank Adaptation settings with an early stopping mechanism.


Prompted GPT-4o to do the translation. We utilised RAGthoven preprocessor to include wikidata entity name and it's translation in the user prompt. In order to improve translations we used RAG and included most similar examples in system prompt.


We trained LLaMA-3.1-8B-Instruct using a multi-turn dialogue setup that incorporates function calls to: (1) identify key entities in the source text that require lookup via function calls (e.g., [search("The Great Gatsby")])and (2) retrieve their corresponding entities in the target language using the Wikipedia API. These retrieved entities are then leveraged to generate the final translation. The system is capable of performing searches at test time, and this version utilizes real-time search to evaluate its performance in real-world conditions.


Use qwen-max-latest as translator, use wiki-id gold label to retrieve entity names used in input with English prompts. Entity names in both source language and target language are retrieved, explicitly pass the entity names to model through prompts. For zh-TW, added an process that convert zh to zh(Traditional).


The generated output from the model detailed (claude-3-5-sonnet-20241022) was not edited (ie. was not fine-tuned, knowledge-augmented, etc). Along with the other models a system paper will explore and discuss areas of failure for machine translation by LLMs (transliteration, formality, etc).


In this submission, we retrieve entity labels and descriptions from Wikidata and pass them to a GPT model for initial entity translation. This step ensures that each named entity is accurately rendered in the target language, taking into account metadata such as the entity’s description. Next, we feed those refined entity translations into a final GPT translation process to generate the complete target-language sentence.


We finetuned an Mbart seq2seq model on translation for all of the given languages. Utilizing Flair NER predictions which were fed through our knowledge base for determining the proper entity translation we built a dataset combining the source and desired translation for the entity like so: "<source>|<translated_entity>" which was then trained to predict the target.  This was a very simplistic approach to attempt to provide additional information to a well performing translation model in order to boost its effectiveness.


I have used gpt 4o for machine Translation.


Prompted GPT-4o to do the translation. In order to improve translations we used RAG and included most similar examples in system prompt.


This submission uses GPT-4o fine-tuned for Entity-Aware Machine Translation (EA-MT) from English to French and Italian. The system incorporates named entity recognition (NER) and context-based re-ranking to improve the translation of rare and ambiguous named entities. It also leverages external reference databases to enhance entity translation consistency.


(I have already submitted the Google Form for this submission ID, but I was not completely sure if I submitted the correct content, so I am submitting it once more. I appreciate your understanding.) We trained LLaMA-3.1-8B-Instruct using a multi-turn dialogue setup that incorporates function calls to: (1) identify key entities in the source text that require lookup via function calls (e.g., [search("The Great Gatsby")]) and (2) retrieve their corresponding entities in the target language using the Wikipedia API. These retrieved entities are then leveraged to generate the final translation. While the system is capable of performing searches at test time, this version utilizes “gold” information to achieve its highest possible performance. Additionally, it integrates a validation dataset during training to further enhance performance.


Using phi4 as the base model and wiki-id as the input, it was trained with full fine-tuning


The team fine-tuned the NLLB-200 model (distilled 600M version) using the training data from the task repository. Furthermore, wikidata id from the task repo were extracted and used to further finetune another NLLB-200 model. The test data was then used for translation using the fine-tuned models.


We used GPT-4o to generate translations for each sentence. Using the gold Wikidata ID, we applied a Retrieval-Augmented Generation (RAG) approach that provides the entity’s English label, foreign label, and description. Since the task emphasizes both entity label accuracy and overall translation quality, we integrated a self-refinement framework. This means GPT  provided feedback on the initial translation from both perspectives and then revised it accordingly by itself.