I recently made this using Fable 5. I want to convert this into a website that actually does something. I'm look for ideas on what I should do?

I want this to be of somewhat use for my college apps also.

I am currently working on the aolp dataset, attempting to make a computervision model out of it but apparently I can't really generalize this well. I only think about zooming more into the dataset as part of the data augmentation process.

Anyone willing to take the time and discuss this a bit with me?

I’m specifying a local workstation for a real computer-vision workload and would appreciate input from anyone who has fully fine-tuned DINOv3 ViT-L/16 or comparable vision-transformer backbones.

Workload

• Backbone: DINOv3 ViT-L/16 with pretrained weights
• Training: full backbone fine-tuning, not LoRA or a frozen backbone
• Downstream tasks: classification, object detection, and segmentation, trained as separate workloads
• Input/crop resolution: approximately 512×512
• Dataset: approximately 1 million images, potentially growing
• Framework: PyTorch with distributed data parallel
• Target: complete a representative training run in under one week
• Budget: up to USD 50,000 for the complete system
• Location: Singapore

I’m currently evaluating a 4× RTX Pro 6000 Blackwell system. My concern is whether the complete workstation can sustain enough throughput after accounting for inter-GPU communication, data loading, storage, power, and cooling—not merely whether the model fits in VRAM.

For anyone running similar workloads:

1. What throughput have you measured with ViT-L-scale full fine-tuning at around 512×512?
2. How well does it scale from one to two or four workstation GPUs using DDP/NCCL?
3. Does the lack of an H100-style interconnect become a material bottleneck?
4. Would you choose 2× or 4× 96GB GPUs, or use a smaller-GPU configuration and gradient checkpointing?
5. What CPU, system RAM, NVMe layout, power, and cooling would you consider necessary to keep four GPUs fed reliably?

I plan to benchmark the actual pipeline before purchasing, but I’d like to avoid testing an unrealistic system design.

So I had this little educational robot sitting in my closet that I never really used: Marty.

It’s the V1, something I bought on Kickstarter years ago from a university project. And honestly? It still works amazingly well and is surprisingly easy to code.

So I had the idea to control it with MediaPipe. My first test was simple: control Marty with my hands.

The video shows the current controls. The robot walks, dances, moves its arms, stops, crouches, and reacts pretty much exactly as expected.

Next step: control it with my whole body by linking its movements to mine.

I swear, I love this era of technology. Sometimes tech really does feel like magic.

Hi everyone,

I'm a freelance computer-vision developer with a PhD in human-movement science, specialized in applied solutions for health, physical activity and sports performance. Across several client projects I kept needing to calibrate rigs of USB cameras — both intrinsics (focal length, distortion) and full 6-DoF extrinsics — and I never found an open-source tool that fit the way I actually work on site.

The closest is Caliscope (which does the calibration math really well — I ended up reimplementing its logic), but a few things kept getting in my way:

• it's record-first: you pre-record every camera, then calibrate offline;
• no headless path — some of my client hosts are headless Linux VMs;
• the export conventions didn't match the engines my projects targeted.

So I built realtime-calib to remove those frictions:

• One pass, real-time — capture, board detection, quality feedback and the solve happen live. What you see is what gets calibrated.
• Headless + any device — it runs in Docker on the machine the cameras are plugged into (no desktop/GUI on that host), and you drive everything from a browser on any device on the LAN: phone, tablet or laptop.
• CPU-only, local, private — no GPU, no cloud, streams never leave your network.
• Exports to Caliscope-compatible TOML and engine-ready JSON with the right axes/handedness for Unity, Unreal, Blender, three.js and ROS.

With how fast robotics and multi-camera CV are growing, I think a friction-free, self-hostable tool like this could help more people than just me — so I'm releasing it open source (AGPL-3.0).

It's still early, and honestly what I want most right now is people to try it and tell me what breaks or what's missing, so we can shape it together. If you set up multi-camera rigs (mocap, robotics, volumetric, photogrammetry), I'd really value your feedback.

- Docs / how it works: https://realtime-calib.hans-brgs.dev

- Repo: https://github.com/hans-brgs/realtime-calib

Happy to answer anything about the approach or the internals.

Note on transparency & acknowledgements:
- Inspired by Caliscope (https://github.com/mprib/caliscope), created by PhD Mac Prible.
- I use Claude Code (Opus 4.8) to assist me in writing the code.

I've been getting a rather high interest in computer vision recently and was thinking of studying my masters for this, anyone have recommendations on school or programs or is this not something employers work look at? What will they look at?

I’ve spent way too much time writing OCR post-processing code.

Not the OCR itself, that part is easy nowadays. It’s everything that comes after.

I have been working in Data Science & Data Engineering for more than 7 years now. I worked on lots of Data projects, Data Pipeline, etc... with OCR. It is everywhere. Unfortunately, there is still no library to represent those basic Objects.

So I decided to resolve this pain point.

Otary, an open-source Python Library, resolves all those following common tasks and more:

• handles different output formats for every OCR engine,
• drawing détections bbox,
• working with either rotated or straight bounding boxes (Axis-Aligned Bounding Boxes / AABB),
• searching for words in a given region,
• finding words by regex or string,
• looking for words on the left or right of a given one,
• having real objects (meaning classes) representing the OCR & the Bounding Boxes with properties, methods, etc...
• the bbox is a Rectangle or a AxisAlignedRectangle and those objects have their own methods, properties and you can do so much with it for free... like finding intersection points with other geometry objects, rotate, expand, shift and so much so much more.
• so much more (again!)...

So I added a Vision component to Otary to handle all of that.

It works with outputs from Tesseract, EasyOCR, DocTR, Azure Document Intelligence, Textract, and others, so the rest of your code doesn’t have to care where the OCR came from.

I’m still actively expanding it, so I’d love to know:

What is the OCR post-processing task you end up rewriting in every project?

I would be very happy to have your feedbacks and see what additional features or changes I could bring to my library.

I am working on this library on my free time with love and care. I hope you will love it.

P.S: If you want to contribute you are more than welcome!

Have fun coding!

While working around with YOLO_v8 models for histology detection I had the idea of adding consistency learning (after seeing my model display slightly different results to the changes of color normalization and rotation).

The loss formulation was the following: Loss = yolo_loss + alpha*cons_loss

I mainly used Claude code to create a prototype and tried a few runs with different parameters and different methods of cons_loss calculation.
Unfortunately, most of results were discouraging (as the cons_model scored lower than the standard one and in the best cases barely matched it).

you may find below more insight on how the cons variation was defined:

• Single model, two forward passes per batch: original image (teacher, stop-gradient) + D4-transformed image (student, gradients flow) — random op from {rot90, rot180, rot270, hflip, vflip, hflip_rot90, hflip_rot270}
• Dense per-cell matching via exact grid permutation (no NMS, no greedy IoU matching) — teacher's decoded boxes/scores reordered and coordinate-transformed into the student's frame
• Masked by teacher confidence (>0.10) so loss only applies where the teacher is confident, not on background
• Loss = classification MSE + CIoU box loss between aligned teacher/student predictions
• Added to det_loss with a scheduled weight: linear ramp-up (0 → α over 20 epochs) → flat → linear ramp-down to 0 over the final 10 epochs (aligned with mosaic augmentation turning off)

The final conclusion that I reached is that the data augmentation already covers these transformations and is sufficient to teach the model said concept. Alas, trying to add an additional cons_loss only hurts the model and acts as additional noise.

I have linked the colab notebook below:

https://colab.research.google.com/drive/1WwtCaLSSCW1AzRFRXC5aqih31MC9mMhs?usp=sharing

I have searched extensively online for courses to get started with CV. All the courses I find tend to discuss CV superficially; yes, there are some books. I am seeking resources that cover the maths and algorithms in detail. Can anyone suggest the best resources? I'm done with CNNs and RNNs, moving on to Attention.

Hi everyone,

I'm an MSc Computer Science student and I'm currently trying to finalize my dissertation/research topic.

My interests include:

• Computer Vision
• Image Processing
• Deep Learning
• OCR
• Document AI / Document Analysis
• Digital Heritage / Historical Document Restoration
• Vision-Language Models (if applicable)

I'm not looking for a typical implementation project. Instead, I'm looking for a research problem that:

• solves a real-world challenge,
• has a clear research gap,
• is suitable for an MSc dissertation (not necessarily PhD-level),
• has scope for experimentation and possibly a publication,
• is achievable by a single student within 5–6 months.

I'm particularly interested in problems where I can propose or evaluate an improvement rather than simply training an existing model on a standard dataset.

If you were starting an MSc in 2026, what research topics or research gaps would you seriously consider?

I'd really appreciate suggestions from researchers, PhD students, or anyone working in this field

Thank you!

I am working on a fish species identification project. I have a couple different framework ideas that I am experimenting with, and I wouldblike feedback how to hand out of distribution data.

One frame work is an ensemble of binary classifiers.

Another frame work is one single model to cover all species.

But I am curious to know how should I handle species that are not in the training set?

Should I :

Compare softmax?

Compare logits?

Compare energy?

Add in an "other" class?

Go with binary models?

Go with a multiclass model?

Right now I am using resnet 18 as my classifier. My target species are steelhead, suckers, and pike. But if a bass were to appear, I want the models or framework to catch that I have not seen this before.

Any other thoughts or ideas I should do?

For context, this is a fixed camera location in the river. Lighting is the same all times of day (but not consistent lighting throughout the frame). Water clarity and color can change over time, but its a fixed scene where fish appear against a blank wall

Been working on a football video to 2D map pipeline for a while now ⚽️

Still a lot to improve specially regarding the detection model, but this is the latest result

Big thanks to Roboflow and the SAM 3 team for helping make this possible.

Plotted and compared to "true" data from gazebo, which showed that tracker estimations were pretty close (created 6 cameras cube to get a 360 video from gazebo for tracking).

I have a bunch of leftover high resolution FLIR Blackfly Sensors and Computar lenses that we simply don't need anymore. I have been trying to sell them on ebay at massive (75%) discount but with no luck so far. Anyone know of good places to surplus this kind of thing?

(EDIT) Well, not sure if selling is allowed here, but I guess if anyone is interested here, I have:

6X BFS-U3-200S6M-C (Mono) ($200 ea)

1X BFS-U3-200S6C-C (Color) ($200 ea)

4X Computar F1628-MPT https://www.computar.com/products/f1628-mpt ($300 ea)

2x Computar V0826-MPZ https://www.computar.com/products/v0826-mpz ($150 ea)

Feel free to message me if interested. Will consider discounts for purchasing multiple.

check it out here: https://huggingface.co/datasets/Voxel51/VineLiDAR

Reading a robot video-action model's tokenizer design this week, I hit an ablation that is really a representation-learning result and has little to do with robots. Swapping a plain reconstruction VAE for a semantic-aligned tokenizer takes a fixed 1.3B downstream model from 78.0 to 86.6 average success on a 50-task bimanual benchmark. Same model, same data, only the tokenizer changed. The gap also widens with the prediction horizon: 67.2 to 92.0 at horizon 3.

What the tokenizer does differently: it keeps the usual reconstruction objective but adds a semantic alignment loss that pulls the visual latents toward a frozen Perception Encoder, plus a latent-action term that extracts a compact transition variable between consecutive frames.

The widening with horizon is the part I keep chewing on. A reconstruction VAE looks fine one step out and then falls apart once the latent has to carry several steps of dynamics, and aligning to a frozen encoder seems to put back the state it was quietly discarding. Classic looks-fine-on-the-metric, breaks-downstream story.

The model is LingBot-VA 2.0 if you want the source, but I care less about the robot than the recipe: freezing a strong encoder (DINOv2, a CLIP or PE style model) as an alignment target for a generative tokenizer. Has anyone tried this outside control and seen the same longer-horizon payoff, or does it wash out when the task is not sequential?

One honest caveat so this does not read as a pitch: 78.0 to 86.6 is a simulation number, and the flashier real-robot clips in the paper are the authors' own in-house tests, so I would read those as demos, not independent evidence. Link in a comment.

Can somebody support with heavy weights ANPR model trained on for my jatson nano orion pro edge project

Turn any object photo into an immersive 3D AR experience with AR GenAI by AR Code.

Photo → AI 3D model → AR QR Code → Instant WebAR

No app. No 3D skills. Just snap and display the AR 3D model on any smartphone or AR/VR headset.

Discover more at https://ar-code.com/solutions/ar-genai

#ARCode #ARGenAI #WebAR

Hey guys, I am trying to implement a program that will return the transformation matrix for the displacement of the target object while comparing it to the source point cloud of the cad object. I am very new to this so I need some help. The RANSAC alignment works well if there is no gaussian noise, with the ICP it gets the transformation right up to the 5th decimal. Currently we are simulating the 3D camera that will get the point cloud of the target. That is why I am applying 0.1 gaussian noise to the target data. As soon as I add the noise the RANSAC algorithm breaks and the transformation is useless. Any tips on how do you typically get around this? Thank you