r/FunMachineLearning

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

Benchmark	Base	Ours	Rel. reduction
Kathbath (read/clean)	15.24	11.49	24.6%
Gramvaani (rural/noisy telephony)	39.07	37.66	3.6%
Lahaja (dialects/accents)	25.09	18.68	25.5%
FLEURS (multilingual)	19.12	16.98	11.2%

Lahaja WER, accents and dialects, where we do best

System	WER
Ours (0.8B)	18.68
IndicASR M1 (Conformer-L)	19.40
Google Chirp	22.30
Azure STT	28.60
Whisper large-v3 (1.55B)	32.40
MMS (300M)	34.40

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.

Code:

https://github.com/Pratik-3706/BadApple\_nn

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.

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.

Most "learn machine learning" advice is either a 40-hour paid course or a scattered pile of blog posts that assume you already know half the material.

I got tired of that, so I built a structured path using only official Microsoft Learn content — the same material behind Microsoft's actual DP-100 (Azure Data Scientist Associate) certification, just organized in the order it should be learned in.

What it actually covers, in order:

1. Core ML concepts (what regression, classification, clustering actually are)
2. Real hands-on coding with Python + scikit-learn — regression, classification, clustering, deep learning
3. Training models at scale with Azure ML — workspaces, compute, MLflow tracking
4. MLOps — AutoML, hyperparameter tuning, pipelines, actual production deployment

That last part is the piece most beginner resources skip entirely — they teach you to train a model in a notebook and just... stop. This goes all the way to "deploy a model to a managed endpoint," which is the actual job, not just the fun part.

Free, self-paced, no signup beyond a Microsoft account. I'm a Computer Engineering student who built this while learning it myself — not an instructor, just organized what I wish existed when I started.

Link: https://learn.microsoft.com/collections/86w0cztk0gjpm4?wt.mc_id=studentamb_523020

Happy to hear what's missing or what should be reordered.

Since I just uploaded the 75th Jupyter notebook to my public GitHub repo I built to maintain and grow interactive lecture notes, I thought about sharing it with the community. I teach AI/ML/NLP and related university courses and provide Jupyter notebooks as lecture notes for a long time with my students. The SELENE repo is the next iteration: consolidating the notebooks across all my courses and improving them towards an open, large-scale, interactive textbook.

The current focus is on the fundamentals, so the target audience are beginners but who are comfortable with basic math (linear algebra, calculus, probability theory). Here is a crude overview to some of the topics (the links go to the HTML version of the notebooks)

• Traditional models: Linear Regression [1,2,3], Logistic Regression [1,2], Multinomial Naive Bayes, Decision Trees / CART [1,2], Random Forests, Boosting Methods (AdaBoost, Gradient Boosted Machines, XGBoost, LightGBM, CatBoost)
• Neural network models: basics / MLPs (incl Backpropagation [1,2]), RNNs (incl. Backpropagation Through Time), Training a NumPy-only MLP
• Neural network components: linear layer, residual connections, layer normalization, dropout, mixture-of-experts
• Transformers: attention mechanism, transformer architecture, positional encodings [1,2,3], masking
• LLMs: language models [1,2], RAG [1,2], fine-tuning [1,2], training an LLM from scratch, efficiency strategies, data preparation
• Optimizers: Gradient Descent with Momentum, RMSProp, AdaGrad, Adam
• NLP basics: tokenization (incl. Byte-Pair Encoding and WordPiece), normalization, lemmatization & stemming, embeddings (overview, Word2Vec [1,2])

There is an overview page for all topics with links to the HTML version, the GitHub repo, as well to open each notebook directly in Google Colab.

Feel free to check it out; hopefully useful to some of you who want to get started. I would be curious what other people other than my students think. I do have a Discord server for the latest updates and handling questions and other issues.

We are also in the process of building a web interface to help navigate topics and suggest learning paths. A first prototype is almost done; see the screenshot for a teaser.

Hello Community,

Standard budget caps tell you that an agent failed, but they don't tell you why (did it loop on a broken tool? did its context spiral?).

To solve this, we open-sourced state-harness (https://github.com/vishal-dehurdle/state-harness); a lightweight Python/Rust runtime guard that tracks a normalised token growth ratio (inspired by discrete Lyapunov stability) and exports failure signatures straight to OpenTelemetry.

Hey guys,

Over the past couple of weeks, I've been working on an Emotion Detector model to classify different emotions from audio . but I ran into a wall and could really use some feedback from people who've built similar stuff before.

data_set =Surrey Audio-Visual Expressed Emotion (SAVEE)

models = SVM, Logistic Regression, and KNN