Instructions to use aoiandroid/neutts-jp-150m-float16 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use aoiandroid/neutts-jp-150m-float16 with Transformers:

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

pipe = pipeline("text-generation", model="aoiandroid/neutts-jp-150m-float16")

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("aoiandroid/neutts-jp-150m-float16")
model = AutoModelForCausalLM.from_pretrained("aoiandroid/neutts-jp-150m-float16", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use aoiandroid/neutts-jp-150m-float16 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "aoiandroid/neutts-jp-150m-float16"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "aoiandroid/neutts-jp-150m-float16",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/aoiandroid/neutts-jp-150m-float16

SGLang

How to use aoiandroid/neutts-jp-150m-float16 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 "aoiandroid/neutts-jp-150m-float16" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "aoiandroid/neutts-jp-150m-float16",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

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 "aoiandroid/neutts-jp-150m-float16" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "aoiandroid/neutts-jp-150m-float16",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use aoiandroid/neutts-jp-150m-float16 with Docker Model Runner:
```
docker model run hf.co/aoiandroid/neutts-jp-150m-float16
```

neuTTS-JP-150M (float16, pre-ONNX)

Japanese neuTTS-JP-150M weights in PyTorch / Hugging Face format (safetensors), float16, before ONNX export.
This checkpoint was produced by loading aoiandroid/neuTTS-JP-150m in FP16 and saving with save_pretrained (see dtype: float16 in config.json).

For ONNX or other runtimes, convert from this repo or use a separate ONNX/GGUF release if published.

Model summary

Item	Value
Architecture	`LlamaForCausalLM` (`model_type: llama`)
Weight dtype	float16 (`config.json` → `dtype`)
Hidden size	512
Layers	12
Attention heads	8
KV heads	8
Intermediate (FFN)	2048
Max position embeddings	4096
Vocab size	99111
Tokenizer	Custom `LlmJpTtsTokenizer` (`trust_remote_code=True`)

Repository structure

All files live at the repository root (flat layout):

aoiandroid/neutts-jp-150m-float16/
├── README.md                    # Model card (this file)
├── .gitattributes               # Managed by Hugging Face Hub / Git LFS rules
├── config.json                  # Transformers model config (FP16, Llama-style)
├── generation_config.json       # Default generation settings
├── model.safetensors            # Model weights (float16)
├── tokenizer_config.json        # Tokenizer metadata + auto_map for custom class
├── tokenizer.json               # Tokenizer vocabulary / merges
├── special_tokens_map.json      # Special token id ↔ string mapping
└── tokenization_llm_jp_tts.py   # Custom tokenizer implementation (remote code)

File	Role
`model.safetensors`	Serialized FP16 weights
`config.json`	Architecture, `dtype`, RoPE, etc.
`tokenization_llm_jp_tts.py`	Required for `AutoTokenizer`; use `trust_remote_code=True`
`tokenizer.json` + `tokenizer_config.json` + `special_tokens_map.json`	Tokenizer assets

Usage (Transformers)

Requires trust_remote_code=True for the tokenizer because of tokenization_llm_jp_tts.py.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "aoiandroid/neutts-jp-150m-float16"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",
)

Full text-to-speech pipelines may depend on additional neuTTS inference code (codec, features, etc.) beyond this causal LM export. This repo documents the pre-ONNX FP16 Hub snapshot only.

Upstream and lineage

Base (FP32 Hub): aoiandroid/neuTTS-JP-150m
This repo: FP16 save_pretrained export for smaller disk footprint and faster load on FP16-capable devices.

Citation

If you use this model, cite the original neuTTS / neuTTS-JP work and model card from the upstream repository as applicable.

License

See the license and terms on aoiandroid/neuTTS-JP-150m and any bundled LICENSE there. This derivative does not change upstream licensing unless stated otherwise on the upstream model card.