r/FunMachineLearning • • Dec 27 '25

How to publish a good paper on top tier CS/AI conferences?

7 Upvotes

I am now a year 2 phd students. However, I still can't come up with an idea that's good enough to be presented at a top-tier conference. What should I do?


r/FunMachineLearning • • Dec 13 '25

Robots with double the neurons do better in Robot battles

Post image
7 Upvotes

r/FunMachineLearning • • Dec 06 '25

Seeking feedback on a project that tries to answer a simple question: can a machine spot “mood changes” in a time-series without me telling it what those moods are?

Thumbnail
github.com
7 Upvotes

I’ve been working on a project called RegimeFlow. It tries to spot pattern changes in data over time. Think of it like this: if you watch something every day prices, energy use, storage levels, whatever you often feel the pattern shifts. Calm periods, busy periods, crisis periods. Most systems only notice these shifts when someone hard-codes rules or thresholds. That misses a lot.

RegimeFlow drops the hand-made rules. It looks at the data itself and works out the hidden patterns. It groups similar behaviour together, then trains a model to recognise those patterns going forward. It also gives a confidence score, so you know when the system is unsure instead of pretending it always knows what it’s doing.

I tested it on European LNG storage data from 2012 through 2025 and on fake data with clear pattern changes. It kept finding three to four meaningful “regimes” that line up with real-world behaviour like building up storage, using it up, or hitting stress periods. The model also holds up on synthetic signals, which shows the pattern-spotting part is solid.

The system uses mixtures of statistics and a neural network. It mixes long-range attention (good for spotting slow shifts) with dilated convolutions (good for fast, local changes). An uncertainty layer helps reveal when the predictions look shaky. I ran a bunch of automated hyperparameter searches to keep the results reproducible.

Limitations exist. The unsupervised labels depend on Gaussian mixtures. It needs proper comparisons with other change-point detectors. The economic tests are basic placeholders, not production-grade logic. Better calibration methods could reduce remaining confidence-related noise.

I’m looking for feedback from anyone willing to point out blind spots, oversights, or ways this explanation can be clearer for people who don’t follow machine-learning jargon.


r/FunMachineLearning • • Sep 29 '25

Can I start deep learning like this

7 Upvotes

Step 1: learning python and all useful libraries Step 2: learning ml from krish naik sir Step 3 : starting with Andrew ng sir deep learning specialisation

Please suggest is it the optimal approach to start new journey or their would be some better alternatives


r/FunMachineLearning • • Sep 22 '25

Intro to Quant Trading

Thumbnail
youtube.com
7 Upvotes

I created a Youtube channel a few days ago and thought this video might be useful for this community since you're into machine learning and might be interested in applying it to trading.

Love to hear your feedback; both positive and negative. Please like and subscribe too!


r/FunMachineLearning • • Aug 03 '25

The Forgotten Research That Fixed The Worst Physics Bug! - Two Minute Papers

Thumbnail
youtube.com
7 Upvotes

r/FunMachineLearning • • Oct 12 '24

Having Fun with Machine Learning by Doing the Basics

Thumbnail
youtu.be
7 Upvotes

r/FunMachineLearning • • Sep 13 '24

Getting internship

7 Upvotes

Which technologies should I focus on to increase my chances of landing an internship? Also, what steps can I take to secure one?

So far, I have experience in building websites using React, creating an anime recommender system with machine learning algorithms (scikit-learn), and generating anime faces using GANs in PyTorch. I've also worked with NLP, computer vision, and generative models, participated in Kaggle competitions, and developed a chatbot using DialoGPT.


r/FunMachineLearning • • Jun 10 '24

NVIDIA’s New Tech: Next Level Ray Tracing! - Two Minute Papers

Thumbnail
youtube.com
7 Upvotes

r/FunMachineLearning • • Oct 15 '26

We gave a decision model anytime reasoning

6 Upvotes

We've been working on Span-02. Instead of choosing low/medium/high reasoning, you give it a time budget in milliseconds.

We asked it “land or water?” for 4,050 coordinates. Then plotted the answers.

Reasoning off: 71.9% accuracy.

300ms to think: 84.5%.

That's what you're seeing in the video. The weights are open.


r/FunMachineLearning • • Sep 18 '26

DeepSeek Just Made AI Memory 4x Smaller! - Two Minute Papers

Thumbnail
youtube.com
6 Upvotes

r/FunMachineLearning • • Jun 15 '26

I built CNA: a compact neural archive format (2–3× smaller than SafeTensors). Benchmarks + converters included.

6 Upvotes

Hey all: I’ve been working on a new model‑weight storage format called CNA (Compact Neural Archive).
It’s designed as a practical alternative to SafeTensors and GGUF for storing and distributing neural network weights.

What it does:

  • 2–3× smaller than SafeTensors

  • Multiple compression schemes (ZSTD, delta‑encoding, sparse RLE, codebooks, mixed‑precision quantization)

  • Automatic per‑tensor scheme selection

  • mmap‑based reader with lazy decompression

  • Full metadata system (TLV)

  • SafeTensors → CNA converter

  • CNA → SafeTensors converter

  • GGUF → CNA (basic)

Benchmarks (tiny ~43M param model):

  • SafeTensors: 174 MB

  • CNA (≈3 bits/weight): 75.3 MB → 2.3× smaller

  • Load time penalty is modest (≈25% slower cold load, ~3× slower random access)

  • Sequential reads are still fast enough for most workflows

Use cases:

  • Model archival

  • Distribution of quantized models

  • Research on compression methods

  • A container for future codecs (e.g., transform‑based compression)

Repo:
https://github.com/bassdrum4/CNA

If anyone wants to try it, break it, benchmark it, or suggest improvements, I’d love feedback.
Happy to answer questions or add features people want.


r/FunMachineLearning • • Feb 24 '26

[R] Astrocyte-like entities as the sole learning mechanism in a neural network — no gradients, no Hebbian rules, 24 experiments documented

Thumbnail
gallery
6 Upvotes

r/FunMachineLearning • • Jan 06 '26

Liquid Compute: Reframing Obsolete Consumer Hardware as Disposable Compute Systems

6 Upvotes

r/FunMachineLearning • • Jun 09 '24

OpenAI’s GPT-4o: Can An AI Be Controlled? - Two Minute Papers

Thumbnail
youtube.com
6 Upvotes

r/FunMachineLearning • • May 30 '24

NVIDIA’s New AI: 5,000x Faster Virtual Worlds! - Two Minute Papers

Thumbnail
youtube.com
6 Upvotes

r/FunMachineLearning • • 15d ago

Learn Convolutional Neural Networks Interactively

5 Upvotes

I've been working on a side project that combines my notes from college courses and artifacts that Claude made to help me visualize concepts. It's a way to play around with CNN concepts interactively with knowledge checks at the end of each module to help cement the idea. I'm looking for some feedback if you'd like to check it out:
https://www.receptive-field.xyz/


r/FunMachineLearning • • Oct 12 '26

Could LLM-driven formal math lead to "specification gaming"? A question on the recent Navier-Stokes proof

5 Upvotes

There’s been a lot of interest recently around OpenAI using AI models and Lean 4 to formalize a Navier-Stokes blowup. Regardless of the fluid dynamics, the mechanics of how the proof was constructed got me thinking about automated theorem proving from an ML alignment perspective.

In reinforcement learning, we frequently see specification gaming: when an agent is given a strict target, it exploits every unconstrained degree of freedom to find an extreme edge-case rather than the natural solution we originally envisioned.

Looking at how the formalization satisfied the strict Millennium Prize rules, it seems like something very similar might have occurred:

• To keep the external force legally smooth while canceling the singularity, the construction relies on non-analytic bump cutoffs whose higher-order derivatives explode factorially.

• To stitch the inner vortex to the outer flow, the matching parameters sit on an extraordinarily sensitive knife-edge to keep the system invertible.

• The formal global energy constraint is strictly respected, but unconstrained local gradients blow up.

The proof is completely valid mathematics and compiles without error. But it feels conceptually similar to an agent finding an adversarial loophole in the human-written specification.

I’m curious how folks working on neural theorem proving and formal verification view this:

  1. As automated provers tackle open problems, how do we distinguish between proper mathematical insight and an AI "gaming" the formal definitions?

  2. Does this suggest that our formal mathematical specifications need additional constraints or regularizers when targeted by AI search agents?

Would love to hear your point of views and open an open minded discssion croos disciplanary ! Thanks,


r/FunMachineLearning • • Sep 22 '26

Looking for an active Kaggle community / people to compete with

5 Upvotes

Hey!

I'm looking for people who are actively doing Kaggle competitions and would like to work with others.

Not necessarily looking for a huge server actually, I'd prefer a small group of people who regularly compete, share ideas, discuss solutions, datasets, models, etc.

I'm also building a tech community around AI, ML, dev and builders, so if there are a few Kagglers looking for a place to hang out and compete together, I'd be happy to create a dedicated space for it.

Basically looking for:

  • active Kaggle competitors

  • people learning ML through competitions

  • potential teammates

  • small existing Kaggle groups looking for a home

Does anyone know a good community like this, or would anyone be interested in starting a small group together?


r/FunMachineLearning • • Aug 20 '26

Fine-tuned Qwen3-ASR-0.6B on 1,000 hours of Hindi/Hinglish call audio: beats Whisper large-v3, Azure and Google on accented Hindi at half the size (Apache-2.0)

5 Upvotes

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

BenchmarkBaseOursRel. reduction
Kathbath (read/clean)15.2411.4924.6%
Gramvaani (rural/noisy telephony)39.0737.663.6%
Lahaja (dialects/accents)25.0918.6825.5%
FLEURS (multilingual)19.1216.9811.2%

Lahaja WER, accents and dialects, where we do best

SystemWER
Ours (0.8B)18.68
IndicASR M1 (Conformer-L)19.40
Google Chirp22.30
Azure STT28.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.


r/FunMachineLearning • • Aug 11 '26

I built a symbolic regression framework that rediscovered Planck's law from raw blackbody data — including the dimensionless variable

5 Upvotes

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.


r/FunMachineLearning • • Jul 30 '26

I ran an 56M parameters LLM across 3 microcontrollers using ESP32 boards

Post image
5 Upvotes

Been working on this for a while, splitting a small transformer LLM across three ESP32-S3 N16R8 boards that talk to each other wirelessly via ESP-NOW. No single board could run this model on its own, so the idea was to partition it and let the boards handle inference together in real time.

How it's split:

  • Board A — embeddings + output head

  • Board B — transformer layers + KV cache (in PSRAM)

  • Board C — part of the embeddings table + WiFi web UI

You connect to a WiFi AP hosted by Board C, type a prompt in a simple web page, and watch the text stream out as the three boards pass data back and forth over ESP-NOW.

Some technical details:

  • ~56M parameters, quantized to 4-bit/8-bit to fit in 16MB flash per board

  • Split-PLE design (Per-Layer Embeddings, borrowed from Google's Gemma architecture)

  • KV cache on Board B gives it a 256-token context — actually attends to the full generated sequence instead of token-by-token

  • Trained on WikiText-103, runs 100% offline after flashing

  • Generates short but coherent text (~30 words)

It's an extension of slvDev's esp32-ai (single-board TinyStories LLM) and inspired by Karpathy's llama2.c.

Code, architecture diagrams, and full writeup here (MIT licensed): https://github.com/wladimiravila/esp32s3-distributed-ai


r/FunMachineLearning • • Jul 12 '26

From-Scratch Language Model (custom CUDA and C++ kernels)

5 Upvotes

Hi guys! I'm Nai, and I would really like to share this learning journey of mine with you all.

A few months ago, I got the interest to understand machine learning, I didn't know where exactly to start, but I just did the simplest thing, which is asking. I just searched on youtube "how to make a neural network", that was the farthest thing I knew about machine learning back then. I found the youtube tutorial series "Neural Networks from Scratch in Python" by sentdex.
I was genuinely blown away over how simple it turned to be. I just wondered if I could go a bit deeper, so, I started a C++ project, I tried my best to replicate every piece of math a neural network would need to run in a structured style, with classes, functions and everything. despite some concepts being still ambiguous for me, I kept searching, I found some other youtube videos that cover things like backpropagation deeper so I can understand it better.

Over time, I started taking a hold of it, running a couple of successful experiments, even if slow, they were functional, and I understood them.

After that, I turned it into a library (NeurologicalLibrary) that can be called from Python with Pybind11, I used tkinter to make a simple bounce ball environment just to test the library, and it worked! Just making a neural network that can get variable position of a ball and rectangle then predict where to go, despite simple, made me feel really proud.

That however, was just the below zero beginning, here is the project repo called "NAISENT_workspace" that is basically my entire learning journey work until I finally made my first ever Language Model!

https://github.com/Nai-built/NAISENT_workspace

The repository is under the Apache 2.0 License
Here is a copy of the README file:

this project is made with:
 - DotNet WinForms (C#)
 - Pybind11 (Python <-> C++23)
 - CMake (C++23)
 - CUDA (C++17)


Powershell commands to build the 3 libraries:
cd NeurologicalLibrary/bridge; cmake -S . -B build -A x64; cmake --build build --config Release -j; cd ../..
cd OptimizedNeurologicalLibrary; cmake -S . -B build -A x64; cmake --build build --config Release -j; cd ..
cd CudaNeurologicalLibrary; cmake -S . -B build -A x64; cmake --build build --config Release -j; cd ..


Run showcases:
py SHOWCASES/BASIC_SHAPE_RECOGNITION_CPU.py
py SHOWCASES/BETA_NAISENT_BALL_SEEKER_CPU.py
py SHOWCASES/LSTM_MATH_TEST_CPU.py
py SHOWCASES/NAISENT_ELM_CPU.py
py SHOWCASES/NAISENT_LM_CUDA.py
py SHOWCASES/NAISENT_SLM_CUDA.py
py SHOWCASES/SHAPE_RECOGNITION_CPU.py


Make sure that your terminal's path is set exactly to NAISENT_workspace


The core idea of this project was to learn and understand Machine Learning by building it from scratch
So I've built 3 different libraries in 3 seperate stages:
 - NeurologicalLibrary (NL)
    . The absolute beginning for me
    . I've learned in it how Dense Layers work and how to chain them to make Deep Neural Networks
    . How Convolutional Layers and pools work
    . How Recursive Layers (specifically LSTMs) work
    . And also Activation Functions
    . I've also tipped toes into Graph Layers but couldn't run a successful experiment, so I removed it
    . This library was the first time I made an image recognintion model, and also one that can play a simple bounce ball game
    . Was also the first time I made an optimizer like Adam for training
    . Save/load system for the model .json files


 - OptimizedNeurologicalLibrary (ONL)
    . Here things started to get a bit more serious
    . I've gotten way deeper into how C++ works and how we can optimize its performance
    . I've made faster Dense Layers
    . Faster Convolutional Layers
    . And faster LSTMs
    . Merged Activation Functions into the layers' own activation/gradient functions
    . After that, I got into Transformers (similar concept to Graph Layers, but this time it was successful!)
    . I optimized the training loop for image recognition
    . I made a simple experimental language model that can that it's "NAISENT" with the Transformer system I've made


 - CudaNeurologicalLibrary (CNL)
    . My most precious one so far
    . For the first time, I've got into Cuda kernels!
    . I've learned how Cuda interacts with data through the CPU, Memory and GPU
    . I've learned how to optimize it using shared memory
    . For this one, I went right ahead to build a language model system
    . First, I made Dense Layer Cuda kernels
    . Then I went into Norm Layers (RMS)
    . SCC (Sine/Cosine Cycle) positional embedding kernels
    . Multi-head Masked Self Attention kernels (split into multiple optimized Cuda files)
    . The ability to place sub chains to assemble the transformer architecture properly
    . Adam optimizer in Cuda Kernels
    . And obviously, Activation Functions (Cuda kernels)
    . First time adding the Residual mechanic as a visible variable in the Python side
    . Almost all of these were made in ONL already, but it wasn't with Cuda to use the GPU and it was juggled up together awkwardly. I'm much more proud of this one
    . Was when I made a proper tokenizer system in Python


The libraries are made in C++
and they're used by the Python side via Pybind11
I made the shape recognition and bounce ball environments in C# with WinForms
CUDA to use the GPU in the library CNL

r/FunMachineLearning • • Jun 20 '26

An open-source AI semantic search model in the browser - 7MB, runs on CPU, no server

5 Upvotes

I’ve been toying around with a hobby project - ultra lightweight semantic embeddings on CPU. I made a model + tokenizer + Rust→WASM SIMD inference engine, all in one 7MB package. No API, no GPU, no ML runtime.

Check out the Live demo - semantic search over 2k React docs, fully on-device → https://ternlight-demo.vercel.app/

I used an aggressive BitNet-style ternary quantization on stacked encoders, distilled teacher model into a ternary student with QAT. A few highlights:

  • fast embedding on CPUs ~2ms per embed, ~500 emb/s

  • 0.84 Spearman vs the MiniLM teacher model

  • Rust implementation of forward pass inference engine (no torch, no ONNX), includes ternary weights, embedding table, and tokenizer

  • Compiled into webAssembly, ubiquitous runtime

Planning to open source this, would love your thought... is this something you'd find useful as an npm package?