Style-Bert-VITS2 JVNV — Karume

What is this

A Japanese text-to-speech distribution: Style-Bert-VITS2 JP-Extra voices converted into the WebGPU inference runtime Karume's container format (a single safetensors file = weights + a graph JSON embedded in __metadata__). Runs as-is in the browser and in Deno.

The acoustic chain is shipped as fused graphs: text_encoder (a Japanese DeBERTa), front (phoneme encoder + duration predictors) and voice (flow + HiFi-GAN decoder).
Style and speaker are looked up at run time from the shipped tables — the names in the tables below index the rows of style_vectors / speaker_embeddings.
Not readable by Style-Bert-VITS2 (it's a different container with an embedded graph); the reader is a pipeline that implements sbv2/1.
Exporter used for the conversion: karume/0.5.0. The distribution manifest is karume.json (karume/4).

Base weights and attribution

Converted into the container format — the original checkpoints are not distributed here.

Voices: jvnv-F1-jp/ / jvnv-F2-jp/ / jvnv-M1-jp/ / jvnv-M2-jp/ of litagin/style_bert_vits2_jvnv
Architecture: Style-Bert-VITS2 JP-Extra (version: 2.0-JP-Extra)
Terms: CC BY-SA 4.0, inherited from the JVNV corpus the voices were trained on — the source repository states the corpus license carries over to the models. Redistribution here keeps it: credit the authors, name the source and the license URL, state that the weights were converted to another format and quantized to i8 (i4 for the group-quantized weights), license any derivative work under CC BY-SA 4.0 as well, and impose no further restrictions. There is no NonCommercial and no NoDerivatives clause — commercial use and modification are both allowed.
Changes made here: conversion into the Karume container format and quantization of the weights — the voices in f16 / i8 / mixed, the text encoder in i8 / mixed, where the mixed form stores the group-quantizable weights as i4 and everything else as i8 (the quant table below says which storage each quant selects). No retraining, no fine-tuning — the voices are the source checkpoints in a different storage form.
Text encoder: ku-nlp/deberta-v2-large-japanese-char-wwm, licensed cc-by-sa-4.0 (as of retrieval). It is redistributed here in the container format as the text_encoder component — the same license as the voices, so the share-alike term is consistent across everything in this repository.
Training data: the JVNV corpus, licensed CC BY-SA 4.0. Detai Xin, Junfeng Jiang, Shinnosuke Takamichi, Yuki Saito, Akiko Aizawa, Hiroshi Saruwatari, JVNV: A Corpus of Japanese Emotional Speech with Verbal Content and Nonverbal Expressions, arXiv:2310.06072. Corpus page: https://sites.google.com/site/shinnosuketakamichi/research-topics/jvnv_corpus
Training implementation: Style-Bert-VITS2 (AGPL-3.0). Karume's runtime contains none of that code: it is an independent implementation that reads these weights from its own container format, so the AGPL terms govern the training implementation, not the runtime that plays these files.

Models

Model	Pipeline	Quants	Default quant
`F1` (default)	`sbv2/1`	`f16+bert8` / `i8` / `i8-a8` / `i8+bert4` / `i4`	`i8+bert4`
`F2`	`sbv2/1`	`f16+bert8` / `i8` / `i8-a8` / `i8+bert4` / `i4`	`i8+bert4`
`M1`	`sbv2/1`	`f16+bert8` / `i8` / `i8-a8` / `i8+bert4` / `i4`	`i8+bert4`
`M2`	`sbv2/1`	`f16+bert8` / `i8` / `i8-a8` / `i8+bert4` / `i4`	`i8+bert4`

model selects one of these; omitted, it is F1. quant defaults to that model's own default quant.

Usage

import { encodeWav, Sbv2Pipeline } from "jsr:@karume/models";

using pipeline = await Sbv2Pipeline.fromPretrained({
  repo: "hdae/karume-sbv2-jvnv",
  // Pin a commit for reproducible builds — without it you track `main`, and a future
  // repo update (renamed files, new manifest format) may break your app.
  // Copy the full hash from this repo's "Files and versions" tab:
  // revision: "<full commit sha>",
}, {
  // model: "F1", // default — available: F1 / F2 / M1 / M2
  // quant: "i8+bert4", // default — available: f16+bert8 / i4 / i8 / i8+bert4 / i8-a8
});

const audio = await pipeline.generate({
  text: "こんにちは、これはテストです。",

  // Voice — the names below come from the tables further down; every model in
  // this repository brings its own set:
  // style: "Neutral", // default — available: Angry / Disgust / Fear / Happy / Neutral / Sad / Surprise
  // styleWeight: 1.0, // default — 0 = the average style, 1 = the named one
  // speaker: "jvnv-F1-jp", // default — available: jvnv-F1-jp

  // Delivery:
  // lengthScale: 1.0, // default — larger is slower
  // sdpRatio: 0.2, // default — 1 = stochastic duration, 0 = deterministic
  // noiseScale: 0.6, // default — sampling noise on z_p
  // noiseScaleW: 0.8, // default — sampling noise inside the stochastic predictor

  seed: 42, // same seed + same knobs → same waveform
});
await Deno.writeFile("sbv2.wav", encodeWav(audio.data, audio.sampleRate));

generate() returns { sampleRate, data }, where data is an f32 mono waveform — exactly what encodeWav takes. Weights are fetched once and cached (verified against karume.json's size / sha256). You can also build from bytes you fetched yourself (Sbv2Pipeline.fromAssets).

The Japanese analyzer dictionary the text front-end needs is not part of this repository: the pipeline fetches it on the first generate() and keeps it for the rest of the instance's life (pass your own through the dictionary option to skip the fetch).

Model: F1

Files

Key	Dtype	Path	Size	sha256
`text_encoder`	i8	`shared/text_encoder/model.i8.safetensors`	292.84 MiB (307,068,768 B)	`cc3d87f336389f5e…`
`text_encoder`	i4	`shared/text_encoder/model.i4.safetensors`	184.93 MiB (193,911,592 B)	`1425e397c96f4174…`
`front`	f16	`F1/front/model.f16.safetensors`	17.12 MiB (17,954,836 B)	`b6fc72cbab1af5bf…`
`front`	i8	`F1/front/model.i8.safetensors`	9.85 MiB (10,324,816 B)	`ed989f8c3053d41d…`
`front`	i4	`F1/front/model.i4.safetensors`	7.04 MiB (7,381,496 B)	`47acc445af6252a5…`
`voice`	f16	`F1/voice/model.f16.safetensors`	104.30 MiB (109,363,444 B)	`05dde98e8f93ca49…`
`voice`	i8	`F1/voice/model.i8.safetensors`	52.95 MiB (55,516,968 B)	`c6db5b1a817ac09f…`
`voice`	i4	`F1/voice/model.i4.safetensors`	34.37 MiB (36,039,208 B)	`e3f1522b0e04f827…`
`tokenizer`	—	`shared/tokenizer/deberta-tokenizer.json`	119.17 KiB (122,035 B)	`8705372d7c85d55e…`
`symbols`	—	`shared/text/symbols.json`	1.60 KiB (1,642 B)	`6d61307808256836…`
`style_vectors`	—	`F1/styles/style_vectors.safetensors`	7.09 KiB (7,256 B)	`eb1c16769e61375a…`
`speaker_embeddings`	—	`F1/speakers/speaker_embeddings.safetensors`	2.09 KiB (2,136 B)	`a57c5add00e06343…`

Only the first 16 hex digits of the sha256 are shown (the full value and size live in karume.json — verify against that at the fetch layer). Dtype labels use the runtime's storage dtype vocabulary (f16 / i8 / i4), not the fp16 spelling common elsewhere in the ecosystem. A path under shared/ is one this model shares byte for byte with another model in this repository (it is fetched and cached once).

Quants

Quant	What it is	Weights	Compute
`f16+bert8`	Highest fidelity (f16 synthesis) — front and voice in f16 storage, with the int8 text encoder — the largest download, and the closest match to the source checkpoint's audio.	`text_encoder` = `i8` / `front` = `f16` / `voice` = `f16`	—
`i8`	Half size (int8) — Every component stored as int8 and computed in f32 — roughly half the f16 download, with the execution path left unchanged.	`text_encoder` = `i8` / `front` = `i8` / `voice` = `i8`	—
`i8-a8`	int8 with int8 linear activations — The int8 weights with per-token int8 activations in the linear layers — faster on GPUs with dp4a, same download as the plain int8 seat.	`text_encoder` = `i8` / `front` = `i8` / `voice` = `i8`	`linearCompute` = `a8`
`i8+bert4` (default)	Balanced (int8 + int4 text encoder) — int8 synthesis with the text encoder in GPTQ-calibrated int4 (group-32): a markedly smaller download that stays audibly level with f32.	`text_encoder` = `i4` / `front` = `i8` / `voice` = `i8`	—
`i4`	Smallest (int4) — Text encoder, front and voice all in int4 group-32 — the smallest download and the fastest warm start, with slightly lower tension than f32.	`text_encoder` = `i4` / `front` = `i4` / `voice` = `i4`	—

If no quant is given, it runs as i8+bert4 (this model's recommended default). In a quant name, bert is the text_encoder component.

How the stored weights were rounded:

i8 — every weight in i8, rounded per tensor (plain RTN).
i8+bert4 (default) — text_encoder in i4 group-32: its linear layers rounded with GPTQ calibration (a 48-sentence Japanese corpus), its embedding table plain RTN. front / voice stay i8.
i4 — the same text encoder as i8+bert4, plus front / voice linear and conv1d weights in i4 group-32 with plain RTN. Smallest download and fastest warm synthesis; the output is very close to i8+bert4, with slightly lower tension than the source checkpoint's unquantized f32 reference.

Styles

Style	ID
`Neutral`	0
`Angry`	1
`Disgust`	2
`Fear`	3
`Happy`	4
`Sad`	5
`Surprise`	6

style takes one of these names — the ID is the row it selects in F1/styles/style_vectors.safetensors. styleWeight blends between the average style (0) and the named one (1).

Speakers

Speaker	ID
`jvnv-F1-jp`	0

speaker takes one of these names — the ID is the row it selects in F1/speakers/speaker_embeddings.safetensors.

Defaults

Any knob not passed to generate() is filled in from the manifest's defaults.

speaker: jvnv-F1-jp
style: Neutral
styleWeight: 1.0
sdpRatio: 0.2
noiseScale: 0.6
noiseScaleW: 0.8
lengthScale: 1.0

seed is the one knob the manifest does not carry — it defaults to 0, and the same seed with the same knobs gives the same waveform.

Model: F2

Files

Key	Dtype	Path	Size	sha256
`text_encoder`	i8	`shared/text_encoder/model.i8.safetensors`	292.84 MiB (307,068,768 B)	`cc3d87f336389f5e…`
`text_encoder`	i4	`shared/text_encoder/model.i4.safetensors`	184.93 MiB (193,911,592 B)	`1425e397c96f4174…`
`front`	f16	`F2/front/model.f16.safetensors`	17.12 MiB (17,954,836 B)	`972fcd3d737d6aeb…`
`front`	i8	`F2/front/model.i8.safetensors`	9.85 MiB (10,324,816 B)	`92820a9d338f56dc…`
`front`	i4	`F2/front/model.i4.safetensors`	7.04 MiB (7,381,496 B)	`9ac479a474fb41e7…`
`voice`	f16	`F2/voice/model.f16.safetensors`	104.30 MiB (109,363,444 B)	`778174cd575f7941…`
`voice`	i8	`F2/voice/model.i8.safetensors`	52.95 MiB (55,516,968 B)	`e42edb452d9bf915…`
`voice`	i4	`F2/voice/model.i4.safetensors`	34.37 MiB (36,039,208 B)	`80d10c70ad304491…`
`tokenizer`	—	`shared/tokenizer/deberta-tokenizer.json`	119.17 KiB (122,035 B)	`8705372d7c85d55e…`
`symbols`	—	`shared/text/symbols.json`	1.60 KiB (1,642 B)	`6d61307808256836…`
`style_vectors`	—	`F2/styles/style_vectors.safetensors`	7.09 KiB (7,256 B)	`de33dc878f1f6227…`
`speaker_embeddings`	—	`F2/speakers/speaker_embeddings.safetensors`	2.09 KiB (2,136 B)	`24c1f61f9bfe9933…`

Quants

Quant	What it is	Weights	Compute
`f16+bert8`	Highest fidelity (f16 synthesis) — front and voice in f16 storage, with the int8 text encoder — the largest download, and the closest match to the source checkpoint's audio.	`text_encoder` = `i8` / `front` = `f16` / `voice` = `f16`	—
`i8`	Half size (int8) — Every component stored as int8 and computed in f32 — roughly half the f16 download, with the execution path left unchanged.	`text_encoder` = `i8` / `front` = `i8` / `voice` = `i8`	—
`i8-a8`	int8 with int8 linear activations — The int8 weights with per-token int8 activations in the linear layers — faster on GPUs with dp4a, same download as the plain int8 seat.	`text_encoder` = `i8` / `front` = `i8` / `voice` = `i8`	`linearCompute` = `a8`
`i8+bert4` (default)	Balanced (int8 + int4 text encoder) — int8 synthesis with the text encoder in GPTQ-calibrated int4 (group-32): a markedly smaller download that stays audibly level with f32.	`text_encoder` = `i4` / `front` = `i8` / `voice` = `i8`	—
`i4`	Smallest (int4) — Text encoder, front and voice all in int4 group-32 — the smallest download and the fastest warm start, with slightly lower tension than f32.	`text_encoder` = `i4` / `front` = `i4` / `voice` = `i4`	—

If no quant is given, it runs as i8+bert4 (this model's recommended default). In a quant name, bert is the text_encoder component.

How the stored weights were rounded:

i8 — every weight in i8, rounded per tensor (plain RTN).
i8+bert4 (default) — text_encoder in i4 group-32: its linear layers rounded with GPTQ calibration (a 48-sentence Japanese corpus), its embedding table plain RTN. front / voice stay i8.
i4 — the same text encoder as i8+bert4, plus front / voice linear and conv1d weights in i4 group-32 with plain RTN. Smallest download and fastest warm synthesis; the output is very close to i8+bert4, with slightly lower tension than the source checkpoint's unquantized f32 reference.

Styles

Style	ID
`Neutral`	0
`Angry`	1
`Disgust`	2
`Fear`	3
`Happy`	4
`Sad`	5
`Surprise`	6

style takes one of these names — the ID is the row it selects in F2/styles/style_vectors.safetensors. styleWeight blends between the average style (0) and the named one (1).

Speakers

Speaker	ID
`jvnv-F2-jp`	0

speaker takes one of these names — the ID is the row it selects in F2/speakers/speaker_embeddings.safetensors.

Defaults

Any knob not passed to generate() is filled in from the manifest's defaults.

speaker: jvnv-F2-jp
style: Neutral
styleWeight: 1.0
sdpRatio: 0.2
noiseScale: 0.6
noiseScaleW: 0.8
lengthScale: 1.0

seed is the one knob the manifest does not carry — it defaults to 0, and the same seed with the same knobs gives the same waveform.

Model: M1

Files

Key	Dtype	Path	Size	sha256
`text_encoder`	i8	`shared/text_encoder/model.i8.safetensors`	292.84 MiB (307,068,768 B)	`cc3d87f336389f5e…`
`text_encoder`	i4	`shared/text_encoder/model.i4.safetensors`	184.93 MiB (193,911,592 B)	`1425e397c96f4174…`
`front`	f16	`M1/front/model.f16.safetensors`	17.12 MiB (17,954,836 B)	`ac36502ff989b2d2…`
`front`	i8	`M1/front/model.i8.safetensors`	9.85 MiB (10,324,816 B)	`d53b9c655098f72a…`
`front`	i4	`M1/front/model.i4.safetensors`	7.04 MiB (7,381,496 B)	`63abf1645a0c7176…`
`voice`	f16	`M1/voice/model.f16.safetensors`	104.30 MiB (109,363,444 B)	`ab9e2067aa71a4f7…`
`voice`	i8	`M1/voice/model.i8.safetensors`	52.95 MiB (55,516,968 B)	`553a14089f09631f…`
`voice`	i4	`M1/voice/model.i4.safetensors`	34.37 MiB (36,039,208 B)	`01c49642f54e83e8…`
`tokenizer`	—	`shared/tokenizer/deberta-tokenizer.json`	119.17 KiB (122,035 B)	`8705372d7c85d55e…`
`symbols`	—	`shared/text/symbols.json`	1.60 KiB (1,642 B)	`6d61307808256836…`
`style_vectors`	—	`M1/styles/style_vectors.safetensors`	7.09 KiB (7,256 B)	`ae2bf2a8e357564c…`
`speaker_embeddings`	—	`M1/speakers/speaker_embeddings.safetensors`	2.09 KiB (2,136 B)	`c983aa5ab85d138a…`

Quants

Quant	What it is	Weights	Compute
`f16+bert8`	Highest fidelity (f16 synthesis) — front and voice in f16 storage, with the int8 text encoder — the largest download, and the closest match to the source checkpoint's audio.	`text_encoder` = `i8` / `front` = `f16` / `voice` = `f16`	—
`i8`	Half size (int8) — Every component stored as int8 and computed in f32 — roughly half the f16 download, with the execution path left unchanged.	`text_encoder` = `i8` / `front` = `i8` / `voice` = `i8`	—
`i8-a8`	int8 with int8 linear activations — The int8 weights with per-token int8 activations in the linear layers — faster on GPUs with dp4a, same download as the plain int8 seat.	`text_encoder` = `i8` / `front` = `i8` / `voice` = `i8`	`linearCompute` = `a8`
`i8+bert4` (default)	Balanced (int8 + int4 text encoder) — int8 synthesis with the text encoder in GPTQ-calibrated int4 (group-32): a markedly smaller download that stays audibly level with f32.	`text_encoder` = `i4` / `front` = `i8` / `voice` = `i8`	—
`i4`	Smallest (int4) — Text encoder, front and voice all in int4 group-32 — the smallest download and the fastest warm start, with slightly lower tension than f32.	`text_encoder` = `i4` / `front` = `i4` / `voice` = `i4`	—

If no quant is given, it runs as i8+bert4 (this model's recommended default). In a quant name, bert is the text_encoder component.

How the stored weights were rounded:

i8 — every weight in i8, rounded per tensor (plain RTN).
i8+bert4 (default) — text_encoder in i4 group-32: its linear layers rounded with GPTQ calibration (a 48-sentence Japanese corpus), its embedding table plain RTN. front / voice stay i8.
i4 — the same text encoder as i8+bert4, plus front / voice linear and conv1d weights in i4 group-32 with plain RTN. Smallest download and fastest warm synthesis; the output is very close to i8+bert4, with slightly lower tension than the source checkpoint's unquantized f32 reference.

Styles

Style	ID
`Neutral`	0
`Angry`	1
`Disgust`	2
`Fear`	3
`Happy`	4
`Sad`	5
`Surprise`	6

style takes one of these names — the ID is the row it selects in M1/styles/style_vectors.safetensors. styleWeight blends between the average style (0) and the named one (1).

Speakers

Speaker	ID
`jvnv-M1-jp`	0

speaker takes one of these names — the ID is the row it selects in M1/speakers/speaker_embeddings.safetensors.

Defaults

Any knob not passed to generate() is filled in from the manifest's defaults.

speaker: jvnv-M1-jp
style: Neutral
styleWeight: 1.0
sdpRatio: 0.2
noiseScale: 0.6
noiseScaleW: 0.8
lengthScale: 1.0

seed is the one knob the manifest does not carry — it defaults to 0, and the same seed with the same knobs gives the same waveform.

Model: M2

Files

Key	Dtype	Path	Size	sha256
`text_encoder`	i8	`shared/text_encoder/model.i8.safetensors`	292.84 MiB (307,068,768 B)	`cc3d87f336389f5e…`
`text_encoder`	i4	`shared/text_encoder/model.i4.safetensors`	184.93 MiB (193,911,592 B)	`1425e397c96f4174…`
`front`	f16	`M2/front/model.f16.safetensors`	17.12 MiB (17,954,836 B)	`d8d3281d212d5104…`
`front`	i8	`M2/front/model.i8.safetensors`	9.85 MiB (10,324,816 B)	`b8f1d82861cde31c…`
`front`	i4	`M2/front/model.i4.safetensors`	7.04 MiB (7,381,496 B)	`bbb0e202003cb537…`
`voice`	f16	`M2/voice/model.f16.safetensors`	104.30 MiB (109,363,444 B)	`32706fbfa271440e…`
`voice`	i8	`M2/voice/model.i8.safetensors`	52.95 MiB (55,516,968 B)	`b4df2c14fc8a430f…`
`voice`	i4	`M2/voice/model.i4.safetensors`	34.37 MiB (36,039,208 B)	`4367eb1f9e413ed7…`
`tokenizer`	—	`shared/tokenizer/deberta-tokenizer.json`	119.17 KiB (122,035 B)	`8705372d7c85d55e…`
`symbols`	—	`shared/text/symbols.json`	1.60 KiB (1,642 B)	`6d61307808256836…`
`style_vectors`	—	`M2/styles/style_vectors.safetensors`	7.09 KiB (7,256 B)	`68fd36ce26e2664e…`
`speaker_embeddings`	—	`M2/speakers/speaker_embeddings.safetensors`	2.09 KiB (2,136 B)	`fd039e988b7e7f9e…`

Quants

Quant	What it is	Weights	Compute
`f16+bert8`	Highest fidelity (f16 synthesis) — front and voice in f16 storage, with the int8 text encoder — the largest download, and the closest match to the source checkpoint's audio.	`text_encoder` = `i8` / `front` = `f16` / `voice` = `f16`	—
`i8`	Half size (int8) — Every component stored as int8 and computed in f32 — roughly half the f16 download, with the execution path left unchanged.	`text_encoder` = `i8` / `front` = `i8` / `voice` = `i8`	—
`i8-a8`	int8 with int8 linear activations — The int8 weights with per-token int8 activations in the linear layers — faster on GPUs with dp4a, same download as the plain int8 seat.	`text_encoder` = `i8` / `front` = `i8` / `voice` = `i8`	`linearCompute` = `a8`
`i8+bert4` (default)	Balanced (int8 + int4 text encoder) — int8 synthesis with the text encoder in GPTQ-calibrated int4 (group-32): a markedly smaller download that stays audibly level with f32.	`text_encoder` = `i4` / `front` = `i8` / `voice` = `i8`	—
`i4`	Smallest (int4) — Text encoder, front and voice all in int4 group-32 — the smallest download and the fastest warm start, with slightly lower tension than f32.	`text_encoder` = `i4` / `front` = `i4` / `voice` = `i4`	—

If no quant is given, it runs as i8+bert4 (this model's recommended default). In a quant name, bert is the text_encoder component.

How the stored weights were rounded:

i8 — every weight in i8, rounded per tensor (plain RTN).
i8+bert4 (default) — text_encoder in i4 group-32: its linear layers rounded with GPTQ calibration (a 48-sentence Japanese corpus), its embedding table plain RTN. front / voice stay i8.
i4 — the same text encoder as i8+bert4, plus front / voice linear and conv1d weights in i4 group-32 with plain RTN. Smallest download and fastest warm synthesis; the output is very close to i8+bert4, with slightly lower tension than the source checkpoint's unquantized f32 reference.

Styles

Style	ID
`Neutral`	0
`Angry`	1
`Disgust`	2
`Fear`	3
`Happy`	4
`Sad`	5
`Surprise`	6

style takes one of these names — the ID is the row it selects in M2/styles/style_vectors.safetensors. styleWeight blends between the average style (0) and the named one (1).

Speakers

Speaker	ID
`jvnv-M2-jp`	0

speaker takes one of these names — the ID is the row it selects in M2/speakers/speaker_embeddings.safetensors.

Defaults

Any knob not passed to generate() is filled in from the manifest's defaults.

speaker: jvnv-M2-jp
style: Neutral
styleWeight: 1.0
sdpRatio: 0.2
noiseScale: 0.6
noiseScaleW: 0.8
lengthScale: 1.0

seed is the one knob the manifest does not carry — it defaults to 0, and the same seed with the same knobs gives the same waveform.

Downloads last month: -; Downloads are not tracked for this model. How to track

Model tree for hdae/karume-sbv2-jvnv

Base model

ku-nlp/deberta-v2-large-japanese-char-wwm

Quantized

(3)

this model

Paper for hdae/karume-sbv2-jvnv

JVNV: A Corpus of Japanese Emotional Speech with Verbal Content and Nonverbal Expressions

Paper • 2310.06072 • Published Oct 9, 2023