Instructions to use PoSTMEDIA/Rosetta-7B-Think with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use PoSTMEDIA/Rosetta-7B-Think with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="PoSTMEDIA/Rosetta-7B-Think", trust_remote_code=True)
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("PoSTMEDIA/Rosetta-7B-Think", trust_remote_code=True, device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use PoSTMEDIA/Rosetta-7B-Think with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "PoSTMEDIA/Rosetta-7B-Think"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "PoSTMEDIA/Rosetta-7B-Think",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/PoSTMEDIA/Rosetta-7B-Think

SGLang

How to use PoSTMEDIA/Rosetta-7B-Think with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "PoSTMEDIA/Rosetta-7B-Think" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "PoSTMEDIA/Rosetta-7B-Think",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "PoSTMEDIA/Rosetta-7B-Think" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "PoSTMEDIA/Rosetta-7B-Think",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use PoSTMEDIA/Rosetta-7B-Think with Docker Model Runner:
```
docker model run hf.co/PoSTMEDIA/Rosetta-7B-Think
```

Rosetta-7B-Think

Introduction

Rosetta-7B-Think is a 7B-parameter bilingual (Korean-English) reasoning model developed by PoSTMEDIA. Built on PoSTMEDIA's Rosetta dense decoder-only architecture and post-trained from Rosetta-7B-Base with reasoning-focused SFT and preference optimization, it generates an explicit reasoning trace wrapped in <think> ... </think> before committing to a final answer.

Where most compact reasoning models concentrate their gains in English math, Rosetta-7B-Think was trained to reason in and about Korean: under our unified protocol it surpasses Qwen3-8B on Korean math reasoning (HRM8K) and Korean comprehension (HAE-RAE) — while critically, unlike several global reasoning models, it reliably terminates its reasoning on Korean inputs.

Model	Download	Note
Rosetta-7B-Base	HuggingFace	Foundation model (completion-style)
Rosetta-7B-Instruct	HuggingFace	Instruction following / chat
Rosetta-7B-Think	HuggingFace	Explicit reasoning (`<think>`) (this model)

Highlights

Explicit reasoning — structured <think> traces with reliable termination in both Korean and English
Korean math reasoning — HRM8K 64.8, above Qwen3-8B under the identical protocol
Korean comprehension — HAE-RAE 67.1, best in its comparison class
Competition math from a 7B — AIME24/25 33.3, a large step up from same-size non-reasoning models
65,536-token context window — headroom for long reasoning traces
Apache-2.0 — unrestricted commercial use

Model Summary

Architecture	Rosetta dense decoder-only Transformer (`RosettaForCausalLM`)
Parameters	7B
Layers	32
Hidden size	4,096
Attention heads	32
Attention pattern	interleaved sliding-window (4,096) + global, 3:1, with QK-normalization
Context length	65,536
Vocabulary	161,425 (Korean-extended)
Post-training	reasoning SFT → preference optimization (DPO)
Reasoning format	`<think> ... </think>` + final answer
License	Apache-2.0

Training Overview

Pretraining on trillions of tokens of curated bilingual web, code, and academic text
Staged mid-training for reasoning-dense data and long-context extension up to 65K
Korean continual pretraining on curated Korean corpora plus in-house synthetic Korean data assets (161K extended vocabulary)
Reasoning post-training — SFT on long-form reasoning traces across math, code, science, and Korean-language tasks, followed by preference optimization (DPO)

Evaluation Results

All models in the table below, including competitors, were re-evaluated in-house under an identical protocol (lm-evaluation-harness + vLLM ≥ 0.26). Reasoning models are sampled at temperature 0.6, top-p 0.95; competition-math scores are the average of 8 runs.

Benchmark	Rosetta-7B-Think ^7B	Qwen3-8B ^8B	DeepSeek-R1-0528 ^8B	HyperCLOVAX-Think ^14B
Reasoning & Mathematics
MMLU (0-shot CoT)	68.1	79.5	80.4	77.7
GSM8K	69.2	90.1	88.2	79.2
AIME 2024^‡	33.3	70.0	66.7	46.7
AIME 2025^‡	33.3	66.7	70.0	43.3
Korean Language & Knowledge
KMMLU	50.5	58.8	21.9^§	54.7
CLIcK	54.8	63.8	19.8^§	69.9
HAE-RAE	67.1	60.0	20.9^§	81.3
HRM8K	64.8	62.3	17.4^§	54.4
KoSimpleQA^†	43.4	74.2	10.4^§	57.5

_{Bold indicates the best score in each row. ^† KoSimpleQA is evaluated as a judge-free 10-choice MCQA variant. ^‡ Average of 8 sampled runs. ^§ DeepSeek-R1-0528-Qwen3-8B frequently fails to terminate its reasoning within the 32K generation budget on Korean inputs, which dominates its Korean-benchmark scores under this protocol.}

Rosetta-7B-Think holds the top score on Korean mathematical reasoning (HRM8K) in this comparison and beats Qwen3-8B on Korean comprehension (HAE-RAE), while being the smallest model in the table. Just as importantly, it terminates its reasoning reliably on Korean inputs — a failure mode that collapses the Korean scores of some global reasoning models under identical budgets.

Quickstart

Transformers

Requires transformers>=5.13 and trust_remote_code=True.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "PoSTMEDIA/Rosetta-7B-Think"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id, dtype="bfloat16", device_map="auto", trust_remote_code=True
)

messages = [{"role": "user", "content": "127 × 43은 얼마인가요? 단계적으로 풀어주세요."}]
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True, return_tensors="pt"
).to(model.device)
out = model.generate(inputs, max_new_tokens=4096, temperature=0.6, top_p=0.95, do_sample=True)
text = tokenizer.decode(out[0][inputs.shape[1]:], skip_special_tokens=True)

# Split the reasoning trace from the final answer
if "</think>" in text:
    reasoning, answer = text.split("</think>", 1)
    reasoning = reasoning.replace("<think>", "").strip()
else:
    reasoning, answer = "", text
print("REASONING:", reasoning[:500])
print("ANSWER:", answer.strip())

vLLM

Use the PoSTMEDIA vLLM distribution — native Rosetta support and a built-in reasoning parser:

VLLM_USE_PRECOMPILED=1 pip install git+https://github.com/PoSTMEDIA-AI/vllm@rosetta-v0.26.0

vllm serve PoSTMEDIA/Rosetta-7B-Think \
  --dtype bfloat16 \
  --reasoning-parser rosetta

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
resp = client.chat.completions.create(
    model="PoSTMEDIA/Rosetta-7B-Think",
    messages=[{"role": "user", "content": "소수가 무한히 많음을 증명해줘."}],
    temperature=0.6,
    top_p=0.95,
)
print("REASONING:", resp.choices[0].message.reasoning)
print("ANSWER:", resp.choices[0].message.content)

vLLM v0.26 or later is required. Recommended sampling: temperature 0.6, top_p 0.95. Allow a generous max_tokens (≥ 4,096; 32,768 for competition math) so reasoning traces can complete.

Limitations

Reasoning traces increase latency and token usage; budget max_tokens accordingly.
The model can generate factually incorrect content inside fluent reasoning; verify high-stakes outputs.
Optimized for Korean and English; other languages are not guaranteed.
Alignment was performed on contexts up to 32K tokens; validate quality for longer inputs.

License

Apache License 2.0 — see LICENSE. If you build something with Rosetta, we'd appreciate a "Built with Rosetta" attribution.

Citation

@misc{rosetta2026,
  title  = {Rosetta-7B: A Bilingual Korean-English Language Model Family},
  author = {{PoSTMEDIA AI Lab}},
  year   = {2026},
  url    = {https://huggingface.co/collections/PoSTMEDIA/rosetta-6a9db30fd1b4585b0c1845e9}
}

Contact

Questions and feedback — please open a discussion on the model page.

Downloads last month: 504

Safetensors

Model size

8B params

Tensor type

BF16

Model tree for PoSTMEDIA/Rosetta-7B-Think

Base model

PoSTMEDIA/Rosetta-7B-Base

Finetuned

(2)

this model

Collection including PoSTMEDIA/Rosetta-7B-Think

Rosetta

Collection

Rosetta-7B: PoSTMEDIA's Korean-English 7B language model family — Base, Instruct, and Think (reasoning). • 3 items • Updated 1 day ago