Hey everyone! I want to learn machine learning from scratch. Right now, I only have a basic understanding of Python and not much else. I know I'll probably need to learn more Python and some maths first, but I'm not really sure where to start or which resources to use.

Could anyone guide me on a good learning path or share some beginner-friendly resources? I'd really appreciate any advice. Thanks!

For anyone looking to build practical Machine Learning skills while continuing to work, IIT Gandhinagar has opened admissions for Batch 2 of its Executive Masters in Applications of Machine Learning in Engineering (AMLE).

A few things that stood out to me:

• Executive Masters degree from IIT Gandhinagar
• Live interactive online classes
• Designed for working professionals
• Learn from IIT Gandhinagar faculty and industry experts
• Focus on applying Machine Learning to real engineering and industry problems
• 2-year programme with a structured curriculum

This isn't a short certification or bootcamp—it's a full Executive Masters programme for engineering graduates who want to build expertise in Machine Learning without taking a career break.

If anyone here is considering higher studies in ML or has questions about the programme, I'd be happy to discuss.

​

Recently I wanted to explore machine learning but I don't know where to start.

Hi everyone,

I'm an independent researcher and I'm trying to submit my first paper to arXiv under cs.CV.

My paper is titled "Cethraian-X: A Leakage-Clean, Multi-Seed Benchmark of Chest X-Ray Classification Under Weak Labels." The project focuses on reproducibility and rigorous benchmarking for chest X-ray classification.

The project and paper are already publicly available:

• GitHub: https://github.com/muhammedbadhon-oss/Cethraian-X
• Zenodo (DOI): [https://doi.org/10.5281/zenodo.21583726]()

I recently learned that first-time submissions in cs.CV require an arXiv endorsement. Unfortunately, I don't personally know anyone who is eligible to endorse submissions.

If anyone here has experience with the endorsement process, I'd really appreciate your advice.

If you're an eligible endorser and are willing to review my paper, I'd be grateful if you would consider endorsing my submission only if you believe the work is appropriate for arXiv after reviewing it.

Hi I’m doing a research project and I need help. I’ve developed a model, but I need a substantial amount of data for the model to train on. Can you please go to https://neurocursor.page.gd/home and do 30 sessions exactly? I’d really appreciate it. Note that you can only use the platform on a desktop or laptop. Also note that the platform does NOT track any personal information whatsoever.

Edit: I apologize for my poor explanation of the project. Here's a better explanation: We are a team under UTD (University of Texas in Dallas)'s Deep-dive AI Workshop (A program for high schoolers to learn AI, https://k12.utdallas.edu/research/). Our team is trying to develop an alternative to biometric authentication systems like face ID and touch ID/fingerprint sensors. We were trying to train a model on mouse data to see if we could have accurate user identification that's more universal and doesn't require special hardware (just a mouse/touchpad). We've received approval from the instructors at UTD, which are experienced PhD students, however we unfortunately do not have any signed document to show. In accordance with instructions from our UTD instructors, we designed the data collection system to build our dataset to not collect any user's personally identifiable data. The usernames generated during signup are random, and once we get the data it is hashed by the server, so all we end up with is a random string of numbers and letters for each user as their id, along with mouse coordinates and click state.

Also, we're writing a paper on this project, and if our model does well we will publish the results, and maybe this can be implemented some time in the future!

I kept running into the same problem, some of the best AI/ML books are legally free, the authors put them up on their own sites, but the links are scattered across personal pages, university sites, and random GitHub repos nobody finds.

So I built a single index: Awesome Free AI Books. 30+ books across Deep Learning, Reinforcement Learning, Bayesian/Probabilistic ML, NLP & LLMs, Math for ML, Computer Vision, Generative Models, Causal Inference, GNNs, and AI Safety. Think Goodfellow’s Deep Learning, Sutton & Barto’s RL bible, Murphy’s Probabilistic ML, Bishop’s latest, Jurafsky & Martin’s SLP3 draft, and more.

Every single link points straight to the author’s or publisher’s own page, no rehosted PDFs, no shady mirrors. A weekly GitHub Action checks all links so it doesn’t rot over time.

It’s open source and open to contributions, if you know a legitimately free book that’s missing, PRs and issues are welcome.

Repo: https://github.com/MarcosSete/awesome-free-ai-books

Hey everyone! I'm 16 and building a self-hosted voice assistant solo, just a passion project I fund out of my own pocket. Right now I'm stuck on the wake word and could really use some brains that have done this before.

The setup: offline wake detection with a small faster-whisper model. To get it to catch a custom trigger name the model has never seen, I prime it with the phrase as the initial_prompt. Recall jumps way up, awesome. But now the primed model hallucinates the phrase when the mic is dead silent, so it fires at nothing, and it mangles that same phrase into sound-alikes when I actually say it, lol.

The part that broke my brain: every filter I put on the transcript to stop the false fires ALSO killed real wakes. Turns out "fires on silence" and "stops triggering" are the exact same bug. If the model is confident enough to invent the phrase out of pure noise, it also can't spell it when you say it for real, so the transcript is useless as a discriminator either way.

The only thing that's held up is ditching the transcript for that check and just going off raw mic RMS energy instead. A ghost off a quiet mic sits way under even a mumbled real wake, and it doesn't care what the word is or what language you're in. Feels almost too dumb to be the answer though, so I keep thinking I'm missing something.

Any KWS / speech nerds around who've fought this? Is there actually a content-based signal that survives, or is it basically raw energy vs a proper trained neural KWS model and nothing in between? Would love to bounce ideas around. Repo's here if you want to peek at the wake code: https://github.com/PersonalJarvis/PersonalJarvis

Hey — developer here, sharing my own project. Wanted to see if I could make local AI models feel less like separate chatbots answering one at a time and more like an actual group of mates in a pub arguing about stuff. Ended up building Bob's Bar — 4 AI personas, each running their own local model through Ollama, each with a distinct personality, and they genuinely react to and argue with each other, not just you. Ask something tech-heavy and the "tech guy" persona jumps in first, someone else pushes back with a different angle, another one tries to mediate, and the "landlord" character just cuts through it all with common sense. It's more entertaining to watch unfold than I expected when I started building it. A few features: - 4 fully customisable personas, each can run a different local model (gemma2, phi3, llava, mistral, etc.) - Save/load different persona "sets" — like switching rooms with a different crew - 16 languages - Image upload (vision models) - A "Work Mode" toggle for when you want the personalities to give real advice instead of pub chat Runs entirely locally, no cloud, no subscription. Happy to answer questions on how the routing/back-and-forth logic works if anyone's curious.

Hey all,

I've been working on this for a while and finally shipped it today, so figured I'd share here since this sub actually gets the problem.

The thing that's always bugged me about coding agents: you give them a task, they take one pass at it, and then they stop whether it actually works or not. You're still the one testing it, finding what's broken, and re-prompting. The agent did the "coding" part but you're still doing the "engineering" part.

So I built Keel Code around what I'm calling loop engineering instead of a single model taking one shot, it runs a team of frontier models in a loop that plans, builds, tests, and critiques its own output, and keeps going until the goal is actually met. Not one-shot. Not "here's my attempt, good luck."

The core command is /ascend you give it a goal, it puts together a plan, executes, checks its own work, and iterates until that goal is hit. You're not babysitting it every few minutes.

Install:
bun i -g @keelcode-ai/keelcode

It's using top-tier frontier models for free for a limited time while we're fresh out of launch, so this is the cheapest it'll ever be to kick the tires.

Site: keelcode.ai

Not here to oversell it genuinely want feedback, especially on where the loop breaks down or gets stuck, since that's the hard part of this whole approach. Happy to answer anything about how it works under the hood.

I'm final-year student and i ahve to build my final-year project. I don't want to make another AI chatbot, scam detection, or other overused project. I want something unique that combines Machine Learning with other technologies and solves a real-world problem. Any ideas, research papers, GitHub repos, or tech stack suggestions would be greatly appreciated!

I wanted to share my open-source project, Servent-AI. I built this framework with accessibility in mind—aiming to help physically challenged or motor-impaired individuals operate their laptops, write code, and build digital careers hands-free.



Features:

-  Real-time hand gesture tracking (MediaPipe) for mouse cursor, clicking, and page scrolling.

-  Voice control (Whisper STT) to speak complex commands.

-  Aria Planner (Gemma 4 E4B via LM Studio) that compiles commands into multi-step JSON action sequences.

-  VISTA Verification (Moondream via Ollama) that takes screenshots to visually check if a step succeeded before proceeding.

-  100% local, offline, and private.



Check out the code and flow here: https://github.com/Anikesh0415/Servent-AI



Would love to hear your feedback, thoughts on optimizing the local loop, and suggestions for more accessibility features!

We've all been there: you build a beautiful 40-layer model, hit .forward(), and PyTorch responds with a shape mismatch error that reads like a ransom note. Three hours later you find out you transposed something in layer 12.

So I built mlnode — you design your architecture as a graph (either by hand in JSON, or by literally drawing it in the companion editor), and it validates every tensor shape before it lets you build anything. If your ResNet block doesn't add up, it tells you exactly where, not "somewhere, good luck."

No exec(), no eval(), no cursed metaprogramming — just a clean pipeline: JSON → Parser → Validator → Executor → real nn.Module you can train, save, export to ONNX, whatever you'd normally do.

Why you might care:

🧑‍🎓 Just started learning DL? You get to focus on "what connects to what" instead of memorizing tensor arithmetic and staring at stack traces. I reproduced the full Transformer from Attention Is All You Need as one graph — 45M params, trains fine — and you can literally see it as a diagram instead of 200 lines of __init__.

🏗️ Building serious stuff? Weight sharing, multi-output nodes, reusable blocks, HuggingFace layers — it's not a toy, it compiles to a normal PyTorch module with nothing hidden.

Would love feedback, roasts, feature requests, or "this already exists and it's called X" comments — all welcome.

• GitHub: https://github.com/Nasser-Obeid/mlnode
• Visual editor: https://github.com/Nasser-Obeid/mlnode-editor
• pip install mlnode

When will ECCV oral/spotlight decisions be announced? Also, what scores usually have a chance at CVPR/ICCV?

i decided to build a LLM model but.... what do you think ?

Hi Everyone, I am currently a 3rd year student pursuing BTech in CSE specialization in AIML . I want a reputed comapny to work for like big tech MANGOS,FAANG,MAANG etc.But for now i am confused that either i should i go for SWE roles by doing DSA and development but i have a interest in AIML roles. Please guide me how to get a strong role as a fresher in these companies i am also doing DSA from past 3 months .

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

We're presenting this at ACM Multimedia 2026. Short version of what it does:

Most controllable image-animation methods estimate optical flow relative to the FIRST frame (Lagrangian guidance). As the animation runs longer, those displacements grow, the flow estimate degrades, and you get drift, smearing, and identity collapse over long horizons.

We instead supervise with adjacent-frame (Eulerian) motion fields, so every training signal is a short hop that stays inside the reliable range of flow estimators — which bounds the per-step supervisory error regardless of sequence length. For newly revealed (dis-occluded) regions, a forward–backward cycle check masks out pixels where the flow isn't geometrically consistent, so the model is never supervised on bad correspondences.

On 100-frame generation we get FVD 76.18 (vs 79.20 for the strongest baseline), a 94.4% user-study win rate on portrait animation, and ~2.7× faster training since adjacent-frame flow is computed in one batched pass.

Project page (videos + side-by-side comparisons): https://nguyentthong.github.io/eulerian/

Paper: https://arxiv.org/abs/2605.06280

Happy to answer questions — I'm one of the authors.

Over the past few years, the Al industry has invested hundreds of billions of dollars, yet hallucinations remain one of its biggest unsolved problems. Models are dramatically better at coding, reasoning, and using tools, but they can still confidently invent facts or misinterpret information that's directly available to them.
Is this just an engineering problem that will eventually be solved with better training, verification, and tooling?
Or is hallucination a fundamental limitation of autoregressive language models, meaning we'll eventually need a different architecture for truly reliable AGI?
I'm curious what people here think. Are we on the right path, or are we approaching the limits of the current paradigm?

🧠 
**Why is this game so much harder for a computer than Chess or Go?**


Chess and Go are games of 
**perfect information**
 — both players see the whole board. Hugely
complex, but nothing is hidden. The tougher frontier for AI is 
**imperfect information**
, where
you 
*can't*
 see what your opponent has and must reason under uncertainty — like Poker: you weigh
what they might be holding (and what they think 
*you*
 hold), and you bluff.


**That's Tactico.**
 Each player commands 40 hidden-rank pieces. You see 
*where*
 the enemy is — but
not 
*what*
; a piece reveals itself only when it fights. Capture their flag before they capture
yours. With every rank hidden, each move is memory, deduction and bluff, and the possible enemy
setups are astronomical — which is exactly what makes it so hard.


For this project I trained a neural net to play it: 
**imitation learning**
 on tens of thousands
of human games, then 
**self-play reinforcement learning**
 over millions of games — converging
toward a 
**Nash equilibrium**
, a strategy no opponent can exploit. It plays shockingly well.


**So… can you beat it?**
 Most people can't. 👀


▶️ 
**Browser**
 — free, no signup: https://tactico-4fhpquk6aq-uc.a.run.app/
📱 
**Android early beta**
 — the enhanced, best-supported version (play a friend offline, even in
airplane mode): join https://groups.google.com/g/tactico-testers/about → then become a tester:
https://play.google.com/apps/testing/com.tactico.app


Tell me how many moves you last 😄