More than an answer.
A distribution
to learn from.

The alternatives carry information.

A text response tells you which token was generated. A probability distribution also tells you which alternatives the model considered plausible. A student can learn from the teacher’s relative preferences instead of receiving only one selected token as its target.

A logprob is a natural logarithm: p = exp(logprob). For example, −0.693 is approximately 50%. Full mode includes the tail that a top-5 or top-20 response omits.

See what the student can learn.

In this tiny, fictional vocabulary, the teacher prefers A but leaves room for B and C. Increase the distillation temperature to give the alternatives more weight.

This is a teaching example, not a Qwen or Bielik measurement. The control reweights a saved distribution with softmax(logp / T); it does not change the API’s generation temperature.

What you can build with it.

Request every next-token probability.

Generate an API key and put it in FABRYKA_API_KEY. Save the following as request.json. Use bielik-11b-v3 instead of qwen3.8-27b to query Bielik.

{
  "model": "bielik-11b-v3",
  "messages": [{"role": "user", "content": "Stolica Polski to"}],
  "max_tokens": 1,
  "temperature": 0,
  "logprobs": true,
  "top_logprobs": -1
}

curl --fail-with-body --silent --show-error \
  https://fabryka.ai/v1/chat/completions \
  -H "Authorization: Bearer $FABRYKA_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @request.json \
  -o teacher.json

max_tokens: 1 returns a distribution for the next generated position after the server’s chat-formatted prompt. For up to 8 positions, each later row is conditioned on the tokens the teacher actually generated before it.

In JSON, read choices[0].logprobs.content. Each position contains a generated id, token, bytes, logprob, and a top_logprobs list. In full mode that list contains every vocabulary token. The enclosing object reports full_vocabulary: true and vocab_size.

Alternatives are in backend probability order. Always index by id, not by list position or decoded text. The API rejects incomplete vocabularies, duplicate IDs and invalid values. Open the API reference →

Turn the response into a tensor.

The downloadable exporter validates full coverage and saves a float32 array with shape [generated_positions, vocabulary_size]. Column j always refers to teacher token ID j. It also saves the request, generated token IDs and response metadata in a separate JSON file.

python -m pip install numpy
curl --fail --silent --show-error \
  https://fabryka.ai/examples/export_logprobs.py -o export_logprobs.py
python export_logprobs.py teacher.json --request request.json --out teacher

A single dense float32 vector takes about 0.12 MiB for Bielik or 0.95 MiB for Qwen. The API’s JSON is substantially larger because it includes token strings, bytes and IDs. A million Qwen positions would require about 926 GiB for the float32 values alone. Pilot your collection and storage budget before scaling.

Record the exact teacher checkpoint, tokenizer revision, chat template, quantization and generation settings with the experiment. The public model ID and system_fingerprint are useful labels, but are not an immutable checkpoint pin. Ask for the exact serving configuration before a reproducibility-sensitive collection.

Train on the teacher’s preferences.

For a student with the same vocabulary semantics and token IDs, minimize KL(p_teacher || p_student) at matched positions. You can soften both distributions with temperature T and mix the distillation objective with supervised cross-entropy on task targets. Tune the mixture on a held-out validation set.

The function below takes two tensors of shape [valid_positions, vocabulary_size]. Remove padding and unscored prompt positions before calling it. It normalizes the stored teacher logprobs and keeps gradients only on the student.

import torch
import torch.nn.functional as F


def distillation_loss(student_logits, teacher_logprobs, temperature=2.0):
    if temperature <= 0:
        raise ValueError('temperature must be positive')
    if student_logits.ndim != 2 or student_logits.shape != teacher_logprobs.shape:
        raise ValueError('Inputs must have matching [valid_positions, vocabulary] shapes')
    if student_logits.shape[0] == 0:
        raise ValueError('At least one valid position is required')
    teacher = teacher_logprobs.detach().to(device=student_logits.device, dtype=torch.float32)
    log_p_teacher = F.log_softmax(teacher / temperature, dim=-1)
    log_p_student = F.log_softmax(student_logits.float() / temperature, dim=-1)
    return F.kl_div(
        log_p_student, log_p_teacher,
        reduction='batchmean', log_target=True,
    ) * temperature ** 2

Download the loss function → This is the training objective, not a complete trainer. For the first generated position, use the student’s last-position logits on the identical teacher input prefix. For later positions, condition the student on the teacher’s preceding token IDs and select the corresponding next-token logits.

Full logprobs are enough to change distillation temperature offline: log_softmax(logp_teacher / T) cancels the original normalization constant. The API’s temperature controls generation; it is separate from this training-time T. Native floating-point precision still applies.

If the student uses a different tokenizer, start with filtered teacher-generated text and supervised sequence training, or implement and validate an explicit cross-tokenizer alignment method. Do not apply elementwise KL directly between Qwen and Bielik vectors.

Measure the student against its own baseline on held-out tasks. Distillation can transfer teacher behavior, including errors; access to the full distribution does not guarantee a smaller model will match or outperform its teacher. The soft-target method follows Hinton, Vinyals & Dean; the loss implementation uses PyTorch’s documented KL convention.

Full vocabulary. Defined scope.

Generated positions only

This endpoint does not return prompt logprobs, arbitrary reference-text likelihoods or teacher-forced scores for a supplied continuation. Appending text as another chat message changes the context; it is not an exact continuation-scoring API.

Up to 8 positions per full request

The explicit limit bounds very large responses. Higher values are rejected before billing. Start with one position per prompt; full JSON and SSE are supported.

Probabilities, not raw logits

The API returns natural-log probabilities before sampling filters in full mode. It does not expose hidden states, gradients or raw pre-softmax scores. Re-normalize native-precision values for training.

Pin Qwen or Bielik

Use qwen3.8-27b or bielik-11b-v3. Auto Router, the hybrid route and PLLuM do not support this option. The distribution belongs to the served model configuration, not necessarily the original full-precision weights.

Plan collection and evaluation

Normal authentication and token billing apply. Save responses locally; the guide does not train or store a dataset for you. Keep provenance and use data and model outputs under their applicable terms.

Method and reference.

• Hinton, Vinyals & Dean — Distilling the Knowledge in a Neural Network (2015)Soft targets and temperature-based distillation.
• PyTorch — torch.nn.functional.kl_divLog-space targets, reduction and argument order.
• llama.cpp — Server documentationBackend probability and sampling semantics.
• Fabryka API referenceCurrent request schema and authentication.

Full-vocabulary coverage verified through fabryka.ai for both models in JSON and SSE on 5 September 2026. This verifies API behavior, not a distillation quality benchmark.