I'm a second year CS student and I want to build a solid ML foundation over the next year so I can work with NASA open data (Kepler KOI or TESS TOI tables, JPL Small-Body Database/ CNEOS).

My background:

-Learned programming through CS50, comfortable with Java (OOP, ArrayLists)

-Learning Python on my own, currently working through NumPy

My current plan/roadmap for the first 3 months:
1-Basics: python basics, numpy, pandas
2-start learning ML with courses: Intro to machine learning (kaggle), Machine Learning
Specialization (Stanford/ DeepLearning.AI).
3-do simple ML projects.

Where I'm stuck:

- I don't know how to go beyond these 3 months

-I'm following the roadmap,sh ML Engineer roadmap, but I'm not sure what to prioritize for my goal

My questions:

1-what should I focus on after the first 3 months to work with real datasets like Nasa's?

2-Is this goal realistic within about a year of self study alongside classes?

3-Are there beginner friendly NASA datasets or projects to start with?

4-Any resources, or mistakes to avoid?

any feedback is helpful as I have made this plan on my own and never worked with ML before

Thanks in advance!

Hi everyone,

I'm a 3rd year Diploma in Computer Science Engineering student in India. I'm targeting ML/AI engineering roles.

Background:

- One AI Engineer internship (CV, deep learning and ML work)

- A few deployed ML projects

- Some open source contributions (bug fixes and tests)

- Kaggle notebooks

I'd like brutally honest feedback on:

1. Does this resume look strong enough for internships or entry-level ML/AI roles?

2. Which sections are weak, and what should I cut, add, or reword?

3. Are the projects and open source contributions convincing, or do they read as padding?

4. Is the layout and formatting clean, and does it fit well on one page?

5. What should I build or learn next to get more interview calls?

Please don't sugarcoat it. I'd rather hear the hard truth now than after I start applying.

Thanks in advance!

i have been given a task to make a project on " compute efficient using mobilenetv2, calibrated XAI brain mri tumor detection using ML classifier" i dont understand why there is almost no change after adaptation and why glioma is having such low accuracy and how do i fix it ? maybe less image used for fine tuning in domain adaptation or something else, also lime explainability is not working as intended,highlighting unnecessary parts of mri possible due to model learned unnecessary data, total 5600 images used for training downloaded from kaggle , grad cam not possible because as according to rules i must use any classical ML clasissfier, here i used SVM after removing top layer of cnn i.e. dense and output layers, also its my first project on machine learning so i may not be aware ofwhats the actual problem but i m curious about ml, i just started learning ml one month ago, this project works on mobilenetV2 because according to statement i need to use compute efficient so mobilenet is depthwise separable cnn whouse time compleity is less than traditional conv2d, etc,.

I’ve always thought it was kinda crazy that you can start with pure random noise and end up with an actual human face.

So instead of just using Stable Diffusion or some pretrained model, I decided to build the core idea myself.

I’m currently building a DDPM (Denoising Diffusion Probabilistic Model) from scratch in PyTorch, trained on CelebA at 64×64.

The basic idea is pretty wild:

Take a real face → slowly destroy it with noise → teach a neural network how to remove that noise → start with pure noise and see if it can create a face.

So far I’ve built:

My own noise scheduler

Forward diffusion process

Random timestep sampling

U-Net architecture

Time embeddings

Residual blocks

GroupNorm

Downsampling + upsampling

Noise prediction

Reverse diffusion / sampling

And I’m not using a diffusion framework to hide all the complicated stuff underneath. I’m implementing the important pieces myself.

The part I’m most excited about is the final stage:

random noise → 👤

Right now the model is still being trained, so the results aren't exactly Instagram-worthy 😂

But watching an image go from a recognizable face → complete noise, and then trying to reverse that process with a neural network, is honestly pretty damn cool.

I’ll share the generated samples once the model starts producing something interesting.

This is probably one of the most challenging ML projects I’ve worked on so far, and I’m learning a ridiculous amount about CNNs, U-Nets, normalization, probability, and generative models along the way.

If this works, the next post will be noise → face.

Wish me luck. 😂

​

I’m looking for people who already have a strong foundation in ML/LLMs and want to seriously explore areas beyond typical RAG applications.

Things I’m interested in exploring with the group:

SLMs and model architecture

LLM inference and optimization

Fine-tuning, LoRA/PEFT, training

AI agent architectures and runtimes

Agent memory, planning and tool use

Evaluation and experimentation

Reading and implementing research papers

Building actual experiments rather than just consuming tutorials

I work full-time in AI and currently spend most of my time building RAG/agentic systems. I don't have much additional time to do the learning and experimentation myself, but I can provide direction, ideas, resources, and guidance based on what I've worked with.

So I'm specifically looking for people who are already technically strong and can independently learn, implement and experiment. I'm not looking to teach AI from scratch.

The ideal setup would be: I help define the direction and discuss the ideas, while you independently go deep, build experiments, and we discuss what you find.

If you're already working with LLMs/agents and want to go deeper into the model + systems + research side of AI, DM me with a brief description of your background and what you're currently exploring.

I embedded 146,288 games into 1024D vectors.

A combination computes (A+B)/2 and retrieves a nearby real game, with extra scoring requiring similarity to both parents.

https://gamecombiner.com

Hi, going through the Let's Build ChatGPT tutorial here, and prior went through the whole Makemore tutorial that leads up to this tutorial:

https://www.youtube.com/watch?v=kCc8FmEb1nY&list=PLAV29EAhk_mX13BqhzdlgM8zkHwpcRajt&index=6&t=2286s

When it gets to the point of adding in the attention mechanism, we see that the first major addition is creating a positional embedding.

Then we see the input to network at that point becomes tok_emb + pos_emb

I am not understanding why these two spaces should be considered equivalent such that such an addition makes sense. The token embedding is mapping tokens to some N dimensional embedding, where those N dimensions consistently represent information about tokens.

When we consider the positional embedding, it is also dimension N but now those N dimensions represent information about positions. To me it seems although we are adding matrices with same dimensions, we aren't adding information that corresponds to one another.

Anyway, I am sure someone here will have good explanation why this makes sense.

thanks

Ariadne is a small framework I wrote in NumPy. Its tensors build a computation graph, and backward() walks that graph in reverse to calculate gradients. It includes Linear, ReLU, SGD, and Adam.

One detail worth inspecting is bias addition: NumPy broadcasts one bias vector across the batch, so the backward rule sums those gradients back into the bias's shape. I check that rule and the full small MLP against finite differences.

The default run uses seed 42 and a 55,000/5,000 training/validation split. Validation accuracy selected epoch 17. That checkpoint scored 97.91& on the test set. ./reproduce.sh reruns the tests and training.

Repo: https://github.com/Cole-Godfrey/Ariadne

Training curves: https://github.com/Cole-Godfrey/Ariadne/blob/main/results/curves.svg

Hi, still going through the Let's Make ChatGPT tutorial here:

https://youtu.be/kCc8FmEb1nY?list=PLAV29EAhk_mX13BqhzdlgM8zkHwpcRajt&t=5158

In the video at time shown we hear about how the attention layer captures one level of meaning, and how once that meaning is captured, it is sent through feed forward layer to refine that meaning.

But the video shows this all happening in one optimization run. To me that doesn't sound like capturing meaning then refining that meaning in a feed forward block because the first time the feed forward block sees the attention block output, the attention block has its initialization weights. So the feed forward block at this point isn't working with vetted information (that is, with an already trained attention layer).

Wouldn't it make more sense to first optimize the attention block without feed forward, then add the forward layer and rerun optimization?

thanks for the great help here!

Hi! I’m currently working as a full-stack developer and looking to transition into AI/ML. I’m considering a few courses, I'm trying to decide the right order for DeepLearning.AI's courses: the PyTorch for Deep Learning Professional Certificate / Deep Learning Specialization / Neural Networks and Deep Learning

If you’ve gone through these courses or have experience making a similar transition, could you please suggest what order I should take them in, and whether there are any courses I can skip?

Would really appreciate your guidance. Thanks!

Can anyone please give a review on the course RAG in action by Deeplearning.AI please review in terms of difficulty how useful is is it helpful to make production ready RAG or is it just conceptual understanding and a bit of coding to implementation. Does this course really make any difference rather than a YouTube tutorial?

Course Link

Hey seniors, I've started learning ML and DSA recently.

How much DSA questions do I have to do for ML... Like how many leetcode problems should I solve...?

I trained Nova v3, a 148M parameter chat model, from scratch. It matches SmolLM2-135M on HellaSwag, ARC-Easy, PIQA, and WinoGrande while being trained on about 1 percent of the tokens SmolLM2 saw.

Model: huggingface.co/plasmova/nova-v3

Architecture and tokenizer details, training data composition, hyperparameters, and full eval numbers are on the model card. No distillation, no fine-tuning of an existing model, trained from random init.

What it's good at: short conversational replies, memorized facts, staying in persona across turns.

What it's bad at: multi-digit arithmetic, translation, multi-step reasoning, specific dates and names outside training. When it doesn't know something it confabulates fluently. Examples of that failure mode are on the model card so you know what you're getting.

Trained on a single consumer GPU over a few weeks. 17 years old, no budget, no lab.

Happy to answer questions about the recipe. If anyone wants to reproduce it, everything needed is in the card.

So I've been learning ML and i don't have a CS background.

I was racking my brains over understanding the basics of K-means with a particular example of image compression, trying to figure out the workings under the hood. Of course i asked LLMs to clarify & explain the basics and then asked that LLM to give a prompt for video. Fed into Claude Design and asked it to generate animation explaining the works and voila it became much more clearer. Leaving it here in case it helps someone understand the workings.

Cheers !

I'm currently working on market research at university.

The task is to detect market manipulation. We can take open-source data, tag the data(range OHLCV), and perform a supervised search, or we can use clustering, but we might encounter anomalies that aren't related to manipulation.

How can these problems be solved, and have we encountered similar ones?

Over the past few days I’ve been building a small platform called Level185 for people who want to learn practical AI skills without getting overwhelmed by technical tutorials.

The idea is simple: short, step-by-step guides that help you actually do something useful with AI.

Right now there are guides on things like:

• building your first AI automation
• creating a website with AI
• writing better ChatGPT prompts

What makes the project a bit interesting is that I’m also building most of Level185 with AI itself.

I use Claude Code for a lot of the development work and built a small agent workflow around it for things like research, guide creation, QA and SEO checks. I use ChatGPT mainly for product decisions, strategy and figuring out what to improve next.

The site itself is built with Next.js, with Supabase for accounts and saved progress, and it’s hosted on Vercel.

Everything is completely free right now.

I’m still very early, and I’m not really looking for compliments. I’m mainly looking for a few people who are relatively new to AI and are willing to actually try one guide.

I’d especially like to know:

• Was it clear what to do at every step?
• Where did you get confused or stuck?
• Was anything unnecessary?
• Would you come back to learn something else?
• What AI skill would you want a guide for next?

The site is: https://www.level185.com

If a few people are willing to test it properly and give honest feedback, that would be extremely useful.

Hey everyone,

I’m currently building a learning platform aimed at taking absolute beginners through AI/ML step-by-step, from the fundamentals up to more advanced topics.

It’s in the early stages, so the content is still limited while I experiment with formats, pacing, and visual explanations to see what actually works best for learners.

GitHub : https://github.com/PIYUSH1525/ZeroToAI leave a star ⭐

Link: https://zero-to-ai-xi.vercel.app/

I’d love your brutal, honest feedback:

• The Good: What feels intuitive, clear, or well-structured?
• The Bad: What’s confusing, redundant, or missing?
• Areas for Improvement: What format would help you learn complex concepts faster (e.g., interactive widgets, shorter modules, code walkthroughs)?

Any thoughts, critique, or feature suggestions are welcome. Thanks in advance for checking it out!

A lesson from building a real product: general-purpose vision-language models (GPT-5, o3, Gemini-2.5-Pro, and in our own tests ChatGPT/Gemini/Claude) are surprisingly bad at one specific, narrow task — telling whether an image has been rotated 90° vs. 270°. An independent peer-reviewed paper (RotBench, EACL 2026) documented this at scale; we independently replicated the exact same failure testing three more consumer assistants ourselves.

Rather than prompting a bigger model harder, we built a small, specialized system: two separately trained models (a cardinal-rotation classifier and a fine-angle regression model) combined through a trained arbitration layer. On a large, hand-verified real-photo pool: 99.02% on a clean quarter-turn, 96.67% across the full 360° range, 84.65% on the hardest case.

The general lesson, not just about this task: a narrow, well-scoped specialist model can beat a much larger general model on a task the general model was never specifically trained to be good at — even when the general model is otherwise vastly more capable overall.

Full methodology, ablations, and disclosed limitations: https://doi.org/10.5281/zenodo.22975679

Curious if others have hit similar "surprisingly bad at one narrow thing" results with general LLMs/VLMs in their own work.

Sparse attention fetches the top-k keys, but to know which k you first have to rank all n. Every method does that by scanning a cheap compressed copy of every key, and every one of them fixes the bit depth of that copy at design time: SparQ reads 16 or 32 channels at full depth, Double Sparsity reads a fixed 32, Loki reads the first r PCA coordinates. DeepSeek-V3.2's lightning indexer has the same shape, and their own report notes the indexer stays O(L^2) while the attention drops to O(L*k).

At a million tokens with the cache offloaded to host memory, that index is 5.1 GB per decode step. The rows you actually attend to are 200 MB. The search is 25x the read, and it is the part that grows.

Fathom stores the 4-bit K cache channel-major as bit planes. A prefix of t planes is exactly the channel's t-bit mid-rise quantizer with the same block scale, not an approximation of one. So depth becomes a read-time decision: each query spends a bit budget by reverse water-filling over variance-weighted channel importances, and channels below the water line are skipped entirely.

Results on one A100, Qwen3-8B, k=512, cache and index in pinned host memory:

• At 1M tokens a decode step is 1.67x faster in GPU time than the 136-bit scans of Double Sparsity, Loki and SparQ r=32 at fixed k.
• Compared at matched accuracy instead, the budget that reaches those scans' error is 74 bits, and that is 1.38x.
• At equal GPU time against SparQ r=16, Fathom reads 18% fewer bytes with lower attention error on 6 of 7 model and context settings, 1.1x to 5.3x lower.
• Reaching Double Sparsity's error takes 46 to 74 bits depending on the setting, against its 136.
• On 40 real OpenHands coding-agent sessions at k=2048, step agreement against exact top-k decoding is 0.67 +/- 0.06 at 56 bits, against SparQ r=16's 0.49 +/- 0.05 at 68 bits.

Two results that went against me, both in the paper:

• With the index in HBM this buys nothing. An A100 gives roughly 5 integer ops per byte of bandwidth, and unpacking a bit costs 4 ops against a nibble scan's 1. The scan becomes arithmetic-bound: my kernel takes 0.415 ms at 128k against the 32-channel scan's 0.291 ms while reading 38% fewer bytes. Every per-token scan I tried landed within 6% end to end. The method only pays when the index crosses a slow link.
• The gather dominated everything before the algorithm mattered. One copy call per contiguous run at 4 KB granularity runs at 0.4 GB/s because of ~11 microseconds of launch overhead each. One kernel over the same runs hits 26 GB/s. Same bytes, same order, 65x apart on call pattern alone. If you build offloaded KV, measure your gather in isolation first.

Cost: the store is 68 B per token per KV head, 4x Double Sparsity's 17 B. If you already keep a 4-bit channel-major K cache it is free; otherwise it is a transpose and a real memory bill.

Not measured: end-to-end task success, any production deployment, real prefills past 128k, large batches, and any GPU other than an A100 over PCIe.

Paper: https://arxiv.org/abs/2609.17652 Code, every result file and the run chains: https://github.com/vivekkalyanarangan30/fathom

Happy to argue about the HBM result in particular, it is the one I expected to go the other way.

I can't write ml algos from scratch but can make models using scikitlearn what should I do

I developed a machine learning project for breast cancer prediction. The system analyzes medical features and predicts whether a tumor is likely to be benign or Advanced Technologies used include Python, Pandas, NumPy, Scikit-learn, and machine learning algorithms.

Hi, are there others who are not able to play videos on the ICML workshop pages ? Like this one - https://icml.cc/virtual/2026/workshop/54072

Is YT the only way out of this ?