TypeSafe recently added a Box question type to Jev: you describe something in an image in plain words and get back one bounding box with a confidence. It’s closed and API-only, so I built an open version: LOCUS (Locate Once, Check Until Settled).

The weights are open (2B and 0.8B) and run on as little as X GB of VRAM.

The problem: VLMs normally write a box out as text, one token at a time. That’s precise but slow, about 18 steps per box. A small regression head can predict the whole box in one pass, which is fast, but the edges come out loose.

The idea: use both. The head makes a quick draft, then the same model checks every draft token in parallel and fixes the ones it disagrees with, repeating until nothing changes. The final box is exactly what the model would have decoded on its own, in about 5.6 steps instead of 18.

Results (RefCOCO / RefCOCO+ / RefCOCOg):

• Same weights, Acc@0.9 goes from 54.9 → 59.1 with verification
• +4.52 Acc@0.9 over Jag (strongest open regression-head model) at the same size and training budget
• 1.5x faster than vLLM decoding the exact same tokens

Use it on your own data: the released models are trained on RefCOCO, but you can fine-tune them on your own dataset (images, a description and a box for each). The repo covers full fine-tuning and LoRA, so a smaller GPU works too.

Limitations: a pure regression head is still faster, and since it’s trained only on RefCOCO it struggles with very small objects. Fine-tuning on your own domain is the fix there.

• Project page: https://muhammad-talha-ad.github.io/LOCUS/
• Code: https://github.com/muhammad-talha-ad/LOCUS
• Models: https://huggingface.co/MTalha2001/LOCUS-2B

Not affiliated with TypeSafe. Since Jev’s Box is API-only, I couldn’t evaluate it under the same conditions, so all comparisons are against open models. Happy to answer questions.

Hello all,

I was looking for a video dataset with more than 50 identities to test my facial recognition pipeline.

I came across the FaceSurv dataset but it needs a password which can only be obtained by signing and sharing license agreements.

Where can I find a video which has 30-50 unique faces recognisable in surveillance settings?

Or else if anyone can share the password, it will be highly appreciated.

My mother runs a sound healing room, so I rebuilt my old ESP32-S3-BOX-3 chakra firmware as an app for Espressif's ESP-Mosaico (ESP32-S31, 2.16" 480 x 480 touch screen, microphone).

What it does:

* Hears a singing bowl, tuning fork or hummed tone and shows the chakra with symbol, note, frequency to 0.1 Hz and cents (a tuner ring fills as the tone settles)

* The whole screen fades to the chakra's colour, so it works without lamps; Philips Hue (local API), Home Assistant lights and WiZ bulbs follow

* Two reactions: Flow waits 0.4 s for a steady tone and fades softly (made for a sound journey), Strike reacts in 0.13 s

* Notes (A = 440 or 432 Hz), Solfeggio, or your own bowls: strike each of your seven bowls once and it learns them

How it decides it is a tone and not noise: a 4096-point FFT (3.9 Hz bins, the old firmware had 31 Hz), a weighted harmonic sum, then three gates: loud enough, 45 % of the energy on the tone's harmonics, pitch steady within 35 cents. Plus hysteresis at note boundaries so a bowl sitting between two notes does not flicker.

I tested it against free recordings from Wikimedia Commons: single bowls and tuning forks lock one chakra 77 to 99 % of the time; drums, shakers, rain sticks mostly give no colour; a handpan melody changes colour 3 times in Flow and 116 times in Strike. One honest finding: real bowls are often not tuned to C to B. In a 7-bowl chakra video the "root" bowl rings at G#3 (210 Hz), which is why learning your own bowls exists.

The detection is plain C with no dependencies, so the board, Espressif's simulator (fed by the Mac's microphone) and the host tests run the same code. My board is still on order, so it is simulator-tested and builds for the ESP32-S31, but untested on hardware.

Open source (Apache-2.0): https://github.com/leopardcodeai/chakra-detection

Happy to hear from anyone who plays bowls: does your set match C to B, or would you learn it?

Built on Espressif's esp-mosaico-vibe workspace and ESP-GSP simulator; test recordings from Wikimedia Commons (free licences), not shipped in the repo.

Hi everyone!

I’m an AI Engineer with hands-on experience building and deploying AI products, and I’m currently looking for remote AI Engineer / Machine Learning Engineer opportunities.

My experience includes:
1. Computer Vision: Object detection, ball and player tracking, pose estimation, and real-time sports video analytics.
2. Generative AI: LLMs, RAG, embeddings, vector search, and multimodal AI applications.
3. Machine Learning: Model training, evaluation, predictive modelling, and optimisation algorithms.
4.Production AI: Python, PyTorch, TensorFlow, Docker, CI/CD, GPU inference optimisation, and API integration.
5.AI Product Development: Building end-to-end solutions, from data collection and model development to deployment and real-world use.
I’ve worked on AI products in sports analytics, fashion technology, and AdTech.

I’m passionate about solving real-world problems with AI and would love to join a team where I can contribute, learn, and grow as an engineer.

I’m open to remote full-time roles, contract work, and freelance projects.

Spread-spectrum mark: chroma + luma tiles, pilot tiles, Viterbi + CRC. 0 wrong values, 0 false alarms in our 480-copy benchmark; failures (fog, night, B&W + crop) are in the README.

https://github.com/thevijayparmar/Ghostmark-Image

Can someone tell me in detail the difference between CNNs and the software from the sensors from Keyence, Cognex, Zebra. I can't imagine that it's really "AI" what they are using with like no computing power in their tiny edge devices. Can someone explain it to me? Are there approaches to use open source for industry? Thanks!

I cleaned up what we ship for the open eval demo (fruit conveyor inspection — grading only in centre cell C, not full-frame chase).

What changed:

- Release build tuned for size (opt=size, x86-64-v3) -Fruit_Inspector.exe is about 3.8 MB now (was ~5.8 MB on the old drop).

- Public archive Fruit_Inspector_DLL.7z is ~14 MB unpacked tree - CPU ONNX Runtime only in lib/cpu/ (plus bundled MSVC CRT there, no separate VC++ installer for the operator).

- Not in the default demo zip: lib/cuda/, lib/openvino/ - bring your own if you switch EP; default settings.json stays cpu.

- Still in the zip: Fruit_Inspector.exe, trig.exe(TCP client for GOOD / BAD+apple id), three inference DLLs, apple models, licenses.

Unchanged product logic:

- 3×3 grid, stable IDs, Cat/LightGBM only when focus is in C.

- Nim shell+ORT in DLLs -same architecture as before, just less junk around it

Download (eval,non-commercial):

https://github.com/olesha-ai/fruit-inspector-demo

Release 0.10.0 - Fruit_Inspector_DLL.7z.

Linux zip on the same release is unchanged from the earlier port.

If you unpack and run on Win64 CPU - curious if anything breaks vs the old fat bundle.

Best regards

olesha-ai

Hey all, I work on LightlyStudio, an open-source tool for looking through and curating CV datasets.

Embedding plots always bugged me a bit. You get nice clusters, but the x and y axes don’t actually mean anything. So we added text axes: you type a word or phrase for each end of the two axes and the points get placed by how well they match. Put “night” and “day” on x and “indoors” and “outdoors” on y, and you get four quadrants you can actually read. Then you can lasso a corner and see what’s in there.

By default it uses MobileCLIP for images and Perception Encoder for video, but it works well with other multimodal embeddings like Gemma too. You can bring your own.

• Repo: https://github.com/lightly-ai/lightly-studio
• Docs: https://docs.lightly.ai/studio/workflows/embeddings/#text-axes

It’s Apache 2.0. It’s still pretty fresh, so any feedback is really appreciated, good or bad.

I built a face shape detector and decided early that nothing would leave the phone. 468 point mapping, all local, no account.

Few things that surprised me. Lighting and camera angle shift the result more than the model itself does, so most of my work went into handling that rather than accuracy. Also most faces sit between two shapes, a single clean label like "oval" is usually wrong, people respond better to a blended answer.

If anyone else is doing on-device vision work, curious how you handle the angle problem.

\[https://play.google.com/store/apps/details?id=com.ai.face.shape.detector.meface\\\]

Hi!

Some time ago I showcased here Rendersynth, a Blender extension to generate synthetic computer vision datasets without writing Blender Python scripts.

I received some useful feedback so I thought I'd share a small update on the project:

• Synthetic thermography: I've been working on IR-synth, a separate Blender add-on for generating synthetic thermal imagery from temperature fields and radiance models.
• Pixel semantic segmentation: Replaced the previous approach with pixel-level segmentation masks with cryptomatte.
• Quality of life improvements for the other formats (normal maps, depth maps, point clouds, keypoints, bounding boxes, ...)

Source code for both modules is available at:

For the main body: https://github.com/lorenzozanizz/rendersynth
For thermography: https://github.com/lorenzozanizz/ir-synth

The goal is still to make synthetic dataset generation accessible for smaller CV projects, without having to build and maintain custom Blender Python pipelines.

I plan to integrate the two projects into a single suite and write hooks for external frameworks like Blenderproc. If you feel like trying it (Blender 4.5.0+) expect to find some nasty bugs, since its still a prototype.

Any suggestions or criticism are welcome! Especially if you have any feedback or advice on the synthetic thermography component it would be greatly appreciated!

Thank you for you attention!

As a side note, for the demonstration I used free models from SketchFab, 3DAI, CGTrader

We're collecting difficult document pages for regression tests, especially cases where the output looks plausible but a number, row or label is wrong.

One of ours is this receipt. It has six product and packaging rows, plus discounts below three of them. An LLM returned nine item records by treating the discounts as extra products. Our schema had no separate discount field and asked for every line item/product, so the instructions left that interpretation open.

Source: NAVER CLOVA's CORD-v2 dataset, CC BY 4.0, image unchanged.

What image or document do you keep around because OCR or layout extraction repeatedly gets it wrong? Handwritten corrections, faint punctuation and wrapped table rows are a few examples we'd like to test.

Public links or redacted snippets would be useful. Include the line, row or field you wanted, what the output should be, and what went wrong. The reader/model and preprocessing settings help too, if you have them. It doesn't need to be a whole dataset.

Hi everyone,

I'm prototyping a tool for an urban planning consultancy in Germany.

Currently, their analysts spend 2–3 days walking streets on foot to manually spot:

1. Vacant infill lots ("Baulücken"): empty gaps or underutilized surface plots between perimeter buildings.

2. Vertical extension potential ("Aufstockung"): buildings with flat roofs or lower height than neighboring buildings that could take 1–2 additional floors.

We are testing this in Lower Saxony (Hannover). From initial research, I found that our state survey office (LGLN) provides official 3D building models (LoD2) and 20 cm aerial orthophotos (DOP20) completely free as Open Data.

Before building from scratch:

- Are there existing open-source tools, repos, or workflows that leverage LoD2 3D models / aerial rasters to automate infill & rooftop potential?

- Is it better to solve this purely via 3D vector/GIS math (building heights delta, roof shape analysis in QGIS/Python) or combine it with Computer Vision on street-level imagery (Street View / Mapillary)?

Appreciate any pointers, papers, or libraries!

Hello

A month ago I posted v1.0 here (12k images, one 7–12 letter word each). A commenter pointed out that real queries are much shorter, and the production numbers agreed: the median query has 5 distinct characters and a quarter have 3 or fewer. So v2.0 matches that.

WhatFontIs-Bench v2.0:

- 60,000 images, 3,000 fonts (1,059 sans, 1,000 serif, 500 slab, 300 script, 141 mono), same three types and difficulty levels as v1

- the text length, case and digit/& mix are sampled from production query statistics; the strings themselves are COCO-Text v2 strings, not user queries

- labels: font, text, word quad, per-letter quads, camera transform; JSONL + COCO, CC BY 4.0

- a 1,200-image subset that scores within about a point of the full set, for quick checks

Baseline (our own API, open catalogue of 1.2M fonts, top-k by font family), top-1 by number of different letters, pro mode / default mode:

- 1 letter: 48.2% / 43.2%

- 2 letters: 73.8% / 64.7%

- 3 letters: 86.2% / 77.3%

- 4 letters: 89.6% / 82.6%

- 5–6 letters: 92.0% / 86.8%

- 7+ letters: 93.5% / 89.8%

- all 60,000: 88.1% / 82.2%

Above five letters it is as easy as v1; below three, there often isn't enough of the font in the image to separate it from its near-twins. The controlled-glyph diagnostic set (same font and background, only the word varies) is the next one.

Hugging Face (viewer, config v2): https://huggingface.co/datasets/whatfontis/WhatFontIs-Bench

GitHub: https://github.com/whatfontis/WhatFontIs-Bench

Disclosure: I run WhatFontIs, and the baseline is our own system. If you run a model on it, I'd like to see the numbers.

I'm looking for software that can organize hundreds of graduation/event photos into folders for each person.

Some photos contain diplomas with names, which could be used to identify and group the surrounding photos.

Before building my own solution, I'd rather use or adapt something that already exists.

Does anyone know an app, GitHub project, or AI tool that does this or something similar?

Open source, paid, cloud-based — all suggestions welcome!

If anyone has opportunities feel free to reach out

Hello,

Durint the last reviewing round, 2 reviewers suggested adding qualitative results. The task is pose estimation.

How do I chose the examples to include? And to which baseline should I compare to since space is very limited? Should I include a failire case?

Thanks

a custom multi-language OCR pipeline on a single GPU was choking as load grew (~4 detections/sec, 3s+ tail latency). The plan was a second GPU. Instead we optimized serving on the same card and got 55–125/s with ~100ms tail latency, and memory use actually dropped.

I can’t share the specifics since it’s internal work, but I’m curious how common this is. Have you seen teams scale hardware when the real issue was utilization? What was the bottleneck in your case?

Background

I'm coming up with ideas for my CS degree capstone project. I like making short films, so I looked into what kind of software I could make to facilitate the process. One thing I find annoying in post-production is having to go through all the recordings and look for the clapperboards on each video to know what scene, shot and take the video is of. My idea is to train a neural network to find the clapperboard in each recording and extract the information written on the clapperboard to appropriately name the recording. Ex. Avengers_Scene_4_Shot_5_Take_3.mp4.

In short, the neural network would do the following:

1. Detect the clapperboard in a video frame.
2. Read the handwritten text/numbers on the clapperboard.
3. Understand what each piece of text represents

My questions

1. I have not been able to find a lot of videos with clapperboards I could use to train my model. I'm thinking I could create my own videos to train it, so it is trained faster with a consistent clapperboard format. How many would I need more or less to have it not only recognise handwriting but also determine what the numbers indicate (Scene, shot or take)?
2. If it would be too hard to train the AI to do what was previously mention, could I get an already trained AI in handwriting recognition and specialise it in clapperboard data extraction? Would this make my final year project too easy?

I'm building a Quest 3 app (native Kotlin, Meta Spatial SDK) that scans microgreens trays and needs a pixel mask of the plants to measure coverage (plant pixels / tray pixels). I already have Muse Spark working via Meta's Model API for the verdict text, but I can't find a SAM endpoint in the same API — SAM 3/3.1 segmentation, not a chat model.

1.

Does Meta's Model API expose SAM at all? If so, what's the model ID, endpoint, and mask format?

2.

If not, what's the recommended path from a Quest app — a hosted SAM API (Roboflow, Segmind, etc.)? What mask format do those return (mask image, RLE, polygons)?

3.

On-device SAM on Quest is off the table (too heavy) — is a backend service the only other option?

The mask feeds a coverage calculation, so I need actual pixel data, not a text estimate. Thanks!

I rewrote an old Raspberry Pi project of mine that never worked. Now it:

• recognises enrolled faces (YuNet detection + SFace embeddings, cosine match)
• detects the 80 COCO object classes with YOLOX-S via cv2.dnn
• speaks what it sees, with rules so it doesn't nag: greet a person once per 30 s, debounce unknown faces, confirm an object over two passes before naming it
• runs object detection on a background thread so the video and greetings stay smooth

Only dependencies are opencv-python, numpy and pyttsx3. The models download from the OpenCV zoo on first run.

Code: https://github.com/heditrigui/scouter-2

I'd love ideas on making it lighter for a Pi 3 (YOLOX-S at 640 is heavy).

Those percentages are exact matches against 578 hand-checked amounts, dates and ID numbers per condition. Every digit has to be right. Invented numbers are outputs that weren't on the page, totalled across the three conditions. Timings are on an M4 Max.

I ran this because I'm building Fyllyo, a Mac app that fills PDF forms from supporting documents. A missed number can be left for review. A plausible number that wasn't on the page is much easier to overlook.

The test was 17 pages: statements, 1099s, a W-2c, a tax transcript, a prior return and letters. Eight were real statement pages and nine were made for test clients. Each page was tested as a clean image, a simulated scan with tilt, blur, grain and JPEG compression, and a simulated phone photo with perspective, uneven light and blur.

The result that surprised me was Gemma's 73 invented numbers. The outputs looked like plausible amounts. LightOnOCR-2 read every known number correctly in this test and invented none. I ran the 1B model at Q8 with llama.cpp; it is about 1.1 GB.

GLM-OCR also invented none, but sometimes skipped whole blocks. Apple's readers were much faster. Reading in strips improved Vision's exact-match rate, but it also produced 25 invented numbers, compared with 3 for the whole-page pass. A higher match rate by itself didn't tell the whole story.

I also compared five readers in every pair across the three conditions: 30 pair/condition comparisons. No pair agreed on an invented amount in this test. That gave me a reason to use a second reader and flag disagreements, but it doesn't prove two readers can't make the same mistake.

Fyllyo now uses the PDF text layer where it holds the numbers, LightOnOCR-2 for page images, and Apple text recognition as a second reader. Disagreements are shown for review.

The limits matter: 17 pages, one Mac, simulated scans/photos and a narrow exact-number task. This isn't a general OCR leaderboard, and 100% here isn't a guarantee on another document set.

Full setup and results: https://fyllyo.com/blog/ocr-models-tested-on-tax-documents

Disclosure: I build Fyllyo. This post was drafted with AI assistance; the experiment and results are mine.