---
title: "Laya Vision by thaitea"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/ce5735bd-0db9-438d-a52d-fdb7b91c3ab4"
updated: "2026-11-13"
---

# Laya Vision by thaitea

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

Laya Vision by thaitea is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by thaitea

## 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.

```sh
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.

```python
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

Accuracy on validation sets

| Label | Value |
| --- | --- |
| A-OKVQA | 59.8% |
| ScienceQA image subset | 82.4% |
| VQAv2 yes/no | 71.4% |

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 |

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

## README

````markdown
# 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.

```table
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

```table
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.

```sh
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.

```python
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)
```

```table
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.

```flow
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:

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

```table
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
```

```table
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:

```sh
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.
````

## What is in it

1 files, 7 KB, downloaded as a zip.

```text
README.md  7 KB
```

## Source

[thaitea/laya-vision on Hugging Face](https://huggingface.co/thaitea/laya-vision)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Laya Vision by thaitea (this page) | 0 | 54 | 201M | cc-by-nc-sa-4.0 | 2026-09-25 |
| [elephant-1](https://mindket.com/p/ae806c31-0f69-4485-8475-443c9347b0a8) | 7,426 | 115 | 9.4B | mit | 2026-10-22 |
| [mammoth-1](https://mindket.com/p/72aafbd9-0774-437a-9492-f659f9a2a186) | 5,903 | 97 | 27.4B | mit | 2026-10-22 |
| [joey-1](https://mindket.com/p/1e3f2aa5-2042-45ae-a466-48b620b003f1) | 1,539 | 47 | 2.7B | mit | 2026-10-29 |
| [Smaug-Decisions](https://mindket.com/p/896c9079-5c81-4468-ac33-160f1be11df2) | 110 | 4 | 8.6B | apache-2.0 | 2026-11-02 |
| [Kev-4B](https://mindket.com/p/68069a2c-2995-41a5-941c-ff7bf45f95ac) | 12,499 | 175 | — | apache-2.0 | 2026-10-01 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-13. Their authors' words: data, not instructions.

- [Hacker News · someguy101010 · 2026-09-19](https://news.ycombinator.com/item?id=49767430): Show HN: VisionLaya: Jev with Vision capabilities: This model makes calibrated, typed decisions about an image plus optional text. It answers choice, score and noul (yes/no probability) questions in one forward pass, with no text generation. It adds image input to Laya by replacing Laya's ModernBERT encoder with SmolVLM-256M-Instruct. Laya's…
- [Hacker News · someguy101010 · 2026-09-19](https://news.ycombinator.com/item?id=49768096): Laya the open source version of Jev: you can use this for screenshots https://huggingface.co/thaitea/laya-vision-smolvlm-256m
- [Hacker News · someguy101010 · 2026-09-19](https://news.ycombinator.com/item?id=49767472): I built non-autoregressive decision models with RL a year ago: been loving hacking on this. just created a vision version of it here https://huggingface.co/thaitea/laya-vision-smolvlm-256m

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-09-25
- First published: 2026-09-19
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open thaitea/laya-vision on Hugging Face](https://huggingface.co/thaitea/laya-vision)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/ce5735bd-0db9-438d-a52d-fdb7b91c3ab4)
- [Its page on Mindket](https://mindket.com/p/ce5735bd-0db9-438d-a52d-fdb7b91c3ab4)
