Laya Vision by thaitea

Laya Vision by thaitea

Answers questions about an image as choices, yes/no probabilities or rubric levels in one pass, and can play simple games from screen pixels, with 201M parameters. For developers building image triage.

Made by thaitea on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Laya Vision looks at an image, plus an optional note, and answers a list of questions with numbers instead of sentences. For every question you pick the form of answer: one option from a list, the chance of yes, or a score on a scale you define. The model generates no text, and the same approach lets it play simple games, with the screen as the image and the buttons as the options.

Who it suits: It suits developers and researchers who want quick, scored decisions about pictures, such as sorting photos by damage or answering picture quizzes.

Industry | Who uses it | How they use it | Example
E-commerce | Support teams | Sort photos of returned or damaged items | Rating damage from none to destroyed
Operations | Workflow builders | Put yes/no questions to a photo | Checking whether a photo was taken outdoors
Research | Vision researchers | Test multiple-choice questions about images | Running the card's A-OKVQA and ScienceQA checks
Game AI | Reinforcement learning researchers | Control simple games from the screen | Playing Atari Freeway from pixels

If you need written captions or long answers, or commercial use, you can skip it, since it writes no text and its license is non-commercial.

Where to use it:

• Python scripts and services on Windows, macOS or Linux
• A laya install with torchvision, set up from the project's code repository
• Experiments that read an image and need probabilities back

Use case | Who | What they get back
Damage scoring | Support teams | A level on a rubric you define
Item sorting | Operators | The top option among the categories you list
Yes/no checks | Developers | The probability that the answer is yes

How to set it up:

• Python
• The laya package and torchvision, installed from the project's code repository
• The Pillow imaging library, since the snippet opens images with it
• About 805 MB of space for the full-precision weights

1. Clone the code repository and install it in editable mode with torchvision. The card gives a one-line command, which holds a web address, so copy it from there.
2. Optionally download the model files with the hub command.
3. Load the model by its name with laya.load_vlm.
4. Call predict with an image, an optional note and your questions.

pip install -U huggingface_hub
hf download thaitea/laya-vision

How to use it: The card's snippet loads the model and asks three questions about a photo, with a note from the customer. To keep the weights from changing, pass a revision to laya.load_vlm.

import laya
from PIL import Image

agent = laya.load_vlm("thaitea/laya-vision")
result = agent.predict(
    {"image": Image.open("photo.jpg"), "note": "customer says it arrived broken"},
    {
        "damage":   {"type": "score",  "instructions": "How much damage does the item show?",
                     "criteria": ["none", "cosmetic: scratches or dents", "functional: parts broken or missing", "destroyed"]},
        "category": {"type": "choice", "instructions": "What kind of item is this?",
                     "criteria": ["electronics", "clothing", "furniture", "food", "other"]},
        "outdoors": {"type": "noul",   "instructions": "Was the photo taken outdoors?"},
    },
)
a = result["answers"]
a["damage"]["score"], a["category"]["choice"], a["outdoors"]["noul"]   # expected level 0-3, top option, P(true)

Tool | What it does
laya.load_vlm | Loads the model by its name, with an optional revision
agent.predict | Answers your set of questions about an image and a note
choice | Picks the top option and gives probabilities for the others
noul | Gives the probability that a yes/no answer is yes
score | Gives a level on a rubric you write

Example: You send a photo with the note that the customer says the item arrived broken. You ask how much damage it shows, what kind of item it is and whether it was photographed outdoors. You get back a damage level, the top category and the chance the photo was outdoors.

For newcomers and experts: This model looks at a picture and answers with numbers, not sentences, and the card says you can read the probabilities at face value. A good first try is the card's snippet with a photo of your own.

Under the hood, it is SmolVLM-256M-Instruct cut from 30 language layers to 20, with 201M parameters in all. Training took 2 hours and used question-answer examples together with frames from games. An autoresearch loop in the code repository found this checkpoint. The previous checkpoint had 237M parameters and no game training.

Image and optional note go in
Vision-language model, one pass
Answers scored per question
Choice, yes/no or level comes out

Good to know:

Title: Accuracy on validation sets
A-OKVQA: 59.8%
ScienceQA image subset: 82.4%
VQAv2 yes/no: 71.4%

Title: Full suite of 34 validation sets, this model and the previous checkpoint
Measure | This model | Previous checkpoint
Parameters | 201M | 237M
Accuracy over 59,427 questions | 69.1% | 69.3%
Mean accuracy over the 34 sets | 71.6% | 71.9%
Calibration error, lower is better | 0.041 | 0.064
Relative latency on an L4 | 0.83x | 1.00x

Title: Game scores, 0 for random play and 1 for the expert
Game | Normalized score
ViZDoom basic | 0.99
Atari Freeway | 0.81
Acrobot | 0.76
MountainCar | 0.64
Maze 4x4 | 0.32
Atari Breakout | 0.20
Snake 10x10 | 0.17
Maze 6x6 | 0.02
CartPole | -0.01
LunarLander | -0.44
Mean | 0.35

• The VQAv2 split is a re-split by image, so it is not comparable to published VQAv2 numbers.
• Against the previous checkpoint it is within a point on 23 of the 34 sets, ahead on 3 and behind on 8, with the biggest drops on the smallest sets.
• The earlier checkpoint had no game training, and its mean on the same game benchmark is -0.04.
• The card calls it experimental research, and it is an independent fork of Laya.
• License: CC BY-NC-SA 4.0
• Cost to run: none named, though the full-precision weights take about 805 MB
• Data it reaches: none named beyond the images and notes you give it
• Not for: commercial use, or writing text, since it only returns scored answers

On Hugging Face, 13 November 2026

• Task: visual question answering
• Library: laya
• Parameters: 201M
• Weights: about 805 MB in F32; about 101 MB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 0
• Likes: 54
• License: cc-by-nc-sa-4.0
• Languages: en
• Based on: HuggingFaceTB/SmolVLM-256M-Instruct
• Fine-tunes: 2
• Tags: laya, safetensors, calibration, decision-model, vision, smolvlm, games, visual-question-answering

Links

• Model: https://huggingface.co/thaitea/laya-vision
• Files: https://huggingface.co/thaitea/laya-vision/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download thaitea/laya-vision

Then follow the usage in its model card. Nothing in this kit runs by itself.