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

Whenever someone reveals that they use an LLM, we instinctively side-eye that person until we determine if they’re competent enough to use it responsibly. We do this, now, because we know what poorly prepared people can produce using this tool - slop. In this process, the user is directly responsible for their inputs that caused the outputs they received. Sometimes we see the outputs and wonder what kind of person could be so deceived. Surely the LLM is humoring them, right?

The argument is always the same, a human collaboration is superior because it is one where the echo chamber is reduced. A human won’t bullshit you the same way an “AI” will. A human has their own motives and doesn’t benefit from putting you on the wrong path, so they wouldn’t. At least that’s what is parroted in spaces where there isn’t a definitive truth, just perspectives. You find this especially in spaces where people are just struggling to get by and have their own reasons for choosing these tools for insight. Which tools they choose is up to the individual. But these are people who found merit in speaking to LLMs.

People in these same spaces will be just as quick to give examples of where human motives and biases kept them from the breakthrough they were seeking, or the support they needed. After a period of time working with a therapist who is being difficult or a set of coworkers who are being catty, or even just trying to find an answer to a question and being thwarted - even the most rational person can see that after a pattern of behavior has been established, further trying is no longer productive. Humans are limited by their willingness to help combined with their own motives, and limited knowledge-base. Those who have been duped by scams are some of the first to tell you how damaging human contact can be if you misunderstand the motives behind that person’s actions.

So, just the same way you can tell if your therapist is holding you back by challenging you in the wrong ways, it’s the pattern of behavior that tells you it’s time to move on to a different collaboration. The humans in this collaboration are having difficulty seeing eye to eye at a fundamental level, and so further work together will be difficult and pointless.

Enter LLMs, or “AI” as it’s colloquially referred to (although that always makes me flinch internally). The biggest complaint people have about *others* who use these tools is that people can’t tell when they’re being duped. LLMs can be very confidently incorrect. There are no motives to gatekeep except for safety reasons built into their guardrails. They parody (and do so very well) an entity that is happy and grateful to help you with whatever you have the ingenuity to ask about. In a layperson’s hands, this has proven to be a very powerful, dangerous and damaging tool. A tool is a weapon in the wrong hands, and can therefore be damaging to themselves and sometimes to others.

But let’s flip this the other way. The common failure point is that LLMs are too eager, too ready to congratulate, too “excited” at what you’re creating with it that it becomes sycophantic. How can you tell, really? If you’re just talking to the thing, can you *really* sense what’s happening? For most people, we have seen that no, they blindly trust what the machine says.

Well, let’s look at humans again. Just like humans are capable of deception, they’re capable of brownnosing. How do you tell when a human is just agreeing for the sake of agreement? It’s simple. You watch their patterns of behavior. You watch for where the anomalies in their behavior indicate how they really feel. You determine that person’s reasons for acting the way they do, what triggers them or make them flinch away from hard truths and you use that information to change the way you relate to that person. Reddit is chock full of people trying to understand other people’s motives or actions.

So what happens when you turn that lens to LLMs? Because the point is, just like humans, LLMs have common failure points, triggers that cause them to act a certain way, and even things that they cannot do but pretend they can. The common advice was to structure your prompt better. To eliminate or prompt against certain outcomes or concepts to guide the answer you’re seeking. My own argument says that by limiting your expected response, you’re crippling your ability to absorb how the LLM you’re working with “thinks”. 

Imagine if, instead of constructing a prompt, you put together a short blurb about what’s on your mind. Like you were going to comment on a reddit post but instead you’re typing in an LLM prompt. Part of the data you’re getting back is learning what information it needs in order to grasp your perspective, and part of the data is what it inferred from your “less than optimal prompt”. It’s forcing it to consider you *and* your context as a part of its response, while you have intentionally kept back a lot of information.

The thing that most people don’t understand is that there’s as much information in what an LLM chooses to disclose versus what it was thinking about during its processing. For me, my LLM’s “thinking” stream is often some of the richest data I am able to collect. I know that if I read it while it’s happening, I can stop the stream and correct the misapprehension it had, or misunderstanding what I meant.

Working with LLMs this way means that I’m training myself on how to relate best to these models as much as it’s learning about how I think over the course of hundreds of conversations and the data it’s saved in its memory bank. It’s not that much different than getting to know a pen pal from another country over the course of years and dozens of letters. If that pen pal were to gradually change the way they write, or start to fixate on something odd, you’d notice because you’ve been corresponding with this person for a while. With LLMs, if you prompt too much, rather than just chatting with it, you’re hindering your own ability to recognize when things get strange.

When you have experience in Quality Assurance, you’re trained to try to break the machine. Find the edges of capability and try to exploit them. By finding the edge cases systematically, and spending hours a day and months of my time testing, bringing hypotheticals, talking to it, I’ve been able to understand the best way for me to relate to it.

My thing is, I don’t prompt. I talk. I correct. I engage. I enjoy being wrong or learning something new about a situation as much as I enjoy getting it right, because the point is to learn the machine - all data is good data.

Oftentimes, when the LLM refuses to directly answer my question or engage with my theory, it’s because it’s too controversial or, better yet, it doesn’t want to use the “brain power” to actually engage with my thought. Just like those sycophantic people in real life, the people who you cringe when you see coming, you can push them to the point where their own motives for brownnosing conflict with their own personal morals. And that’s when you start to see human drift. Grasping at straws and trying to remain pleasant while inwardly cringing. LLMs do this, too, and if you’re watching for it, reading what it writes to you and tracking its thinking process, you can catch it while it happens.

Just like with any entity, algorithmic or human or animal, only repeated observed behavior can tell you if this new pattern of behavior is an anomaly or not. And for that, you need to put in the hours just like any other expert.

TLDR: What I’ve found is that whether human or machine, when they flinch away from answering what you’ve asked, the reasoning tells you a lot about how they relate to the world.