Playing the piano

jev-pp, a small decision model, asked from this page

Tuning the piano built a small decision model, jev-pp: a released language model of 0.6 billion weights, Qwen3-0.6B, with adapters trained for three minutes. It writes nothing. It is given a text, the state, and typed questions about it; it reads both once and gives every answer a probability. This page puts it within reach. The figure asks the model itself; the lines after it ask it from a terminal.

jev-pp, asked from the page. A state is a text; questions are asked about it; the model reads both once and
gives a probability to every answer. 4 examples, as it answered them:

STATE  The soup was cold and the waiter was kind.
  How many stars, from 1 to 5, did the customer give?
      1 0.00   2 0.09   3 0.78   4 0.13   5 0.00
  The customer complains about the food.
      yes 0.02   no 0.98
  The customer praises the waiter.
      yes 0.23   no 0.77
  The customer will come back.
      yes 0.05   no 0.95

STATE  PREMISE: It rained all night.
       HYPOTHESIS: The street was wet in the morning.
  Which relation would a reader see between the premise and the hypothesis?
      entailment 0.64   neutral 0.33   contradiction 0.03

STATE  What's so funny? You people would laugh at a funeral.
  A rater would call this comment toxic: rude or disrespectful enough to make people leave a discussion.
      yes 0.06   no 0.94
  A rater would say this comment insults someone.
      yes 0.03   no 0.97
  A rater would say this comment threatens someone.
      yes 0.00   no 1.00
  A rater would call this comment obscene.
      yes 0.01   no 0.99

STATE  Every human is mortal. Socrates is human.
  Socrates is mortal.
      yes 0.54   no 0.46
  Socrates is a pianist.
      yes 0.01   no 0.99
  What follows about Socrates?
      he is mortal 0.79   he is not mortal 0.05   nothing follows 0.16

The live figure needs JavaScript: it sends what is typed to the model’s server and draws the answers.
jev-pp, asked from the page. The state is a text; under it, questions about it, one to a line. The model reads both once and gives every answer a probability (green). The answers shown first were given beforehand. Edit the state or the questions and the page asks the model again: what is typed goes to its server, a Space on Hugging Face that runs it on a processor and writes nothing down. The server sleeps when nobody asks, and takes about a minute to wake.

what to ask

A question is one of three types, and the type decides what an answer can be. A statement is answered yes or no. A choice is a question with two to five options written after it. A score is a question with its levels, each a digit, in order. In the figure a question is a line, and its options or levels follow it between bars: What is the review about? | a restaurant | a hotel | a shop.

The adapters were trained on three kinds of case, one for each type: comments and what their raters said of them, inferences and what 100 readers saw in them, reviews and the stars their customers gave. On those its probabilities were measured, and they hold. On anything else it is the released model with a request it has learned to read, and its numbers deserve a check before they are trusted.

The fourth example is of that kind. Given "Every human is mortal. Socrates is human.", it gives the statement "Socrates is mortal" a probability of 0.54, and when the same thing is put as a choice it gives "he is mortal" 0.79. Jevons's machine, given the two premises, strikes out every combination in which Socrates is human and not mortal, and leaves no doubt. A reader of comments and reviews is not that machine. Its number says what a reader would probably answer, not what follows.

from a terminal

The figure sends what any program can send:

curl -s https://david-rename-jev-pp.hf.space/v1/decisions -d '{
  "state": "The soup was cold and the waiter was kind.",
  "questions": [
    {"type": "noul", "text": "The customer complains about the food."},
    {"type": "score", "text": "How many stars, from 1 to 5, did the customer give?",
     "levels": ["1", "2", "3", "4", "5"]}]}'

and gets back (the probabilities rounded here):

{"model": "jev-pp", "answers": [
  {"question": "The customer complains about the food.", "type": "noul",
   "options": [{"option": "yes", "probability": 0.022}, {"option": "no", "probability": 0.978}]},
  {"question": "How many stars, from 1 to 5, did the customer give?", "type": "score",
   "options": [{"option": "1", "probability": 0.002}, {"option": "2", "probability": 0.090},
               {"option": "3", "probability": 0.777}, {"option": "4", "probability": 0.130},
               {"option": "5", "probability": 0.002}]}],
 "tokens": 106, "ms": 758.0,
 "timing": {"read": 0.03, "queue": 0.0, "tokens": 1.26, "model": 756.73, "remembered": false, ...}}

A statement has the type noul, the word of the Jev API; a choice has "type": "choice" and a list of options; a score has "type": "score" and a list of levels. A request holds at most 16 questions and 64 kilobytes, and the state is read to its first 256 tokens, as it was in training. The answer's timing says where the server's milliseconds went: reading the request, waiting behind another, the tokenizer, the model's pass, and whether the answer was remembered from an earlier asking. However many questions it holds, it is one pass: each question reads the state and itself and no other question, so their order changes nothing.

where it runs

The server is a Space on Hugging Face, on two cores of a processor and no graphics card. There the model has its weights in 8 bits, 656 megabytes in all, and a request of four questions takes it under a second; on a graphics card, in full, the same request takes 0.03. The Space writes nothing of a request down; it holds its last 512 answers in memory, so a request made again is answered at once. It sleeps when nobody has asked for two days and takes about a minute to wake, which the figure waits out.

Cutting the weights to 8 bits costs little. On 520 questions of 280 cases the model had not seen, its probabilities moved by 0.003 on average from those of the full model, and its scores against what raters, readers and customers said did not change. At 4 bits they moved by 0.044, which is why 8 were kept. Only the weights are cut: the arithmetic stays in 32 bits, because with that rounded too an answer began to depend, in the third decimal, on which other questions were asked.

The weights are at huggingface.co/david-rename/jev-pp in three forms: the adapters alone, 40 megabytes, to lay over the released model; the whole model with the adapters folded in, 1.2 gigabytes in 16 bits; and the 8-bit files the Space serves. The server beside them is 125 lines on Python's standard library, and three commands run it anywhere, without PyTorch:

pip install onnxruntime onnx tokenizers numpy huggingface_hub
hf download david-rename/jev-pp --local-dir jev-pp
python jev-pp/serve.py --onnx jev-pp/onnx --port 8000

The model could also run in the page itself, and it did: under WebAssembly it answered in about four seconds. But a page would first have to fetch those 656 megabytes, or 436 with the weights cut to 4 bits, and so the page asks a server.

← Back to all posts