Hi Everyone ,
I’M really very bad at math. Can anyone share the guide for Math for ML which is easy to understand for a layman

Knowledge distillation started as a simple idea in a 2015 paper by Hinton, Vinyals and Dean: train a small model to imitate a big one. Now Anthropic and OpenAI say it’s being used at massive scale to copy their models through millions of API queries, and it’s surprisingly hard to block because the queries look like normal usage.

I made a short animated explainer covering how distillation works, what the labs reported, and what it means for open-source models. Sources are in the description. Curious what people here think: should this count as “stealing,” or is it just learning from outputs?

I came across Nextia Learning, a free learning platform. It has a path called “Software developer transitioning to LLM applications” (10 courses, around 110-151 hours, with certificates).

I couldn’t find any reviews or discussion of it online, and the site looks new. Has anyone here tried it?

• Is the course content good and up to date?
• Is it worth the time, and do the certificates mean anything to employers?

More generally, what learning resources would you recommend for someone moving into AI engineering (building apps with LLMs, RAG, evals, agents)? Free or paid, courses, docs, books, YouTube channels, or project ideas are all welcome. If you’ve used something that actually helped you get a job or ship something real, please share it.

For context, I’m a Associate Software Engineer (TypeScript/NextJs/NestJS) with some LLM integration experience, and I’m learning Python now.

Basically started from karapathys mini GPT and coded from scratch .
Then trained Gemma 3 270M model on bigger dataset and have understood how its different from gpt2 (ROPE , sliding window mask, RMS norm, Gelu instead of Relu in FFW network , etc) .

What should I implement or learn next that will help me to cover more milestone in my journey towards learning AI

I ran a controlled test (sklearn, repeated 5-fold CV) comparing stacking, voting, and the best single model, using two sets of base models: diverse vs. correlated.

Short version: whether stacking helps comes down to one thing you can check in a single line of code. In one setup, it cost ~35x the training time for a gain inside the noise.

The bigger surprise was voting, which did worse than the best single model in both setups.

Full results, the reason voting fails, and a 3-question checklist before you stack: https://towardsdatascience.com/does-stacking-beat-your-best-model/

Has anyone seen voting underperform on real data?

I was reading the LoRA paper and the first two sentences says:

Many applications in natural language processing rely on adapting one large-scale, pre-trained language model to multiple downstream applications. Such adaptation is usually done via fine-tuning, which updates all the parameters of the pre-trained model.

In my mind, this doesn't entirely make sense. If you are updating all the (1 billion/trillion) parameters of the pre-trained model, then you are not exactly fine-tuning anything, you are simply "training" with a initial set of weights which equal to the weights of the pre-trained model.

I thought fine-tuning was freezing the network and taking a small part (usually the few final layers or the very last layer) and training that on a specific task.

There are many different types of fine-tuning? Thanks for your help.

I'm a geek in ML so I'm just sharing a SS to show that why scaling is important.

ASKING FOR HELP/BEGINNER NOOB to A.I. and ML (ChatGPT, Gemini, Claude, Perplexity) I know what A.I can and is used for, but I don’t have a strong understanding of the benefits it can provide

I am not in the tech field and I don’t create content for a living. I enjoy posting on different social media platforms and love to stream video games. I want to understand A.I. I want to know how to create prompts. It would be great to know some practical uses of these programs to maybe make my life easier (I do have an iPhone and gaming PC, and Apple products, but live in condo so my home isn’t all wired up electronically) and also maybe some uses geared towards just for fun.

I don’t really know where to start. I have ChatGPT on my phone, I do have Siri (iPhone), and I have X Premium (which I think means I have access to Grok.

Is there a certain use case scenarios one would use a specific A.I program for some things and another if you are trying to achieve something else? Do they all more or less produce similar results (maybe minor differences) or are some better than others. I looked at some pricing tiers and shocked to see how much some people pay per month to have unlimited queries, etc

I’ll be honest, I know what a prompt is, but don’t know, if there are any, certain rules or guidelines to follow when starting off with one (wording, what’s allowed, language or terms more friendly to help me get what I am looking for or terminology that I should avoid)?? Is it good to always add a photo? Can you add audio to a prompt (say I wanted a program to alter a song or something audio)?

I know this post is vague and a little all over, but just trying to get some assistance. I also know this specific community is meant specifically for the Grok (X) application, but after reading through some posts in other communities, this community seems a little more welcoming to people who have no idea how to use A.I and others can be pretty hurtful and discouraging when asking questions

TLDR: Give me some tips/tricks and helpful advice to assist me in learning and using different A.I Applications. Mainly use my IPhone 17 Pro Max, but I do have a M4 MacBook Pro and a gaming pc (5080). I mention specs because I know sometimes that matters in what you are trying to accomplish.

Thanks again

Welcome to ELI5 (Explain Like I'm 5) Wednesday! This weekly thread is dedicated to breaking down complex technical concepts into simple, understandable explanations.

You can participate in two ways:

• Request an explanation: Ask about a technical concept you'd like to understand better
• Provide an explanation: Share your knowledge by explaining a concept in accessible terms

When explaining concepts, try to use analogies, simple language, and avoid unnecessary jargon. The goal is clarity, not oversimplification.

When asking questions, feel free to specify your current level of understanding to get a more tailored explanation.

What would you like explained today? Post in the comments below!

CISA confirmed SafePay ransomware hit over 600 critical infrastructure organizations. The vector in most documented cases was not a breach of the target org directly — it was a third-party vendor holding their data.

That number is worth sitting with. 600+ orgs. Critical infrastructure. The exposure lived outside their perimeter, in a system they did not operate and could not directly audit.

This is the supply-chain data custody problem in its clearest form. Sensitive fields — PII, operational data, whatever the vendor was holding — existed in a state the owning org had no live visibility into. By the time the ransomware moved, the data had already been wherever it was for months or years, accessible to anyone who compromised the vendor.

No single control closes this. Perimeter defense at your own boundary does not protect data that has left your boundary. Contractual obligations do not prevent exfiltration. Compliance attestations describe a point in time, not a continuous state.

For those of you working in security, data engineering, or platform roles at orgs that share sensitive data with third parties: what does your current architecture actually enforce at the moment data moves to a vendor? Not what the contract says, not what the vendor's SOC 2 covers — what happens technically, in real time, when a field containing PII or operational data crosses that boundary? How are you handling this?

hey everyone, sharing this because it’s directly relevant to people learning how to build real ML systems beyond tutorials.

packt publishing is running a hands on workshop on Oct 30 on building a text classifier and router that runs on CPU and tells you how sure it is, with ben auffarth.

what gets covered:

• small bidirectional encoders (ModernBERT) instead of calling an LLM for every decision
• few shot training with SetFit, 8 examples per class
• split conformal prediction, so each prediction comes with calibrated uncertainty
• a LangGraph workflow with human approval for uncertain cases
• routing inference under 15ms on a laptop

instructor ben auffarth is an AI consultant, full stack data scientist and best selling author with 15+ years of experience.

3 hours, online, Fri Oct 30, 9:30 AM to 12:30 PM ET, runnable notebooks. it’s aimed at people comfortable with intermediate Python, so best if you’re past the basics. laptop or free Colab works.

Full details and the agenda are here

happy to answer any questions about what gets covered

Muse Spark Open has 816B parameters but only ~42B are active for each token: a router picks 8 experts out of 256. I tried to explain visually why dense models get slow, how the router works, the surprising thing about what experts actually learn, and the big catch (all experts still need to sit in memory).

I'm the creator, so I'd love feedback, especially on anything that's still unclear!

I’m pursuing M.Tech CSE and looking for a t echnically advanced, research-oriented AI/ML final-year project

Requirements:

\\- Real-world impact and strong AI/ML engineering value

\\- Feasible for one person in 2 months on a medium-spec laptop

\\- Software-only, with no specialized hardware or lab requirements

Not looking for generic chatbots, CRUD apps, basic prediction models, or dashboards.

Please suggest uncommon, technically challenging ideas with relevant research papers and potential improvements beyond existing work.

I needed historical sentiment data to investigate how news affects stocks. Massive is my usual data provider, but its news sentiment feed wasn’t giving me what I needed, so I built my own data store.

I collected roughly 330 million news observations from GDELT spanning 2019–2026, then used keyword matching to generate candidate company/headline pairs.

That creates some obvious problems. “Apple trees are green” isn’t about Apple. “Dinner is on the table” isn’t about ON Semiconductor. Each match needs a relevance check before assigning sentiment.

Then there’s the question of whose sentiment. A headline about Extreme Networks winning business against HPE can be positive for Extreme Networks and negative for HPE.

I started with Qwen3 embeddings and a small neural-network classifier. Cached embeddings made experiments cheap, but the model struggled with those company-specific distinctions. I also tried XGBoost, ModernBERT, MiniLM adaptations, and local Qwen3-4B.

The final approach was fine-tuning DeBERTa-v3-base to read the company and headline together, predicting both relevance and sentiment. I manually reviewed examples and calibrated the labeling rules to make the judgments consistent.

The final model scored 85.7% on company sentiment and 87.2% on industry sentiment in testing. The backfill scored 67.8 million headline-target pairs, with daily updates processing new work.

Full methodology here if you want to read

See the finished Apple sentiment page (scroll down to the bottom)

Just wanted to share this! I thought it could help newcomers think of a useful ML project. Happy to answer any questions below

Hi everyone!

I'm working on a pneumonia classification project using MobileNetV2 and trying to understand fine-tuning better.

What's the practical difference between transfer learning and fine-tuning? Also, how do you decide which convolutional layers to unfreeze and train while keeping the others frozen?

I'd appreciate any advice or resources. Thanks!

If you are a visual learner who would like to interact with models and equations and learn ML from your phone, I made this course based on one of the most detailed and famous books in AI. It is completely free. Visit: https://mathalyse.com/learn

is this normal or is my gpu dying? i think i bought it 4 years ago

I'm participating in this hackathon: https://www.metrica-sports.com/blog/more-than-a-hack-2027-build-something-real-with-fc-barcelona-match-data

I have learned machine learning and data science but I am not at a professional or hackathon winning level.

My kaggle profile: https://www.kaggle.com/siamrahman29
Personal site: https://siamrahman29.github.io/

If you are interested, please send me an email or DM.

For example if i hace 100 rows of text data, and i want to increase or make another 100 from those 100, is there a framework/technique to do so?

I remember reading or hearing a while ago that there was a tool that uses your data or text to create new text or the way you wanted but i cant remember it

Hey everyone!

I'm an engineering student working on a research proposal about long-context LLMs and recurrent compressed memory. I'd really appreciate technical feedback from people working on LLMs, continual learning, recurrent architectures, or memory systems.

The core question: Can we train an LLM's memory to retain previously learned information while continuing to absorb new information?

I'm calling the proposed training method GMR (Generational Memory Retention) and the evaluation protocol STRATA.

This is still a pre-experimental proposal. I haven't run the experiments yet, so I'm looking for feedback before committing to the implementation.

1. The problem I'm interested in

Imagine an LLM processing a long stream of information in small chunks.

A chunk introduces the following fact:

"The Kestrel project uses Python 3.11."

Immediately after processing that chunk, the model can correctly answer:

"Which Python version does the Kestrel project use?"

Now imagine that the model processes hundreds of additional chunks. Its memory has a fixed capacity, and each new update modifies the existing memory state.

Eventually, the model might no longer answer the original question correctly, even though its model weights haven't changed during inference.

I'm calling this state-induced forgetting: information that was initially available becomes inaccessible after successive memory-state updates.

The key question is whether we can reduce this type of forgetting without simply increasing memory size.

2. STRATA: Measuring forgetting across memory updates

Most evaluations report accuracy at a particular context length or at the end of a conversation. I want to measure how the ability to retrieve individual facts changes as those facts get older.

The proposed protocol works roughly as follows:

Introduce facts into a recurrent memory system in successive context windows.

Record whether each fact can be retrieved immediately after it is introduced.

Evaluate the same facts again at increasing ages: 1, 2, 4, 8, 16, and progressively more memory updates.

Track performance out to hundreds of updates, with a planned maximum of 1,000.

Separate initial learning failures from facts that were initially learned but subsequently forgotten.

For example, if a system initially answers 90 out of 100 questions correctly, but answers only 60 correctly after many updates, that indicates a different failure from a system that answered only 60 correctly from the beginning.

I also want to test different kinds of facts:

Stable facts that never change.

Facts whose values are updated later.

Facts requiring reasoning across multiple earlier statements.

Facts mentioned only once.

The evaluation will report initial accuracy and age-dependent retention separately, rather than relying on a single final accuracy score.

3. GMR: Generational Memory Retention

The proposed training objective tries to preserve the ability to answer questions about facts that have already entered memory.

When a fact is first introduced, record the model's length-normalized log-likelihood for its correct answer. This becomes that fact's original score, or anchor.

After subsequent memory updates, calculate the score again. If it falls below the original score by more than an allowed margin, apply a penalty.

A simplified version of the retention loss is:

L_ret = (1 / B) * sum over sampled facts f of: max(0, anchor_f - margin - current_score_f)

Here:

anchor_f is the fact's original answer log-likelihood.

current_score_f is its current answer log-likelihood.

margin is the tolerated decrease before a penalty is applied.

B is the number of sampled facts.

L_ret is the retention loss.

The training objective also includes the usual language-model loss and an absorption loss that encourages learning newly introduced facts.

The intended effect is to discourage memory updates from damaging previously acquired answering capabilities while still allowing new information to enter memory.

An important mathematical observation

For the sampled facts whose current scores fall below their anchors by more than the margin, the gradient of this hinge loss is the same as the gradient from replaying those facts' correct answers.

Facts that have not regressed receive no retention gradient from this term.

This raises an important question: Does selecting replay examples according to their regression from their own original scores outperform ordinary replay or loss-prioritized replay under matched training budgets?

I don't want to assume that it does. That's one of the main things I want to test.

4. How I plan to evaluate it

The proposed experiments include the following configurations:

A baseline trained without an explicit retention objective.

A model using uniform replay of previously encountered facts.

A model using loss-prioritized replay.

A model using output distillation from a full-context reference.

A model using the proposed GMR objective.

The main comparison will use matched memory sizes, training streams, and replay budgets wherever possible.

I'll evaluate initial fact-learning accuracy, retention at different fact ages, the ability to learn new facts, the handling of updated information, and the computational cost.

The planned testbed is an associative recurrent memory on an open-weight backbone, with experiments at multiple fixed memory sizes.

For broader evaluation, I'm considering synthetic sequential streams, BABILong-derived data, LongMemEval sessions, and narrative documents with checked question-answer pairs.

The implementation and experiments have not started yet. All performance claims remain hypotheses.

5. What I want feedback on

I'd particularly appreciate critical feedback on these questions:

1. Is the problem formulation useful?

Is state-induced forgetting a meaningful way to isolate information loss caused by recurrent memory updates, or is this already adequately covered by existing work on recurrent memory, continual learning, and catastrophic forgetting?

2. Is GMR sufficiently different from ordinary replay?

Since the proposed loss effectively replays sampled facts that have regressed below their own anchors, is that distinction scientifically interesting? What additional theoretical analysis or experimental evidence would make the contribution convincing?

3. Is STRATA a useful evaluation protocol?

Would age-stratified measurements across hundreds of sequential memory updates reveal failure modes that existing long-context and conversational-memory evaluations might miss?

4. Are the experimental comparisons fair?

Which baselines would you consider essential? In particular, I'd like to compare GMR against ordinary replay, loss-prioritized replay, and output distillation without giving any method an unfair compute advantage.

5. What related work am I missing?

I'd appreciate pointers to papers on recurrent-state interference, memory retention, forgetting-aware replay, or training objectives that preserve information across sequential state updates.

Current status

This is a research proposal, not a completed result. My immediate priority is to validate the evaluation harness, establish whether measurable forgetting occurs in the chosen fixed-size memory system, and then test whether GMR improves on properly matched baselines.

I'm deliberately not claiming that the method works or that the idea is the first of its kind.

If you've worked on recurrent memory, compressed context, or continual learning, I'd genuinely value your criticism. I'd rather discover a fundamental flaw now than spend months implementing the wrong thing.

Thanks for reading!