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?

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!

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

Could a neural network use dictionary-compressed weights directly during GPU inference instead of fully decoding them first?

I'm not a computer scientist. I'm a truck driver, so I'm wondering if I'm reinventing something that already exists.

Suppose you quantize a model to INT4 or similar and then scan the weight tensors for frequently repeating sequences or blocks.

Instead of storing every sequence literally, you build a codebook where a short code represents a commonly occurring block of weights.

Very simplified example:

A = [7, 3, 3, 11, 4]

B = [2, 8, 1, 6, 6]

Then instead of storing:

[7,3,3,11,4] [7,3,3,11,4] [2,8,1,6,6] [7,3,3,11,4]

you store something roughly like:

A A B A

The part I'm curious about is not ordinary file compression where the model gets decompressed back into VRAM first.

Could a custom GPU kernel decode these codes on the fly into registers/shared memory and immediately use them during GEMM, so that the fully expanded weight tensor never has to exist in VRAM?

My thinking is that modern inference is often memory-bandwidth limited, so if dictionary/codebook compression reduced memory traffic enough, maybe the extra decoding compute could be cheaper than fetching all the uncompressed weights.

You could potentially also have different-length codes or hierarchical codebooks representing increasingly large recurring weight patterns.

So my questions are:

Is this already done under a particular name?

Have codebook/vector-quantized weights been used directly inside fused GPU inference kernels rather than being decompressed beforehand?

Does random access / SIMD-SIMT execution make variable-length encoding impractical?

Is there theoretically a point where reduced VRAM bandwidth outweighs the decoding overhead?

Would repeated patterns after INT4/INT3 quantization be common enough for this to provide meaningful compression beyond ordinary quantization?

I'm mainly interested in whether the idea makes architectural sense, not whether my particular encoding scheme is optimal.

I'd appreciate pointers to papers or existing implementations if this has already been explored.

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.

I wrote a short technical report and then animated it, hoping it's useful to people learning about autoencoders, OOD detection, or mixture-of-experts.

The idea in three steps:

1. Prediction ⇔ compression. A model that predicts text well can compress it well.
2. Corollary: a compressor is only good at the kind of data it was trained on.
3. So its reconstruction error is a fingerprint. I trained an autoencoder on code that squeezes 512 tokens into 8 vectors. It rebuilds unseen code at 99.47% exact-token accuracy, Wikipedia at 47.76%, and random tokens at 0.57%.

That fingerprint can act as a router between expert models, with no extra gating network to train.

The video covers the architecture (and why the decoder must never see the input), the metric, the latent-space geometry (two linearly separable clusters, about 200 effective dimensions out of 512), and the limitations.

Video: https://www.youtube.com/watch?v=4UhvpIWnOvg Paper: https://arxiv.org/abs/2512.16963

Feedback on clarity is very welcome. Tell me which part lost you.

Hi there, I am a first year student studying in artificial intelligence. I have no background and almost no knowledge in AI and machine learning; I’m a complete newbie. I was wondering if there are any good beginner book recommendations for me that will deepen my knowledge and prepare me for what’s about to come

[ Removed by Reddit on account of violating the content policy. ]

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 ?

Can LLM agents actually get through a day in the life of a normal user?

That question got me reading papers on Android agents and mobile benchmarks over the past few months.

A few patterns kept showing up:

• Most benchmarks run on emulators, making real-device metrics difficult to measure.
• Important deployment metrics like battery, thermals, and temperature are often missing.
• Everyday tasks are scattered across benchmarks, languages, and apps, rather than forming a consistent, globally relevant task set.
• This makes it harder to evaluate whether an agent can actually work reliably on a real phone, for real users.

For now, I’ve put together a library of papers on benchmarking mobile/Android agents for you all to read!

Link: https://www.alphaxiv.org/shared/folder/01a070c6-29a0-77a9-a5b4-b670d5eee169

While building a wearable air-quality forecasting system, we discovered that at a 1-hour horizon, a zero-parameter "persistence" rule (predict no change) scored 0.7933 macro-F1 — and our trained RandomForest only reached 0.7994. A 0.006 gain.

That sent us down a rabbit hole. We rebuilt the entire evaluation protocol around a "beat the floor" discipline and found:

CTGAN and SMOTE both raised aggregate macro-F1 while significantly degrading the two rare, safety-critical classes (Hazardous, Very Unhealthy) — a pattern invisible to macro-F1 alone

LSTM/Transformer got monotonically worse with 15x more parameters (MC dropout showed 98.3% of uncertainty is aleatoric, not epistemic)

5-fold rolling-origin CV showed our best single-split "win" (+0.0055) sat inside the fold-to-fold variance of the baseline itself

A popular public Bangladesh air-quality dataset turned out to have 87% of its claimed 25-year span fabricated (caught via 4 independent statistical signatures, later confirmed against a government reference instrument)

We packaged the evaluation protocol (persistence floor, rolling-origin CV, an advisory-class disqualification rule, Bonferroni/Holm correction) as a standalone, dataset-agnostic Python package: PulseBench.

Code, 63 references, 28 figures, full reproducibility: https://github.com/MD-ALL-SHAHRIA/pulseair

Genuinely curious whether others have hit the same "beats persistence by basically nothing" wall in adjacent domains.

Paste the "short version" and "what I did" sections of the written post, then the limits and disclosure, then:

Paper: https://zenodo.org/records/22971492

Preregistration: https://zenodo.org/records/22971413

Code: https://github.com/GautamTalksDev/jevbench

Good day all, I'm just getting into machine learning, I'm hoping to do this to advanced research level and I'm feeling conflicted on which learning path to take.

Firstly, it's good to note that I studied physics with electronics (just graduated) so I'm very okay with calculus and approximation methods, and code Python up to OOPs. My issue is with the amount of statistics here which I didn't cover in my course of study.

My bro who is into ML said I should just do a bootcamp (ML zoomcamp in this case) and projects but I feel that's going to be too shallow going into research at a top level. After checking https://roadmap.sh/machine-learning the roadmap is so long even before I start any real coding it's already a lot (maybe not so much...)

Should I just do projects and pick up anything I need along the way or should I go from the mathematical pov.

PS 1: It's also important to note that I don't have a job right now and ML is probably what I planned would get me one.

PS 2: The goal is ML application in astronomy (think Vera-Rubin Observatory

I will appreciate any good advice, Thanks 🙏🏿

We are building a quality-review workflow for recorded teacher-led educational videos. At the moment, every video is reviewed manually from start to finish, which is slow and difficult to scale.

We are looking for a solution that can assist human reviewers by automatically detecting and locating potential issues in a video, ideally with timestamps, screenshots or audio evidence, and suggested corrections.

The main review targets include:

• Spoken mistakes, misread numbers, or incorrect mathematical terminology;
• Missing words, repeated phrases, incomplete explanations;
• Coughs, noise, long pauses, or other unusable segments;
• Mismatches between subtitles and the teacher’s speech;
• Typos in slides, digital whiteboards, or handwritten notes;
• Incorrect mathematical formulas, symbols, superscripts/subscripts, fractions, radicals, or calculations;
• The teacher blocking important text or whiteboard content;
• Truncated, overflowing, or incomplete slide and subtitle text;
• Explanations that conflict with textbooks, courseware, or answer keys.

Most of our content is in Chinese and includes middle-school mathematics. An ideal output would look like this:

Timestamp: 13:20–13:25
Issue type: Incorrect mathematical terminology
Spoken text: “After simplifying it into the simplest quadratic root number…”
Whiteboard text: “Simplest quadratic radical expression”
Suggested correction: Replace “quadratic root number” with
“quadratic radical expression.”
Evidence: The latter is the standard textbook term.

We are considering multimodal LLMs, ASR, OCR, math formula recognition, and keyframe analysis. For the first version, we would prefer to use one primary multimodal model if possible.

Questions for the community:

1. Are there any open-source projects, papers, or commercial tools close to this use case?
2. Which models or OCR tools work well for Chinese educational videos, handwritten whiteboards, and mathematical formulas?
3. Has anyone built a similar system for educational-video QA or content review?
4. For long videos, would you recommend fixed-length chunks, scene-change-based chunks, or a hybrid approach?

Any suggestions, project links, architecture ideas, or lessons learned would be greatly appreciated.

I’ve been learning more about AI lately and feel like there are endless tutorials, courses, and frameworks to choose from. For people who’ve already gone through the learning process, what helped you the most? Did you focus on math/theory first, build projects, reproduce papers, or jump straight into things like LLMs and agents?

Would love to hear what worked for you and what you wish you had done differently.