You need to agree to share your contact information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

Sori-1B-MCQ is released for ACADEMIC USE ONLY, to be shared and built on under the same terms with attribution. Its audio tower is NVIDIA's Audio Flamingo Next encoder, carried unchanged and frozen under the NVIDIA OneWay Noncommercial License (22 Mar 2022, academic), whose Section 3.3 limits the work and every derivative of it to academic purposes; its language model is Liquid AI's LFM2.5-Encoder-350M (LFM Open License v1.0, kept). Both licenses are reproduced in full in LICENSE, which carries the complete terms. Access is granted on these conditions: you use the model for academic purposes only; anything you derive from it or its outputs is shared under the same terms with a notice of what was changed; and you cite this work in any publication, system or model whose results depend on it.

Sori-1B-MCQ: An Audio Multiple-Choice Question Solver

_{Multiple-choice questions about sound clips, answered as decisions and calibrated probabilities.}

SNU · Human Interface Lab

_{Seonuk Kim · Human Interface Lab · Seoul National University · 🇰🇷}

_{Research preview}

Sori-1B-MCQ — sori (소리) is Korean for sound — listens to a clip and answers typed questions about it: which of these options, how far along this scale, is this true. It returns the answer, a probability for every option you defined, and a confidence — never prose, never a token stream to parse. Code stays in charge: your program defines the options, reads the numbers and decides what to do. It is the decision model of the Sori Agent project at the Human Interface Lab, Seoul National University.

Inspired by TypeSafe's System One model, Jev. Jev showed what a model built for software rather than for conversation looks like: a state, typed questions, calibrated probabilities, one call for many questions. Sori-1B-MCQ is that idea for sound. Its request, its three question types, its answers, its errors and its confidence follow TypeSafe's API deliberately and closely, so code written against Jev reads audio here by pointing the client's base_url at this model. TypeSafe built the interface; this model brings audio to it. We are not affiliated with TypeSafe, and any mistake in the correspondence is ours.

Setup

pip install "transformers>=5.13" "torch>=2.6" soundfile scipy numpy pandas pyarrow
hf auth login

Everything the model needs travels with the checkpoint (trust_remote_code=True loads the model and its processor). The audio tower always runs in bfloat16, the dtype it was trained in; the reader and the head follow the dtype you load. Load in float32 (the default here) and the answers do not depend on how many clips share a call; bfloat16 is faster on a GPU and moves a few answers per hundred. Report the dtype beside any score. Audio is read with soundfile (wav, flac, ogg, and mp3 with libsndfile 1.1+) and resampled to 16 kHz; any sample rate and any length are accepted, and clips are never cut. CPU works.

Usage

from transformers import AutoModel, AutoProcessor

model = AutoModel.from_pretrained("snkii/Sori-1B-MCQ", trust_remote_code=True).eval()
proc = AutoProcessor.from_pretrained("snkii/Sori-1B-MCQ", trust_remote_code=True)

r = model.system_one(
    state={"clip": {"type": "audio", "path": "street.wav"}, "location": "a train station"},
    questions={
        "source": {"type": "choice", "instructions": "What makes the loudest sound?",
                    "criteria": {"train": None, "announcement": "a voice over a PA system", "crowd": None}},
        "busy":   {"type": "score", "instructions": "How crowded does the place sound?",
                    "criteria": ["empty, no voices", "a few people", "a dense crowd"]},
        "horn":   {"type": "noul", "instructions": "Is a train horn heard?"},
    },
    processor=proc)

r["answers"]["source"]["choice"]          # 'train'
r["answers"]["source"]["probabilities"]   # {'train': ..., 'announcement': ..., 'crowd': ...}
r["answers"]["busy"]["score"]             # a position along your levels, 0 to 2 here
r["answers"]["horn"]["noul"]              # the probability that the answer is yes

Many clips at once. model.system_one_batch([(state, questions), ...], processor=proc) answers a list of states in one forward — the call to use for a benchmark or a busy server. Loaded in float32 it answers exactly what system_one answers clip by clip; loaded in bfloat16 a few answers per hundred move, because a bf16 kernel sums a batch in a different order. One invalid item rejects the whole list, and a reading other than prior needs audio in every state.

Three question types, as in TypeSafe's primitives. A choice picks one of the options you name and returns a probability for each. A score places the clip on ordered levels you describe and returns a position along them. A noul answers a yes/no question with the probability of yes. Choice and score answers also carry a confidence: how concentrated the distribution is, 1 for a point mass and 0 for a flat one, so code can act, ask or escalate.

The state. The state is the material the questions are about: a clip, or a JSON object holding a clip and text fields ({"clip": ..., "speakers": [...]}), or an array — up to eight clips in one state, so one question can compare them. Questions in one call are answered independently against the same state, and the audio is read once.

Three readings. A call reports the audio's own evidence (the default), the posterior that also uses what the wording alone suggests, or that text prior by itself — so an application can separate what the sound says from what the question already implied.

As a service. serve.py travels with the model and answers over HTTP in the same shape, so a client written for that API can talk to it — including TypeSafe's own Python SDK, which is MIT-licensed and takes any base_url:

python serve.py --model snkii/Sori-1B-MCQ --port 8790      # --device cuda, --api_key_env KEY to require a key

from typesafe_sdk import TypeSafeClient, Choice
c = TypeSafeClient(api_key="local", base_url="http://127.0.0.1:8790", model="sori-latest")
c.system_one(state={"type": "audio", "path": "street.wav"},
             questions={"source": Choice(instructions="What is loudest?", criteria={"train": None, "crowd": None})})

On a benchmark. example_mmau.py fetches this model and a benchmark, answers it clip by clip and scores it — one command, nothing to download by hand:

python example_mmau.py --limit 25          # add --device mps on a Mac, --device cuda on a GPU, --batch 8 to fill it

It reads MMAU test-mini as its authors publish it on the Hub (gamma-lab-umd/MMAU-test-mini, audio included); nothing of the benchmark is redistributed here. --bench takes a local file instead, and --reading prior is the control that asks how much of a benchmark can be answered without listening at all.

The model

An audio tower, a projector and a reader: 1.05 billion parameters. The tower is NVIDIA's Audio Flamingo Next encoder, carried unchanged and frozen; the reader is Liquid AI's LFM2.5-Encoder-350M, a bidirectional encoder read as released. The projector that turns the tower's frames into the reader's tokens ends in three of the reader's own blocks -- its bottom convolution, convolution and attention layers, copied from the reader and trained further as a mixer over the sound. The model answers only inside the options a question defines. Everything it needs to run and to serve travels with the checkpoint. This is a research preview under active development, for academic use.

License

Sori-1B-MCQ is for academic use only: within that, use it, share it and build on it under the same terms, with attribution. Models, data and systems derived from it or from its outputs carry this license, a notice of what was changed, and a citation of this work; so do publications whose results depend on it. The limit is not ours to relax — the audio tower is NVIDIA's Audio Flamingo Next encoder, carried unchanged under the NVIDIA OneWay Noncommercial License (22 Mar 2022, academic), whose Section 3.3 reads "non-commercially" as for academic purposes only and carries that limit into every derivative work. The model it reads with remains under Liquid AI's LFM Open License v1.0. Both licenses are reproduced in full, and the parts covered by our own terms are named file by file, in LICENSE.

Trademarks

TypeSafe, System One and Jev are TypeSafe's names for TypeSafe's products; they appear here only to credit the interface this model follows and the work that inspired it. This model is not a TypeSafe product and is not affiliated with or endorsed by TypeSafe, and it contains no TypeSafe code, weights, data or model outputs. NVIDIA and Audio Flamingo are NVIDIA's marks, and Liquid AI and LFM are Liquid AI's; neither license grants rights in them beyond the notices this repository reproduces.

Citation

@software{kim_sori_mcq_2026,
  author  = {Kim, Seonuk},
  title   = {{Sori-1B-MCQ: An Audio Multiple-Choice Question Solver}},
  year    = {2026},
  month   = sep,
  institution = {Human Interface Laboratory, Seoul National University},
  url     = {https://huggingface.co/snkii/Sori-1B-MCQ}
}