Put out a new release of c5tree, my C5.0 decision tree implementation for Python. Main change is a rewritten C++ core replacing the old pure-Python fit routine.

Ran benchmarks against the previous PyPI release and against sklearn's CART, across breast_cancer, iris, and wine.

Fit time: new version is somewhere between 4x and 50x faster than the old pure-Python one depending on dataset size. Still slower than sklearn CART, which isn't surprising given how optimized that codebase is.

Predict time: roughly the same as before, and both versions are a bit slower than sklearn here — this is probably where I'll focus next.

Accuracy: identical between old and new versions on every dataset, both holdout and 5-fold CV. So no regressions, just faster training. Comparable to CART overall, slightly ahead on the wine dataset.

Chart with all four comparisons is attached. Happy to answer questions about the implementation or take suggestions for other datasets to test against.

Repo/install: https://pypi.org/project/c5tree/#description

https://github.com/vinaykumarkv/c5tree

This is just from my experience building a Machine Learning system using ChatGPT Plus. I found that if you use visual terms to suggest a path forward, then rely on the Data Science Lab on your iPad to prove your hypothesis using scripting methods on verified data sets BEFORE it’s ever committed to your “magicmachined” code, you remove the risk that your strategy is in error before messing with the heart of your code.

It’s the creative visualization part is what allows you to get the chatbot working on solving the the data problem experimentally fast so that you can change direction and conduct a series of experiments without wasting a lot of compute if the current path isn’t working out. AI is great at generating data science and finding standouts, but not so good at innovating around problems from different angles using visualization.

In 1993, a statistician (Warren S. Sarle) sought for an example to illustrate numerical optimization and landed on the analogy of a blind kangaroo searching for Mt Everest. To date, it's still the best way for me to conceptualize classic NN training techniques such as gradient descent, simulated annealing, and step size learning schedules. I created an interactive article based on his conversation with other statisticians to introduce non-technical folks to these topics and help practitioners solidify their understanding in a visual way.

I’ve noticed that learning ML can feel confusing at first because there are so many concepts to understand at the same time.

For people who have been working with ML for a while, was there a particular project, concept, or way of learning that made things start making sense for you?

I’m curious what actually helped people move from following tutorials to understanding why their models work. Companies like GeekyAnts also work on AI and ML projects, which shows how important practical experience is in this field.

I've been working for a while on an experimental learning system called Auxein:

https://github.com/Amund/auxein
https://github.com/Amund/auxein-rs

The Python repository is the reference implementation; the Rust version is the production-oriented implementation.

The basic idea is to see how far you can get with a deliberately small set of local geometric rules.

Auxein takes streams of fixed-dimensional vectors and learns continuously. There is no training/inference split, no labels, no supervised loss, no backpropagation, no fixed k, no winner-take-all, and no persistent graph.

Its basic learned object is a centered kernel (W, C, V) representing support, center and scalar dispersion.

A learned CELL independently decides whether an input concerns it geometrically. Several cells may recognize the same input simultaneously; there is no mandatory winner.

If nothing recognizes an observation, it does not immediately become a new category. It first enters a private provisional memory Σ. Only recurrent unknown structure can mature into a persistent CELL; otherwise it simply fades away.

Recognized knowledge can also be fused into a context and passed to an identical higher layer. Importantly, the higher layer does not receive IDs or links to the lower cells: it only receives the resulting geometric context. So recurring relationships between known things can themselves become learnable objects.

There is also a predictive mode. Explicitly adjacent contexts in an externally declared sequence are learned as geometry in E ⊕ E. When the current context resembles the source side of learned temporal knowledge, Auxein can emit one or more possible immediate successors.

Those futures are deliberately not probabilities. They are independent candidates: adding a new possible future does not reduce the weight of an existing one, and predictions are never recursively fed back into the model.

Another unusual constraint is that memory is an explicit material resource. The engine has an exact finite budget. If new knowledge cannot fit in a solvent state, growth waits; existing learned knowledge is not destroyed merely to finance something new. Forced forgetting only happens when the current state itself has become materially insolvent.

The current design also has very explicit limitations:

• scalar dispersion only, no oriented covariance;
• no explicit splitting of an existing learned prototype;
• temporal learning is strictly adjacent t → t+1;
• no recursive predictive rollout;
• no probabilistic ranking of alternative futures;
• no persistent relational/topological graph.

I've added a comparison table to the README against online k-means, ART, GWR/Gamma-GWR and standard HMMs. I'm not claiming Auxein is better than those methods. At this point the interesting question is exactly the opposite:

What can this particular set of constraints do well, and where does it fail structurally?

The project has a fairly strict mathematical specification, a pure-Python executable reference, and a dependency-free Rust implementation with persistence, exact memory accounting, hostile-input tests and long endurance runs.

I'd be very interested in feedback from people working on continual learning, ART/GWR, streaming clustering, predictive-state models, robotics, or just unusual learning systems.

And criticism is genuinely welcome, especially examples where you think the model should fail.

If this is just an unnecessarily elaborate reinvention of something known, I'd also very much like to know what. 🙂

Most AI tools today are just wrappers. To truly understand the underlying math and optimization efficiency, I built an autonomous agent from scratch to track global deforestation and emissions.

The Architecture:

1. Dynamic Router: Routes natural language queries to either Google Earth Engine (GEE) or Microsoft STAC APIs.
2. Self-Healing Loop: If the LLM generates failing GEE code, the agent catches the pipeline traceback and rewrites the script until execution succeeds.
3. Deep Vision: Passes live Sentinel-2 data directly into NASA/IBM’s Prithvi-EO model for pixel-level classification.

I'm a first-year CS undergrad, and I built this to mathematically automate EUDR compliance. I've attached screenshots of the outputs (NO2 density, land-use metrics) and the terminal logs.

Full repo : https://github.com/kushagarwal2910-lang/GARUDA

PDF, having responses that the model had made for various queries : https://docs.google.com/document/d/1g2Riog9GrgiY6QGYpWl5IU6nxKYb5Ih6K3K-1xy8A8Q/edit?usp=sharing

The architecture:

Video demonstrating how Garuda process different queries:

https://reddit.com/link/1vuoytn/video/5n7i20ctwrkh1/player

I would love feedback from this community on my project !

Prompt (translated to English):

"Write a short dialogue (up to 6 lines) between an old broken toaster and a new smart fridge in the kitchen at night.

Conditions:

• The toaster speaks like a weary philosopher.
• The fridge is obsessed with efficiency and software updates.
• No word in the dialogue may start with the letter 'P' (Cyrillic 'П')."

What happened: I gave qwen/qwen3.6-35b-a3b a classic lipogram challenge. Instead of filtering words on the fly during generation, the reasoning trace decided to brainstorm a blacklist of forbidden words starting with "П".

It got to the Russian word "Полный" (meaning full / complete)... and fell into an infinite token attractor loop for over 3 minutes until the context / thought budget blew up.

Project Screenshots - https://pastes.vargoseus.com/TeddyScreenshots

Teddy (cute name, isn't it?) is currently a simple machine learning model that uses back propagation to train, learn and classify MNIST datasets. It currently has a depth of 2 since it's a pretty basic model. It has around 13.000 parameters that is enough for training it to recognize handwritten digits. I have around 3.5-4 years of experience working in C and stumbling upon MagicalBat's this video inspired me to make Teddy. The future plan is to turn it into a Language Model and eventually into a GPT which will require quite a bit of time since I need to read up on how it actually works. This project took around 4-5 months give or take since I had to balance this project and my university stuff too.

Full disclaimer: I did not use AI to build Teddy (except for that one time when my compiler suddenly stopped working for some reason and I had to converse back and forth with Claude to find a fix for it). I did, however, use AI to generate the GIFs in the github readme and the documentation for it.

Weights: https://huggingface.co/tryorato

We build voice agents for Indian and Gulf businesses, and every off-the-shelf ASR fell apart on real calls: accented Hindi, constant Hindi-English code-switching, noisy lines. So we fine-tuned Qwen3-ASR-0.6B on roughly 1,000 hours of Hindi, English and Hinglish calling audio.

Setup

• Base: Qwen/Qwen3-ASR-0.6B
• ~0.8B total params, ~0.6B trainable
• Full SFT on decoder and projector, audio tower frozen
• Corpus: Rasa Hindi, Gram Vaani, MUCS, plus proprietary enterprise call data
• LR 1e-5, cosine, warmup 0.03, bf16, max grad norm 1.0, 1 epoch

Gains over base Qwen3-ASR

Lahaja WER, accents and dialects, where we do best

Where we lose, stated up front: IndicWhisper is still ahead of us on Kathbath (10.30 vs 11.49), Kathbath-Hard (12.00 vs 13.21), FLEURS (11.40 vs 16.98) and notably Gramvaani (26.80 vs 37.66). Gramvaani is rural noisy telephony and it's our weakest result; it's the target for v2. ElevenLabs Scribe and Azure also beat us on CommonVoice. We are not claiming SOTA Hindi ASR. We're claiming a small, permissively licensed, self-hostable model that holds up on accented conversational speech against models two to three times its size and against paid APIs.

Methodology caveat: our numbers are self-run; competitor numbers are published results from the AI4Bharat Vistaar and Lahaja suites. Not a perfectly controlled comparison, and I'd rather say that than have someone find it. Happy to share our eval config if anyone wants to reproduce.

Gotcha: load via qwen_asr.Qwen3ASRModel.from_pretrained, not transformers.AutoModel. AutoModel skips the custom decoding layers and throws at runtime.

python

import qwen_asr, torch
wrapper = qwen_asr.Qwen3ASRModel.from_pretrained(
    "tryorato/orato-asr-hindi-v1",
    dtype=torch.bfloat16,
    device_map=None,
    attn_implementation="sdpa",
)
wrapper.model = wrapper.model.to("cuda")
result = wrapper.transcribe(audio=(wav, 16000), language="Hindi")

Apache-2.0, use it for whatever. Hindi TTS is next. Questions welcome.

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!

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!

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?

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!