plamo-3-610m-fin-instruct Text Generation Model: 4GB+ VRAM

September 24, 2026November 8, 2026

At a Glance

Item	Value
Repository	pfnet/plamo-3-610m-fin-instruct
Family guide	plamo-3-fin guide (1 articles)
Publisher guide	Preferred Networks (PFN): models and licenses
Published	2026-09-24
License	plamo-community-license
Formats	safetensors
Source type	Primary source (the publisher itself)

Values determined by this site’s code when the information was collected. Dates are JST.

Overview

Preferred Networks (PFN) has released “PLaMo-3-610M-Fin-Instruct," a lightweight Japanese language model specialized in the financial domain.

This model is built upon the base PLaMo-3 model developed by PFN, with continued pre-training using financial corpora, followed by Supervised Fine-Tuning (SFT) and Direct Preference Optimization (DPO) to create a small instruction-tuned model. The chat format of PLaMo-3 is adopted for dialogues, featuring a format where thought blocks indicating the reasoning process are output enclosed in “ before presenting the final answer.

This model is developed for application to specific tasks and text processing in the financial domain, and is provided for engineers who want to run and evaluate a finance-focused Japanese model in resource-constrained local environments or on-premise infrastructure.

Specifications

Architecture: Causal decoder-only
Context length: 262,144 tokens
Supported languages: Japanese
Tensor format: BF16

Performance

The model card and evaluation data on Hugging Face do not include quantitative benchmark measurement results (comparison tables or measured score data). Therefore, it is not possible to make numerical performance comparisons with other standard models, but the publisher, Preferred Networks, provides detailed qualitative performance evaluations and operational characteristics and limitations within the model card.

The key points of the qualitative evaluation reported by the publisher are as follows:

Domain-Specific Performance and Use Case Limitations

This model has been additionally trained focusing exclusively on financial domain data and directly targets financial domain use cases. Since it is not designed as an assistant model requiring general everyday conversation or broad knowledge, evaluation using your own tasks and datasets in advance is recommended when using it in non-financial domains.

Impact and Hallucinations Due to Model Size

Because it is a model with a small parameter size, the absolute amount of factual knowledge it retains is smaller compared to large-scale models. As a result, there is a tendency for hallucinations to occur, generating information that differs from facts while remaining fluent in context. Descriptions of facts and numerical figures (such as indicators and financial data) generated by the model must always be verified against reliable primary sources. Additionally, when using the model’s output for important decision-making, operations must always include human verification (Human-in-the-loop).

Safety Alignment and Considerations for Professional Advice

Due to its small model size, the reliability of safety alignment (suppressing the generation of harmful expressions) may be lower compared to large-scale models. Therefore, when integrating it into actual applications, it is necessary to appropriately apply content filtering mechanisms that block inappropriate expressions and harmful outputs.

Furthermore, the output results of this model do not constitute professional advice regarding law, finance, taxation, investment, etc., and presenting them as such to end-users is strictly prohibited. It is explicitly stated that application to automated systems that make investment decisions on behalf of users should also be avoided.

Strengths and Use Cases

PLaMo-3-610M-Fin-Instruct is a model developed specifically for Japanese text processing and dialogue tasks in the financial domain. By applying continued pre-training using financial corpora to the PLaMo-3 base model developed by Preferred Networks (PFN), followed by Supervised Fine-Tuning (SFT) and Direct Preference Optimization (DPO), it is adjusted to handle specialized dialogues in the financial field.

The model’s main strengths and expected use cases are as follows:

Financial Text Understanding and Dialogue

It is suitable for text generation and question-answering that take financial terms and context into account. For example, it is expected to be applied to explaining financial terms and dialogue tasks following specific scenarios in the financial domain.

Answer Generation with Thought Processes

This model adopts the PLaMo-3 chat format. For user inputs, it first outputs the reasoning process enclosed in “ tags, followed by the final answer. This makes it easier for developers and users to check through what kind of inference the model arrived at the answer.

Space-Saving Verification and Integration

Because it is a lightweight model with a small number of parameters, it is suitable for rapid prototyping in resource-limited local environments, edge devices, or corporate servers, as well as for the development and verification of lightweight inference engines specialized in the financial field.

However, this model is specialized for the financial domain, not a general-purpose assistant. When using it in areas other than finance, it is necessary to evaluate it with your own tasks in advance. Furthermore, use for the purpose of automating specialized investment decisions or legal and tax advice is prohibited, and human intervention is always required for fact-checking output results.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch) — 890M parameters

Your VRAM	Quantization	File size	Est. memory needed
4GB (laptop iGPU / phone class)	F16	1.7GB	2.0GB

Inference engine support (architecture name matched against each project’s own model registry in its source code, checked 2026-11-08): llama.cpp: registered, vLLM: registered, MLX (mlx-lm): registered.

Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. File sizes are measured from the converted build mradermacher/plamo-3-610m-fin-instruct-GGUF. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.

Can You Run It Locally?

Runs in Ollama, LM Studio and llama.cpp via a converted build.

The publisher ships safetensors, but mradermacher/plamo-3-610m-fin-instruct-GGUF provides a GGUF build you can use.

License — plamo-community-license: A custom license from the publisher. Check the original terms directly, including whether commercial use is permitted.

Compiled by this site’s code from the published formats, converted builds we have found, and each engine’s own model registry. “Not found" means we have not seen such a build, not that none exists. License summaries are not legal advice — check the publisher’s original terms before relying on them.

Our Own Measurements

Values we checked ourselves on our server (no GPU) by actually reading this model’s files, without running the model — not figures copied from the model card. How we measure, and the results for every model: Our Measurements.

Measurements We Did Not Take

We have not confirmed that this site meets the commercial-use terms of this model’s license (plamo-community-license). Because this site carries advertising, we did not run the model (no CPU run, answers, quantization comparison, conversion or generation). Only values we checked without running the model, such as token counts and the GGUF header, are shown.

Inside the GGUF File

File: plamo-3-610m-fin-instruct.Q4_K_M.gguf (0.53GB, Q4_K_M). We read only the header (metadata) of the file, not the weights.

Item	Value
Architecture (as named in the GGUF)	`plamo3`
Maximum trained context length	262,144 tokens
Layers	16
Vocabulary size	107,520
Chat template	Included (mentions tool calls, has a thinking switch)
imatrix	Not recorded in the file
Weight types (share of parameters)	Q4_K 69.8% / Q6_K 30.2% / F32 0.0%
Average bits per weight	5.13 bits
Embedding / output layer type	Q4_K / Q6_K

The quant name in the file name describes the file as a whole; in practice layers mix several types. The average bits per weight is the measured file data divided by the number of weights.

Recent Models in the Same Size Class

Models with up to 4B parameters that Local Model Watch covered recently, listed by code from our article log for comparison. VRAM tiers are this site’s estimates; licenses are as stated on the model cards.

→ Scroll horizontally to see all columns

Model	Parameters	Smallest VRAM tier	License	Our article
LiquidAI/LFM2.5-350M-Diffusion-Exp	425M	4GB	lfm1.0	LFM2.5-350M-Diffusion-Exp Text Generation Model: 4GB+ VRAM (2026-10-03)
togethercomputer/Tev1-0.8B-experimental	873M	4GB	—	Tev1-0.8B-experimental Text Generation Model: 4GB+ VRAM (2026-09-25)
harshatheg/Qwen-2.5-1B-RLCD	1.5B	4GB	apache-2.0	Qwen-2.5-1B-RLCD Text Generation Model: 4GB+ VRAM (2026-09-16)
tencent/Simple-Attention-Sparsification	4.0B	12GB	—	Simple-Attention-Sparsification Text Generation Model: 12GB+ VRAM (2026-09-14)
openbmb/MiniCPM5-2B	2.5B	4GB	apache-2.0	MiniCPM5-2B Text Generation Model: Our Test Answers, 4GB+ VRAM (2026-09-07)

How to Get It

PLaMo-3-610M-Fin-Instruct is available in safetensors format from the Hugging Face repository. To use this model, you must agree to the proprietary “PLaMo community license."

The system requirements and library versions specified to run it are as follows:

Python 3.10.0 or higher
numpy 1.26.4 or higher
numba 0.60.0 or higher
torch 2.6.0 or higher, 2.9.0 or lower
transformers 5.0.0 or higher
accelerate

An example code for directly loading the model using Python’s transformers library and running inference is shown below. trust_remote_code=True must be specified upon loading.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "pfnet/plamo-3-610m-fin-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name, trust_remote_code=True, dtype=torch.bfloat16, device_map="auto"
)

messages = [
    {"role": "user", "content": "PERとは何ですか?一文で答えて。"},
]
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True, return_dict=True, return_tensors="pt"
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512, do_sample=False)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

When this code is executed, the model outputs the reasoning block enclosed in `, followed by the answer to the user's question, and finally terminates the output with<|im_end|>`.

Quantized and Converted Variants