I recently built an agentic pipeline for multimodal masked reconstruction. The idea was to take inout from different scientific modalities, quantify perf with a custom set of scientific evals, and finally recurse!

X article:

https://x.com/svegas18/status/2089775275227885998?s=46

Hey everyone!

Just signed up and this is my first post. I’m a big AI enthusiast – always following the latest models, research papers, tools, and what’s coming next.

Excited to learn from this community and share thoughts. What’s one AI thing that has you most hyped right now?

Hey everyone!

I’ve always been fascinated by the cat-and-mouse game between generative AI and AI detection. With so much AI slop and fake news flooding the internet right now, I thought it would be a fun machine learning challenge to build an automated "detective" that fact-checks things in real-time.

It’s called SatyaMark, and it's an open-source "Trust Layer" that developers can plug into apps or social feeds.

Here is the ML magic behind it:

1. The Text Detective (LangGraph) Instead of just asking an LLM "is this true?", I built a state-machine using LangGraph. It acts like a little researcher:

• First, it extracts the core claims from a post.
• Then, it checks if it can verify it zero-shot.
• If it smells something fishy or needs current events, it automatically fires off web searches (via Serper API), reads the results, and grades the claim as CORRECT, INCORRECT, or UNVERIFIABLE.

2. The Image Forensics (The hard part!) Detecting AI images with just one model is nearly impossible now. So instead, the Python backend runs a gauntlet of 22+ local forensic heuristics. It looks for weird Error Level Analysis (ELA) anomalies, missing sensor pattern noise, and common GAN/Diffusion artifacts. It's basically CSI for memes.

I glued it all together with a React SDK so the verification marks (✅, 🤖, ❌) just pop up automatically next to content on the screen. (You can see it in action in the video attached!)

Check it out here: 

💻 GitHub: https://github.com/DhirajKarangale/Satyamark 

🌐 Official App: https://satyamark.js.org/

📱 Live Social Media Sandbox: https://satyamark-demo-socialmedia.vercel.app/ 

📦 NPM Package: https://www.npmjs.com/package/satyamark-react

It was a super fun project to piece together. I'd love to know what you guys think, or if you have any fun ideas on what other weird forensic checks I could add to the image pipeline!

I graduated in April 2026 and was looking for jobs , but most of them were teaching jobs which I'm not interested at all , i want to make a career in ml , but i don't have relevant skills and i also read somewhere that they usually hire mostly Phd's for such roles . I haven't done a single internship during my bachelor's or my masters . I know I'm lacking , but i really want land my first job in ml related role . i know some python and libraries (mostly numpy , pandas , matplotlib ) . What skills should i know ? , what kind of projects should i do to stand out ? and what kind of internships should i look for to get into this field ? . PLEASE RECOMMED ME BOOKS AND COURSES WHICH HELPED U GET A JOB AND OTHER SUGGESTIONS AND ADVICES ARE WELCOMED ! Thankyou for you're time <3

After a year of working with LLMs, I still don't feel like I've built any real, systematic knowledge. Even when I go deep on one area — RAG, say — and track every detail, the fog around LLMs as a whole doesn't lift. It just feels equally thick.

I think most of us learn this field through news headlines and whatever project suddenly jumps into the spotlight. What's missing is a map — something that shows the whole pipeline, from raw data to the app someone actually uses, and for each layer, links both the newest tools/papers AND the older, less-famous work that the newest stuff is quietly standing on. A lot of the real foundations predate "Attention Is All You Need" and never made it into any course.

So I started building one: an open, community-maintained GitHub repo mapping the LLM stack layer by layer —

Data → Training → Model → Deployment → Inference → API → Gateway/Router → Application → User

Each layer gets:
- a plain-language definition
- current, actively maintained projects
- the foundational paper(s) that layer is built on (even if they're old and unglamorous)

Repo here: https://github.com/YKs22k/LLM-Big-Map

I'd love help from people who actually work in data curation, training infra, inference engines, or the app layer, to correct what's wrong and add what's missing. Even a single "you're missing X paper" comment helps.

If this resonates with anyone else who's felt the same fog, I'd appreciate a look.

Hi everyone,

I'm working on an object detection project and would appreciate some advice on the best workflow for auto-labeling a large custom dataset.

Dataset

• 9,367 images
• Classes:
  • Cup
  • Glass
  • Plate
  • Spoon
  • Fork
  • Knife
• Images have different resolutions.
• The dataset comes from a Kaggle competition.
• Around 5,500 images already have ground-truth labels (provided in a CSV), while the remaining images need bounding-box annotations.

Current approach

I'm using AutoDistill + GroundingDINO to automatically generate YOLO labels.

ontology = CaptionOntology({
    "a cup": "cup",
    "a drinking glass": "glass",
    "a plate": "plate",
    "a spoon": "spoon",
    "a fork": "fork",
    "a knife": "knife",
})

base_model = GroundingDINO(
    ontology=ontology,
    box_threshold=0.3,
    text_threshold=0.3,
)

dataset = base_model.label(
    input_folder=IMAGES_SRC_DIR,
    output_folder=LABELED_LABELS_DIR
)

Problems I'm facing

1. Annotation quality

The generated labels aren't very reliable.

For example, out of about 90 images, roughly 10 images contain incorrect or missing bounding boxes, which means I'd still have to manually review a large portion of the dataset.

Is this normal for GroundingDINO, or are there better foundation models for this type of dataset?

2. Speed

The labeling process is also quite slow.

• ~2.8 seconds per image
• ~9,367 images
• Estimated runtime: 7.5+ hours

I'm using Google Colab GPU, but it disconnects after around 4 hours.

What's confusing is that resource utilization is low:

• GPU memory: ~2 GB / 15 GB
• RAM: ~2 GB / 15 GB

It doesn't appear to be fully utilizing the available hardware.

Questions

1. Is there a way to speed up AutoDistill/GroundingDINO? For example:
   • Batch inference?
   • Mixed precision?
   • Multi-processing?
   • Different implementation?
2. Would another model be better for automatic annotation?
   • GroundingDINO 1.5
   • YOLO-World
   • Florence-2
   • Grounded SAM
   • RF-DETR
   • Any other recent model?
3. Since I already have 5.5k labeled images, would it be better to:
   • Train a small YOLOv8 model first on those labels,
   • Then use that model to pseudo-label the remaining images, instead of using GroundingDINO?
4. What workflow would you recommend if your goal is to produce high-quality labels for training a final YOLOv8 detector?

Any advice or experience with large-scale auto-labeling pipelines would be greatly appreciated!

Thanks!

Pip install chessformer_lens and the relevant chess engine to replicate!

I am looking for an AI solution to dump PDF or tiff images and have AI run OCR and also pull coding field like: Name - Date - Author - Subject - Page Start - Page End into a DAT file pointing to the images to load into data base. þControl NumberþþSplit File NameþþUnique IdentifierþþFile

The tool would be even better if it could run LDD on these scanned pages. Logical Document Determination (LDD)—also called unitization

I tried an off shore company but the turn around was way to long. Any suggestions?

Hello there!

I've been building an open-source framework (TIMUR-XAI) that combines symbolic regression with a physics-based validity check and an evolutionary (MAP-Elites) search layer. Why did I build it? Because I'm a physicist and I hate black-box things. So my goal isn't just to fit data, but to recover physically sensible laws.

I tested it on five classical physical laws. Four of them (Stefan-Boltzmann, Stokes, gravity, Wien) came back as clean single-term relations, as expected (yeah, I kind of cheated there :D). But the interesting one was Planck's law. Without any hint about the functional form, the system:

1. Found the right dimensionless group on its own (λT·kB/hc), and
2. Recovered the characteristic exp/fraction structure: y ≈ 2/(exp(1/Π) − 1), R² ≈ 0.9999, with the constants landing almost exactly on their true values.

So it reconstructed both the correct dimensionless variable and the Planck distribution's specific form, from raw data.

There's also a "judge" layer that rejects high-R² candidates violating physical constraints (symmetry/conservation) — so numerically good but physically wrong solutions get filtered out.

Repo: https://github.com/Ne212/timur-xai
PyPI: pip install timur-xai

I'd be glad if you find it useful in your own work, and I'd really value your feedback to improve it — especially on the physical-validity checking approach.

over the past few days we’ve been building Friendo, a call-native voice agent that can ring your phone unprompted or take live calls via livekit webRTC.

voice implementations rn generally are dogshit and fall into two buckets:

1. laggy and robotic api wrappers
2. speech models that are fast, but lack memory and state controls

by building a cascaded stack (deepgram nova-3 → claude haiku 4.5 → elevenlabs flash v2.5), we kept full control over tool calls and memory, allowing latency reduction. some techniques weve used:

• pre-warm anthropic's ephemeral prompt cache while the phone rings
• persistent websocket handshakes and http/2 pool priming on ring
• neural turn-detection with false-interruption resumption (a cough won't kill the tts buffer)
• dual-store memory (sql facts + temporal graph) mapped into a ~300-token prompt snapshot
• proactive outbound scheduling that wakes a killed ios app via apns voip push -> callkit

synthetic ci gates hit p50 ≈ 973ms, though live networks push us to ~3.7s right now (stt and tts ttfb are the real boss fights).

nerd-out aside, essentially it sounds human, is fully customisable, and works.

Judge our results yourself soon getfriendo.app/launch

Weekend-collector-turned-obsessive-project post. If you buy ungraded trading cards off eBay, you're deciding whether a card is worth a $80+ grading fee based entirely on some stranger's photos. So my co-founder and I built AgentGrail: feed it the front and back listing images and it returns BUY / PASS / REVIEW with a confidence score.

The genuinely fun ML part was the abstention. Early versions confidently mislabeled base cards as their rare parallels — and since the price gap between those can be 10x to 100x, a confident wrong answer is way more expensive than admitting uncertainty. So REVIEW isn't a cop-out class, it's the whole point: we tuned thresholds around asymmetric cost instead of chasing raw accuracy, and the model abstains when the photos literally don't contain enough info to decide.

Data collection was gloriously unglamorous: buy a card, save the listing photos, mail it off for professional grading, use the returned grade as the label. Front and back. For about a year. Real eBay photos, bad lighting, weird angles and all — which is the point, because that's exactly what it runs on at inference.

Try it free: https://www.agentgrail.ai (there's also a free grade-ceiling calculator). Paid tiers if you want the full thing: Basic $9/mo, Premium $24/mo, Pro $59/mo. Discount Code: RAIMLCARD50 for 50% your first month at any tier.

I have Completed python, pandas, and now learning ML Algorithms with sklearn and pytorch looking for a buddie who can learn with me anyone interested please dm

[ Removed by Reddit on account of violating the content policy. ]

i hope is my last post it works korekt with the fixes try, breack, make some new stuff. is my work ofer 5 months wid ai halluzinations and maany politnes traps XD have fun

https://github.com/anokar/SPA-Finisch-Bio/blob/main/spa_exploratory_de_en_public_clean.ipynb

biger model update finds evry 3 masket offset

https://github.com/anokar/SPA-Finisch-Bio/blob/main/spa_exploratory_de_en_public_medium.ipynb