---
title: plamo-3-translate-2b
canonical_url: "https://www.modelscope.cn/models/pfnet/plamo-3-translate-2b"
md_url: "https://www.modelscope.cn/models/pfnet/plamo-3-translate-2b.md"
repository: pfnet/plamo-3-translate-2b
last_updated: 2026-11-09
license: other
pipeline_tag: translation
tasks:
- translation
model_type:
- plamo3
architectures:
- Plamo3ForCausalLM
parameters: 2.9B
tensor_type:
- BF16
library_name:
- transformer
- safetensors
- pytorch
frameworks:
- pytorch
language:
- ar
- az
- be
- bg
- bn
- ca
- ceb
- de
- en
- es
- et
- eu
- fa
- fr
- gu
- he
- hi
- hr
- hu
- hy
- id
- it
- ja
- jv
- ka
- kk
- km
- ko
- lt
- lv
- ml
- mr
- ms
- my
- ne
- nl
- pa
- pl
- ru
- si
- sk
- sl
- sr
- sw
- ta
- te
- th
- tl
- ur
- uz
- vi
- zh
downloads: 16
stars: 0
tags:
- translation
- multilingual
- custom_code
- plamo
---
# plamo-3-translate-2b
> plamo-3-translate-2b - pfnet 在 ModelScope 开源的模型。PLaMo 3 Translate 2B
pfnet/plamo-3-translate-2b 是 ModelScope 魔搭社区上的 2.9B 参数translation模型，采用 other 许可。
- **Repository**: pfnet/plamo-3-translate-2b
- **License**: other
- **Tasks**: translation
- **Parameters**: 2.9B
- **Tags**: translation, multilingual, custom_code, plamo
- **Downloads**: 16
- **Stars**: 0
- **Last updated**: 2026-11-09
Source: https://www.modelscope.cn/models/pfnet/plamo-3-translate-2b
---
# PLaMo 3 Translate 2B
PFN™ translate model
[日本語版のREADME / Japanese README](README_ja.md)
PLaMo 3 Translate 2B is a translation-specialized LLM developed by Preferred Networks (PFN) that delivers world-class translation quality.
It is built on PLaMo 3 NICT, a pretrained model developed through joint research by PFN and the National Institute of Information and Communications Technology (NICT).
We further trained this base model on tens of billions of tokens of translation-focused data.
For development details, see the [tech blog](https://www.preferred.jp/en/blog/tech/plamo-3-translate-weight-release).
PLaMo 3 Translate 2B supports translation among 53 languages (see [Supported Languages](#supported-languages)).
It can also take surrounding context and a glossary into account, and lets you choose between plain and polite style for Japanese output.
The maximum length during training was 32,768 tokens for the input and output combined. The model can translate long passages in one go, but split anything longer so that the input and output together stay within this limit.
PLaMo 3 Translate 2B is available under the [PLaMo Community License](https://plamo.preferredai.jp/info/plamo-community-license-en). Personal use, such as learning or hobby projects, and other non-commercial use, including academic use, are free of charge with no prior registration. See [License](#license) for the terms of commercial use.
## Benchmarks
PLaMo 3 Translate delivers world-class quality in both Japanese–English and multilingual translation. Even the 2B model outperforms the translation-specialized LLMs we compared against on every metric in the figure below.
The top row shows Japanese–English translation quality as the average of PFTB, SaaS and WMT24++ COMET-22. The middle row shows translation between Japanese and 14 other languages, and the bottom row between English and 14 other languages, each as the average of FLORES+ chrF++ in both directions. Higher is better for all scores.
For the FLORES+ multilingual evaluation, we selected the following 15 of the 53 supported languages. Translation was evaluated in both directions between Japanese or English and each of the remaining 14 languages.
- Japanese, English, Arabic, Indonesian, Italian, Dutch, Korean, Spanish, Thai, Chinese (Simplified and Traditional), German, French, Vietnamese, Russian
For details, see the [tech blog](https://www.preferred.jp/en/blog/tech/plamo-3-translate-weight-release).
## Choosing a Model
### Model List
PLaMo 3 Translate comes in four sizes: 0.8B, 2B, 8B and 31B.
For each size, quantized and converted variants are provided in separate repositories.
| Size | BF16 | FP8 | W4A16 | W4AFP8 | NVFP4 | GGUF | MLX |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 0.8B | [BF16](https://huggingface.co/pfnet/plamo-3-translate-0.8b) | [FP8](https://huggingface.co/pfnet/plamo-3-translate-0.8b-FP8) | [W4A16](https://huggingface.co/pfnet/plamo-3-translate-0.8b-W4A16) | [W4AFP8](https://huggingface.co/pfnet/plamo-3-translate-0.8b-W4AFP8) | [NVFP4](https://huggingface.co/pfnet/plamo-3-translate-0.8b-NVFP4) | [GGUF](https://huggingface.co/pfnet/plamo-3-translate-0.8b-GGUF) | [MLX-4bit](https://huggingface.co/pfnet/plamo-3-translate-0.8b-MLX-4bit) |
| 2B | [BF16](https://huggingface.co/pfnet/plamo-3-translate-2b) | [FP8](https://huggingface.co/pfnet/plamo-3-translate-2b-FP8) | [W4A16](https://huggingface.co/pfnet/plamo-3-translate-2b-W4A16) | [W4AFP8](https://huggingface.co/pfnet/plamo-3-translate-2b-W4AFP8) | [NVFP4](https://huggingface.co/pfnet/plamo-3-translate-2b-NVFP4) | [GGUF](https://huggingface.co/pfnet/plamo-3-translate-2b-GGUF) | [MLX-4bit](https://huggingface.co/pfnet/plamo-3-translate-2b-MLX-4bit) |
| 8B | [BF16](https://huggingface.co/pfnet/plamo-3-translate-8b) | [FP8](https://huggingface.co/pfnet/plamo-3-translate-8b-FP8) | [W4A16](https://huggingface.co/pfnet/plamo-3-translate-8b-W4A16) | [W4AFP8](https://huggingface.co/pfnet/plamo-3-translate-8b-W4AFP8) | [NVFP4](https://huggingface.co/pfnet/plamo-3-translate-8b-NVFP4) | [GGUF](https://huggingface.co/pfnet/plamo-3-translate-8b-GGUF) | [MLX-4bit](https://huggingface.co/pfnet/plamo-3-translate-8b-MLX-4bit) |
| 31B | [BF16](https://huggingface.co/pfnet/plamo-3-translate-31b) | [FP8](https://huggingface.co/pfnet/plamo-3-translate-31b-FP8) | [W4A16](https://huggingface.co/pfnet/plamo-3-translate-31b-W4A16) | [W4AFP8](https://huggingface.co/pfnet/plamo-3-translate-31b-W4AFP8) | [NVFP4](https://huggingface.co/pfnet/plamo-3-translate-31b-NVFP4) | [GGUF](https://huggingface.co/pfnet/plamo-3-translate-31b-GGUF) | [MLX-4bit](https://huggingface.co/pfnet/plamo-3-translate-31b-MLX-4bit) |
Accuracy changes from quantization
For each model size, the tables compare the translation accuracy of BF16 with that of each distribution format. The value in parentheses under each score is the difference from BF16 of the same size (a negative value means lower accuracy). Higher is better for all scores.
For details on the evaluation metrics, see the [tech blog](https://www.preferred.jp/en/blog/tech/plamo-3-translate-weight-release).
Overall, `GGUF Q2_K` shows lower translation accuracy on some metrics, while the other formats stay close to BF16.
Size is the total size of the weight files.
#### 31B
| Format | Size (GB) | PFTB (En↔Ja) | SaaS (En→Ja) | WMT24++ COMET-22 (En→Ja) | FLORES+ chrF++ (Ja↔Multilingual) | FLORES+ chrF++ (En↔Multilingual) |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| **BF16** | 63.51 | 0.6244 | 0.5786 | 0.8799 | 37.81 | 56.61 |
| FP8 | 32.31 | 0.6240
(-0.0004) | 0.5803
(+0.0017) | 0.8799
(0.0000) | 37.79
(-0.02) | 56.60
(-0.01) |
| W4A16 | 17.19 | 0.6258
(+0.0014) | 0.5777
(-0.0009) | 0.8805
(+0.0006) | 37.74
(-0.07) | 56.49
(-0.12) |
| W4AFP8 | 17.19 | 0.6223
(-0.0021) | 0.5716
(-0.0070) | 0.8813
(+0.0014) | 37.71
(-0.10) | 56.53
(-0.08) |
| NVFP4 | 18.66 | 0.6258
(+0.0014) | 0.5748
(-0.0038) | 0.8809
(+0.0010) | 37.70
(-0.11) | 56.49
(-0.12) |
| GGUF BF16 | 63.52 | 0.6241
(-0.0003) | 0.5793
(+0.0007) | 0.8799
(0.0000) | 37.82
(+0.01) | 56.59
(-0.02) |
| GGUF Q4_K_M | 19.53 | 0.6237
(-0.0007) | 0.5770
(-0.0016) | 0.8810
(+0.0011) | 37.84
(+0.03) | 56.55
(-0.06) |
| GGUF Q3_K_M | 15.86 | 0.6223
(-0.0021) | 0.5780
(-0.0006) | 0.8813
(+0.0014) | 37.78
(-0.03) | 56.54
(-0.07) |
| GGUF Q2_K | 12.61 | 0.6126
(-0.0118) | 0.5745
(-0.0041) | 0.8801
(+0.0002) | 37.36
(-0.45) | 56.16
(-0.45) |
| MLX 4bit | 18.66 | 0.6222
(-0.0022) | 0.5779
(-0.0007) | 0.8800
(+0.0001) | 37.82
(+0.01) | 56.58
(-0.03) |
#### 8B
| Format | Size (GB) | PFTB (En↔Ja) | SaaS (En→Ja) | WMT24++ COMET-22 (En→Ja) | FLORES+ chrF++ (Ja↔Multilingual) | FLORES+ chrF++ (En↔Multilingual) |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| **BF16** | 17.06 | 0.6119 | 0.5750 | 0.8805 | 37.45 | 56.22 |
| FP8 | 9.41 | 0.6123
(+0.0004) | 0.5764
(+0.0014) | 0.8805
(0.0000) | 37.40
(-0.05) | 56.17
(-0.05) |
| W4A16 | 5.71 | 0.6114
(-0.0005) | 0.5749
(-0.0001) | 0.8789
(-0.0016) | 37.36
(-0.09) | 56.19
(-0.03) |
| W4AFP8 | 5.71 | 0.6174
(+0.0055) | 0.5759
(+0.0009) | 0.8794
(-0.0011) | 37.34
(-0.11) | 56.12
(-0.10) |
| NVFP4 | 6.07 | 0.6040
(-0.0079) | 0.5783
(+0.0033) | 0.8792
(-0.0013) | 37.26
(-0.19) | 56.10
(-0.12) |
| GGUF BF16 | 17.07 | 0.6110
(-0.0009) | 0.5755
(+0.0005) | 0.8802
(-0.0003) | 37.46
(+0.01) | 56.22
(0.00) |
| GGUF Q4_K_M | 5.28 | 0.6100
(-0.0019) | 0.5765
(+0.0015) | 0.8802
(-0.0003) | 37.39
(-0.06) | 56.18
(-0.04) |
| GGUF Q3_K_M | 4.31 | 0.6019
(-0.0100) | 0.5707
(-0.0043) | 0.8826
(+0.0021) | 37.20
(-0.25) | 55.93
(-0.29) |
| GGUF Q2_K | 3.45 | 0.5989
(-0.0130) | 0.5676
(-0.0074) | 0.8791
(-0.0014) | 36.54
(-0.91) | 55.31
(-0.91) |
| MLX 4bit | 6.07 | 0.6102
(-0.0017) | 0.5751
(+0.0001) | 0.8796
(-0.0009) | 37.41
(-0.04) | 56.19
(-0.03) |
#### 2B
| Format | Size (GB) | PFTB (En↔Ja) | SaaS (En→Ja) | WMT24++ COMET-22 (En→Ja) | FLORES+ chrF++ (Ja↔Multilingual) | FLORES+ chrF++ (En↔Multilingual) |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| **BF16** | 5.76 | 0.6061 | 0.5612 | 0.8780 | 37.02 | 55.74 |
| FP8 | 3.43 | 0.6067
(+0.0006) | 0.5613
(+0.0001) | 0.8776
(-0.0004) | 36.98
(-0.04) | 55.76
(+0.02) |
| W4A16 | 2.30 | 0.6032
(-0.0029) | 0.5594
(-0.0018) | 0.8783
(+0.0003) | 36.96
(-0.06) | 55.69
(-0.05) |
| W4AFP8 | 2.30 | 0.6022
(-0.0039) | 0.5612
(0.0000) | 0.8772
(-0.0008) | 36.95
(-0.07) | 55.71
(-0.03) |
| NVFP4 | 2.41 | 0.6032
(-0.0029) | 0.5626
(+0.0014) | 0.8783
(+0.0003) | 36.82
(-0.20) | 55.64
(-0.10) |
| GGUF BF16 | 5.76 | 0.6062
(+0.0001) | 0.5619
(+0.0007) | 0.8782
(+0.0002) | 37.02
(0.00) | 55.75
(+0.01) |
| GGUF Q4_K_M | 1.81 | 0.6062
(+0.0001) | 0.5602
(-0.0010) | 0.8774
(-0.0006) | 37.00
(-0.02) | 55.76
(+0.02) |
| GGUF Q4_0 | 1.70 | 0.6069
(+0.0008) | 0.5604
(-0.0008) | 0.8791
(+0.0011) | 36.12
(-0.90) | 55.62
(-0.12) |
| GGUF Q3_K_M | 1.50 | 0.6053
(-0.0008) | 0.5644
(+0.0032) | 0.8789
(+0.0009) | 36.81
(-0.21) | 55.59
(-0.15) |
| GGUF Q2_K | 1.23 | 0.5977
(-0.0084) | 0.5610
(-0.0002) | 0.8777
(-0.0003) | 36.45
(-0.57) | 55.02
(-0.72) |
| MLX 4bit | 2.41 | 0.6040
(-0.0021) | 0.5624
(+0.0012) | 0.8777
(-0.0003) | 36.99
(-0.03) | 55.64
(-0.10) |
#### 0.8B
| Format | Size (GB) | PFTB (En↔Ja) | SaaS (En→Ja) | WMT24++ COMET-22 (En→Ja) | FLORES+ chrF++ (Ja↔Multilingual) | FLORES+ chrF++ (En↔Multilingual) |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| **BF16** | 1.78 | 0.5862 | 0.5530 | 0.8724 | 36.08 | 54.44 |
| FP8 | 1.22 | 0.5846
(-0.0016) | 0.5491
(-0.0039) | 0.8726
(+0.0002) | 36.00
(-0.08) | 54.60
(+0.16) |
| W4A16 | 0.95 | 0.5847
(-0.0015) | 0.5439
(-0.0091) | 0.8711
(-0.0013) | 35.78
(-0.30) | 53.95
(-0.49) |
| W4AFP8 | 0.95 | 0.5783
(-0.0079) | 0.5456
(-0.0074) | 0.8718
(-0.0006) | 35.75
(-0.33) | 54.38
(-0.06) |
| NVFP4 | 0.98 | 0.5787
(-0.0075) | 0.5436
(-0.0094) | 0.8702
(-0.0022) | 35.54
(-0.54) | 54.20
(-0.24) |
| GGUF BF16 | 1.78 | 0.5873
(+0.0011) | 0.5533
(+0.0003) | 0.8727
(+0.0003) | 36.10
(+0.02) | 54.45
(+0.01) |
| GGUF Q4_K_M | 0.57 | 0.5832
(-0.0030) | 0.5451
(-0.0079) | 0.8716
(-0.0008) | 35.90
(-0.18) | 54.47
(+0.03) |
| GGUF Q4_0 | 0.55 | 0.5853
(-0.0009) | 0.5500
(-0.0030) | 0.8723
(-0.0001) | 34.97
(-1.11) | 54.11
(-0.33) |
| GGUF Q3_K_M | 0.49 | 0.5798
(-0.0064) | 0.5520
(-0.0010) | 0.8710
(-0.0014) | 35.32
(-0.76) | 54.15
(-0.29) |
| GGUF Q2_K | 0.41 | 0.5620
(-0.0242) | 0.5397
(-0.0133) | 0.8659
(-0.0065) | 33.56
(-2.52) | 51.15
(-3.29) |
| MLX 4bit | 0.98 | 0.5773
(-0.0089) | 0.5476
(-0.0054) | 0.8724
(0.0000) | 35.82
(-0.26) | 54.41
(-0.03) |
### Choosing a Distribution Format
Each size of PLaMo 3 Translate is available in the following distribution formats, depending on your use case and hardware.
| Format | Target hardware | Inference engine | Typical use |
| --- | --- | --- | --- |
| **BF16** | GPUs with BF16 support | Transformers / vLLM | Prioritizes accuracy with no quantization, when memory allows |
| FP8 | NVIDIA Ada Lovelace / Hopper / Blackwell | vLLM | Balances accuracy with memory savings and speed |
| W4A16 | NVIDIA Ampere or later | vLLM | 4-bit weights to run with less GPU memory |
| W4AFP8 | NVIDIA Hopper | vLLM | 4-bit weights with FP8 compute, aiming at both low memory and high throughput |
| NVFP4 | NVIDIA Blackwell | vLLM | FP4 compute, aiming at low memory and high speed |
| GGUF | CPU / various GPUs | llama.cpp | Runs on a local PC, optionally combining CPU and GPU |
| MLX-4bit | Apple silicon | mlx-lm | Memory-efficient inference on a Mac |
## Usage
### Transformers
Download the model files and move into that directory. Run the following examples in this directory.
```bash
pip install -U huggingface_hub
hf download pfnet/plamo-3-translate-2b --local-dir plamo-3-translate-2b
cd plamo-3-translate-2b
```
Install the required packages.
```bash
pip install -U torch transformers accelerate numba
```
#### Translating a single text
A chat template is provided so you can try translation easily. Given the source text and the target language, it builds a prompt in the PFML3 format.
For production use, such as integrating the model into an application, we recommend building the prompt directly in the [PFML3 format](#pfml3-prompt-format) and passing it to the [vLLM Completions API](#translating-with-the-completions-api).
The following example translates Japanese into English.
```python
from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(".", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
".", trust_remote_code=True, dtype="bfloat16", device_map="auto",
)
inputs = tokenizer.apply_chat_template(
[{"role": "user", "content": "会議は来週の月曜日に変更されました。"}],
target_lang="en",
add_generation_prompt=True,
return_dict=True, return_tensors="pt",
).to(model.device)
output = model.generate(**inputs, do_sample=False, max_new_tokens=512)
text = tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(text)
```
`max_new_tokens` is the generation limit for the translation. This example sets it to 512 tokens. When translating long text, adjust the limit so that the whole input (source text, history, context, glossary and so on) plus the output fits within the limit of your runtime.
Example output:
> The meeting has been rescheduled for next Monday.
The example above does not specify the source language. When `source_lang` is omitted, the model detects the language from the source text. To specify it explicitly, pass `source_lang="ja"`, for example.
#### Translating multiple texts at once
Multiple texts can be translated in a batch by passing them to the chat template together. The following example uses the `model` and `tokenizer` loaded above to translate two texts into English.
```python
tokenizer.padding_side = "left"
texts = [
"会議は来週の月曜日に変更されました。",
"プロジェクトの管理画面を開いてください。",
]
messages = [[{"role": "user", "content": text}] for text in texts]
inputs = tokenizer.apply_chat_template(
messages,
target_lang="en",
add_generation_prompt=True,
padding=True,
return_dict=True, return_tensors="pt",
).to(model.device)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=512)
translations = tokenizer.batch_decode(
outputs[:, inputs["input_ids"].shape[1]:], skip_special_tokens=True,
)
for source, translation in zip(texts, translations):
print(f"{source} → {translation}")
```
The inputs are padded on the left to equalize their lengths, and only the generated translations are extracted. Translation options such as `target_lang` apply to every text in the batch in this example.
### Continuing a translation with previous translations
When translating a document paragraph by paragraph, you can pass the previous source–translation pairs as history. This lets the model follow the earlier word choices and style when translating the next passage.
With the chat template, alternate the source text as `user` and its translation as `assistant`, and put the current source text in the final `user` message. History is not stored automatically, so include the pairs you need in each request.
The translation direction is shared by the whole request: `source_lang` applies to every source text and `target_lang` to every translation.
History also counts toward the input tokens. Keep the whole input plus the generated translation within 32,768 tokens and within the limit of your runtime. As the history grows, we recommend dropping the oldest source–translation pairs first and keeping the most recent ones.
This example uses the `model` and `tokenizer` loaded above.
```python
messages = [
{"role": "user", "content": "プロジェクトの管理画面を開きます。"},
{"role": "assistant", "content": "Open the project dashboard."},
{"role": "user", "content": "進行中のタスクがすべて表示されます。"},
{"role": "assistant", "content": "It lists all active tasks."},
{"role": "user", "content": "オーナーでフィルタリングすることもできます。"},
]
inputs = tokenizer.apply_chat_template(
messages, source_lang="ja", target_lang="en",
add_generation_prompt=True,
return_dict=True, return_tensors="pt",
).to(model.device)
output = model.generate(**inputs, do_sample=False, max_new_tokens=512)
text = tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(text)
```
### PFML3 Prompt Format
PFML3 is PLaMo's prompt format, in which the text to translate, the target language and other elements are delimited by special tokens. In the Transformers examples above, the chat template converts the source text and target language into PFML3. This section explains how to read the converted prompt and how to write prompts by hand.
For production use, we recommend building the prompt directly in PFML3 and passing it to the [vLLM Completions API](#translating-with-the-completions-api).
Converting the Transformers example above into PFML3 gives the following. The beginning-of-sequence token is omitted here, and the Python string is split across lines for readability. The actual prompt contains no line breaks.
```python
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>input"
"<|plamo:msg|>会議は来週の月曜日に変更されました。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>"
)
```
- `translation` in `dataset` denotes the translation task. Because this model is dedicated to translation, always set `dataset` to `translation`.
- The part following `<|plamo:msg|>` in `input` is the source text to translate.
- `<|plamo:key|>lang<|plamo:val|>en` in `output` sets the target language to English. The translation is generated right after the final `<|plamo:msg|>`.
`<|plamo:tag|>` marks the start of each element, and `<|plamo:msg|>` marks the start of its body. To specify attributes such as the language or style, write the attribute name after `<|plamo:key|>` and its value after `<|plamo:val|>`, following the element name. For example, adding `<|plamo:key|>form<|plamo:val|>plain` to `output` requests plain style.
Context and a glossary are optional. To use them, add `context` and then `glossary`, in that order, between `dataset` and `input`. When translation history is also used, put `context` right after `dataset`, list the previous `input`/`output` pairs, and put `glossary` immediately before the current `input`. In the glossary, write a source term after `<|plamo:index|>` and its translation after `<|plamo:item|>`, repeating this pair for each term. See [Translation Options](#translation-options) for concrete examples.
#### Using a handwritten prompt
When writing PFML3 by hand, start by setting `dataset` to `translation` and end the `output` element with `<|plamo:msg|>`. After generating the translation, the model emits `<|plamo:tag|>` or `<|plamo:bos|>` and stops.
The handwritten examples above omit `<|plamo:bos|>`, which marks the beginning of the sequence. The Transformers tokenizer, llama.cpp and mlx-lm add the beginning-of-sequence token automatically. With the vLLM Completions API, specify `add_special_tokens=true`.
A string produced by the chat template already contains the beginning-of-sequence token. If you pass a string obtained with `tokenize=False` to the Transformers tokenizer, specify `add_special_tokens=False` to avoid adding it twice.
For example, to pass a handwritten prompt to Transformers, use the `model` and `tokenizer` from the Transformers example above.
```python
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
output = model.generate(**inputs, do_sample=False, max_new_tokens=512)
text = tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(text)
```
#### Specifying translation history in PFML3
Translation history can also be written in PFML3 by hand. List the already translated `input` and `output` elements in document order, then add the current source text followed by an `output` element with an empty body. In the following example, only the last sentence, "オーナーでフィルタリングすることもできます。", is translated, with reference to the two previous pairs.
```python
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>input<|plamo:key|>lang<|plamo:val|>ja<|plamo:msg|>プロジェクトの管理画面を開きます。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>Open the project dashboard."
"<|plamo:tag|>input<|plamo:key|>lang<|plamo:val|>ja<|plamo:msg|>進行中のタスクがすべて表示されます。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>It lists all active tasks."
"<|plamo:tag|>input<|plamo:key|>lang<|plamo:val|>ja<|plamo:msg|>オーナーでフィルタリングすることもできます。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>"
)
```
Run the example in "Using a handwritten prompt" above with `prompt` replaced by this string.
To continue translating, append the current source text and the generated translation to the history as a pair. Then add an `input` element containing the next source text and an `output` element with an empty body.
Keep only the body of each translation in the history. The translation returned by the example above can be used as is.
If `<|plamo:tag|>` or `<|plamo:bos|>` remains at the end of a translation, remove it so that exactly one `<|plamo:tag|>` separates it from the next `input`.
### Translation Options
Specify the target language, style, context, glossary and other options as arguments to `apply_chat_template()`, not in a `system` message or in the source text.
Run the Transformers example above with the part that builds `inputs` replaced by the following code.
| Argument | Description |
| --- | --- |
| `target_lang` | Language code of the target language. Required. |
| `source_lang` | Language code of the source text. Optional. |
| `context` | Reference context for interpreting the source text, such as the surrounding text or the situation. |
| `glossary` | A list of `{"source": "source term", "target": "translation"}` dictionaries, one per term. |
| `form` | `plain` for plain style or `polite` for polite style (only with `target_lang="ja"`). |
When combined with translation history, `context` is passed as reference context for the whole request, while `glossary` and `form` apply to the current translation. Previous translations themselves are not changed.
#### Specifying terms with a glossary
Pass pairs of source terms and their translations in `glossary` to control how the terms are translated.
```python
inputs = tokenizer.apply_chat_template(
[{"role": "user", "content": "プロジェクトの管理画面を開いてください。"}],
target_lang="en",
glossary=[
{"source": "管理画面", "target": "dashboard"},
{"source": "プロジェクト", "target": "project"},
],
add_generation_prompt=True,
return_dict=True, return_tensors="pt",
).to(model.device)
```
Example output:
> Please open the project dashboard.
PFML3 prompt for this example
```python
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>glossary"
"<|plamo:index|>管理画面<|plamo:item|>dashboard"
"<|plamo:index|>プロジェクト<|plamo:item|>project"
"<|plamo:tag|>input<|plamo:msg|>プロジェクトの管理画面を開いてください。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>"
)
```
#### Providing context
Use `context` to pass the surrounding text or to describe the situation. In this example, the source text かみを切りました。 is ambiguous because かみ can mean either hair or paper. The context says that the speaker is making origami, so it is translated as paper.
```python
inputs = tokenizer.apply_chat_template(
[{"role": "user", "content": "かみを切りました。"}],
target_lang="en",
context="工作で折り紙を作っています。",
add_generation_prompt=True,
return_dict=True, return_tensors="pt",
).to(model.device)
```
Example output:
> I cut the paper.
PFML3 prompt for this example
```python
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>context"
"<|plamo:msg|>工作で折り紙を作っています。"
"<|plamo:tag|>input<|plamo:msg|>かみを切りました。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>"
)
```
#### Specifying plain or polite style
When translating into Japanese, `form="plain"` requests the plain style (da/dearu) and `form="polite"` requests the polite style (desu/masu). Because `form` applies only to Japanese translations, this example translates English into Japanese.
```python
inputs = tokenizer.apply_chat_template(
[{"role": "user", "content": "This system is convenient."}],
target_lang="ja",
form="plain",
add_generation_prompt=True,
return_dict=True, return_tensors="pt",
).to(model.device)
```
Example outputs for the same source text:
| Style | Option | Translation |
| --- | --- | --- |
| Plain | `form="plain"` | このシステムは便利だ。 |
| Polite | `form="polite"` | このシステムは便利です。 |
PFML3 prompt for this example
Plain:
```python
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>input<|plamo:msg|>This system is convenient."
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>ja"
"<|plamo:key|>form<|plamo:val|>plain<|plamo:msg|>"
)
```
Polite:
```python
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>input<|plamo:msg|>This system is convenient."
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>ja"
"<|plamo:key|>form<|plamo:val|>polite<|plamo:msg|>"
)
```
#### Specifying all options at once
Translation history, context, a glossary and the style can be combined in one request. The following example translates the third sentence after two previous pairs, passing the page type as context and fixing the translation of オーナー with the glossary. `context` is passed as reference context for the whole request, and `glossary` applies to the current translation. When translating into Japanese, `form` can be added in the same way.
```python
inputs = tokenizer.apply_chat_template(
[
{"role": "user", "content": "プロジェクトの管理画面を開きます。"},
{"role": "assistant", "content": "Open the project dashboard."},
{"role": "user", "content": "進行中のタスクがすべて表示されます。"},
{"role": "assistant", "content": "It lists all active tasks."},
{"role": "user", "content": "オーナーでフィルタリングすることもできます。"},
],
source_lang="ja", target_lang="en",
context="プロジェクト管理ツールのヘルプページです。",
glossary=[{"source": "オーナー", "target": "assignee"}],
add_generation_prompt=True,
return_dict=True, return_tensors="pt",
).to(model.device)
```
Example output:
> You can also filter by assignee.
PFML3 prompt for this example
```python
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>context<|plamo:msg|>プロジェクト管理ツールのヘルプページです。"
"<|plamo:tag|>input<|plamo:key|>lang<|plamo:val|>ja<|plamo:msg|>プロジェクトの管理画面を開きます。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>Open the project dashboard."
"<|plamo:tag|>input<|plamo:key|>lang<|plamo:val|>ja<|plamo:msg|>進行中のタスクがすべて表示されます。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>It lists all active tasks."
"<|plamo:tag|>glossary<|plamo:index|>オーナー<|plamo:item|>assignee"
"<|plamo:tag|>input<|plamo:key|>lang<|plamo:val|>ja<|plamo:msg|>オーナーでフィルタリングすることもできます。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>"
)
```
### vLLM
#### Starting the server
Download the model files and move into that directory. Skip this step if you have already downloaded them by following the [Transformers](#transformers) instructions.
```bash
pip install -U huggingface_hub
hf download pfnet/plamo-3-translate-2b --local-dir plamo-3-translate-2b
cd plamo-3-translate-2b
```
Install the required packages and start the vLLM server.
```bash
pip install -U vllm openai numba
vllm serve . --trust-remote-code \
--served-model-name plamo-3-translate \
--max-model-len 16384 --max-num-seqs 4
```
This example sets the maximum combined length of the input and output to 16,384 tokens. Adjust it to fit the available GPU memory as needed.
#### Translating with the Chat Completions API
With the Chat Completions API, put the current source text in the last `user` message and pass the translation options in `chat_template_kwargs`.
```bash
curl http://localhost:8000/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{
"model": "plamo-3-translate",
"messages": [{"role": "user", "content": "こんにちは。"}],
"chat_template_kwargs": {"source_lang": "ja", "target_lang": "en"},
"temperature": 0,
"max_tokens": 512,
"stop": ["<|plamo:tag|>", "<|plamo:bos|>"]
}'
```
`max_tokens` is the generation limit for the translation. This example sets it to 512 tokens. When translating long text, adjust the limit so that the whole input (source text, history, context, glossary and so on) plus the output fits within the limit of your runtime.
The translation is returned in `choices[0].message.content`.
**Translating multiple texts at once**
To translate multiple texts, send one request per text and run the requests in parallel. vLLM batches the requests it receives.
```python
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
texts = [
"会議は来週の月曜日に変更されました。",
"プロジェクトの管理画面を開いてください。",
]
def translate(text):
response = client.chat.completions.create(
model="plamo-3-translate",
messages=[{"role": "user", "content": text}],
temperature=0,
max_tokens=512,
stop=["<|plamo:tag|>", "<|plamo:bos|>"],
extra_body={"chat_template_kwargs": {"target_lang": "en"}},
)
return response.choices[0].message.content
with ThreadPoolExecutor(max_workers=4) as executor:
translations = list(executor.map(translate, texts))
for source, translation in zip(texts, translations):
print(f"{source} → {translation}")
```
**Translating with history via the Chat Completions API**
Pass the already translated source–translation pairs as `user`/`assistant` pairs. Only the last `user` message is translated.
```python
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
messages = [
{"role": "user", "content": "プロジェクトの管理画面を開きます。"},
{"role": "assistant", "content": "Open the project dashboard."},
{"role": "user", "content": "進行中のタスクがすべて表示されます。"},
{"role": "assistant", "content": "It lists all active tasks."},
{"role": "user", "content": "オーナーでフィルタリングすることもできます。"},
]
response = client.chat.completions.create(
model="plamo-3-translate",
messages=messages,
temperature=0,
max_tokens=512,
stop=["<|plamo:tag|>", "<|plamo:bos|>"],
extra_body={"chat_template_kwargs": {"source_lang": "ja", "target_lang": "en"}},
)
print(response.choices[0].message.content)
```
#### Translating with the Completions API
Pass one of the PFML3 prompts shown in the translation examples as `prompt`.
```python
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>input"
"<|plamo:msg|>会議は来週の月曜日に変更されました。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>"
)
response = client.completions.create(
model="plamo-3-translate",
prompt=prompt,
temperature=0,
max_tokens=512,
stop=["<|plamo:tag|>", "<|plamo:bos|>"],
extra_body={"add_special_tokens": True},
)
print(response.choices[0].text)
```
The translation is returned in `choices[0].text`.
**Translating multiple texts at once**
When using PFML3 prompts directly, you can likewise send one request per text in parallel.
```python
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
texts = [
"会議は来週の月曜日に変更されました。",
"プロジェクトの管理画面を開いてください。",
]
def translate(text):
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>input<|plamo:msg|>"
f"{text}"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>"
)
response = client.completions.create(
model="plamo-3-translate",
prompt=prompt,
temperature=0,
max_tokens=512,
stop=["<|plamo:tag|>", "<|plamo:bos|>"],
extra_body={"add_special_tokens": True},
)
return response.choices[0].text
with ThreadPoolExecutor(max_workers=4) as executor:
translations = list(executor.map(translate, texts))
for source, translation in zip(texts, translations):
print(f"{source} → {translation}")
```
**Continuing a translation with history**
Translation with [history](#continuing-a-translation-with-previous-translations) also works with the Completions API. Pass a PFML3 prompt that includes the already translated source–translation pairs, and the translation of the last source text is returned.
```python
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
prompt = (
"<|plamo:tag|>dataset<|plamo:msg|>translation"
"<|plamo:tag|>input<|plamo:key|>lang<|plamo:val|>ja<|plamo:msg|>プロジェクトの管理画面を開きます。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>Open the project dashboard."
"<|plamo:tag|>input<|plamo:key|>lang<|plamo:val|>ja<|plamo:msg|>進行中のタスクがすべて表示されます。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>It lists all active tasks."
"<|plamo:tag|>input<|plamo:key|>lang<|plamo:val|>ja<|plamo:msg|>オーナーでフィルタリングすることもできます。"
"<|plamo:tag|>output<|plamo:key|>lang<|plamo:val|>en<|plamo:msg|>"
)
response = client.completions.create(
model="plamo-3-translate",
prompt=prompt,
temperature=0,
max_tokens=512,
stop=["<|plamo:tag|>", "<|plamo:bos|>"],
extra_body={"add_special_tokens": True},
)
print(response.choices[0].text)
```
## Supported Languages
53 languages are supported, including Japanese and English. Simplified and Traditional Chinese are counted as separate languages. Because Hugging Face groups Chinese as a single language in its language display, the model page shows 52 languages.
Supported languages and language codes
| Language | Code | Language | Code |
|---|---|---|---|
| Japanese | `ja` | English | `en` |
| Chinese (Simplified) | `zh-hans` | Chinese (Traditional) | `zh-hant` |
| Korean | `ko` | Arabic | `ar` |
| Azerbaijani | `az` | Belarusian | `be` |
| Bulgarian | `bg` | Bengali | `bn` |
| Catalan | `ca` | Cebuano | `ceb` |
| German | `de` | Spanish | `es` |
| Estonian | `et` | Basque | `eu` |
| Persian | `fa` | French | `fr` |
| Gujarati | `gu` | Hebrew | `he` |
| Hindi | `hi` | Croatian | `hr` |
| Hungarian | `hu` | Armenian | `hy` |
| Indonesian | `id` | Italian | `it` |
| Javanese | `jv` | Georgian | `ka` |
| Kazakh | `kk` | Khmer | `km` |
| Lithuanian | `lt` | Latvian | `lv` |
| Malayalam | `ml` | Marathi | `mr` |
| Malay | `ms` | Burmese | `my` |
| Nepali | `ne` | Dutch | `nl` |
| Punjabi | `pa` | Polish | `pl` |
| Russian | `ru` | Sinhala | `si` |
| Slovak | `sk` | Slovenian | `sl` |
| Serbian | `sr` | Swahili | `sw` |
| Tamil | `ta` | Telugu | `te` |
| Thai | `th` | Tagalog | `tl` |
| Urdu | `ur` | Uzbek | `uz` |
| Vietnamese | `vi` | | |
## License
PLaMo 3 Translate 2B is released under the [PLaMo Community License](https://plamo.preferredai.jp/info/plamo-community-license-en).
- [English](https://plamo.preferredai.jp/info/plamo-community-license-en)
- [Japanese](https://plamo.preferredai.jp/info/plamo-community-license-ja)
**Personal and non-commercial use**
For personal use, such as learning or hobby projects, you can download and use the model free of charge. Non-commercial use, including academic use, is also free, with no restriction based on revenue or sales and no prior registration with PFN.
**Commercial use when revenue or sales is 1 billion yen or less**
If the revenue or sales of the user or its affiliates in the most recent fiscal year is 1 billion yen or less, register your intended use through the [PLaMo Commercial Use Registration Form](https://forms.gle/mTL8tBLrMYXKNZD56). Commercial use is free of charge from the moment you submit the form.
**Commercial use when revenue or sales exceeds 1 billion yen**
A separate license agreement is required. Instead of the registration form above, please contact PFN through the [PLaMo Translation Model inquiry page](https://translate.preferredai.jp/llm/contact/).
See the full text of the PLaMo Community License for details.
## Preferred Networks Group AI Policy
- [日本語](https://www.preferred.jp/ja/company/aipolicy/)
- [English](https://www.preferred.jp/en/company/aipolicy/)