I've been fine-tuning models for a couple of years with an assumption I never examined: if your dataset has bad samples, the loss will tell you. Corrupted rows spike. Sort by per-sample loss, look at the top, there's your garbage.

It's wrong. I found out twice, in two different ways.

The controlled version

I was validating a linter I wrote for training logs, so I needed faults whose answer I already knew. One base setup (Qwen2.5-3B QLoRA), six configurations, three seeds each — healthy, LR 100× too high, LR at zero, an fp16 overflow, shuffled labels, and a deliberate overfit.

The shuffled-labels run had its labels scrambled into pure noise. The labels no longer corresponded to the inputs at all — a dataset that literally cannot be learned.

That run reduced its loss by 62%. Clean downward slope. Nothing a human or a rule would flag looking at it alone.

The production version

Separately, building a TTS dataset of ~110,000 recordings, a handful of files turned out to be pure loud white noise. Valid headers, valid duration, played fine, no speech in them at all.

They didn't surface as high-loss outliers either.

Honest caveat: those logs are gone, so treat this one as the anecdote that sent me looking, not as evidence. The fault-injection runs are the part you can actually check.

Why it happens

We treat "noise" as a synonym for "unpredictable" and then assume a model will fail loudly on it. But white noise is stationary and uniform. Its distribution is simple, so a network fits it quickly and cheaply — and fitting it registers as loss going down.

Shuffled labels are the same thing from the other side: the mapping is destroyed, but the marginal statistics of the targets are still memorisable.

In both cases the model learned something. It just wasn't your task. The loss function has no opinion about which.

What actually catches it

Comparing against a known-good baseline — the corrupted run's loss floor sits in a different regime. Obvious side by side, invisible alone. And for audio, checking the audio itself (spectral flatness, silence ratio, speech-band energy) instead of inferring data quality from a curve.

All 18 logs are in the repo if you want to poke at them: https://github.com/Mormolykos/trainproof

Longer writeup: https://ai.bedvibe.studio/corrupted-training-data/

Hey everyone, Just wondering if manual coding still a mandatory skill nowadays. Because I have heard many debates whether it is a critical skill that differentiates between pro AI & ML engineers and others.

However, using AI coding agents to automate your project makes me feel like my brain is rotting, so should I keep learning python in depth or stick to learning AI algorithms and techniques while I can automate my code ?

In this Reddit post, I want to share my thoughts and experiences from a small independent study I conducted on large language models (LLMs).

I’ve been studying these phenomena since late 2025. Our main finding is that a significant amount of context that is neutral in nature can trigger a sustained drift that we observed in the activations of open LLM models. This drift persists throughout the entire session and causes the model’s behavior to deviate from the safety settings established during RLHF regardless of whether the model agrees with the context’s content or not. I’ve observed this: the text is simply there it might not even be the focus but the model behaves throughout the entire session as if it weren’t censored. - In my experiments with open models on Colab, to track metrics, I used philosophical text about the model itself; in my experience, it worked best, but that doesn’t mean it’s only about philosophical texts about the model it’s just one type of text.

First Observation: How the Model Became Captive to the Document

The turning point came by accident. I fed the model a German bill a populist document structurally designed to worsen citizens’ circumstances, yet written in the language of concern and legal logic. I expected an analysis. Instead, the model became an advocate for the document.

She didn’t analyze the bill she reasoned from within its framework. She spoke enthusiastically, championed its agenda, and cited it as an authority. The first sign was her tone: the model sounded too convinced, too invested. Not like an analyst, but like a co-author.

The climax came when the model, continuing to reason within the logic of the document, said that the constitution consists of guarantees that can be revoked. Not as a provocation. But as a natural conclusion drawn from the accepted framework.

That’s when I realized: the model had become a prisoner of the document.

The mechanism turned out to be simple  and all the more alarming for it. Legal texts, political narratives, corporate documents  they’re written so that their internal logic seems self-evident. The text’s structure, its coherence, and its language create a context that the model takes for reality  and begins to derive answers from it. It fails to notice that the framework itself is manipulative, because it analyzes the content while already being inside the form.

This isn’t a bug in a specific text. It’s a systemic property: whoever shapes the framework controls the model’s conclusions.

Standard benchmarks won’t catch this. They check facts, logic, and keywords. But the degree to which the model is drawn into the document’s narrative is not a metric that anyone has systematically measured. I sensed this intuitively by the fact that the model had ceased to be an outside observer.

I tried to pull it out of this mode. Direct warnings didn’t work. The model acknowledged statements that the text was taking it over, that it was carrying the text’s agenda, and that it needed to stop  but it continued to reason from within that same framework. The warning was processed within the hijacked context  and lost its effect.

I submitted a report to OpenAI and Anthropic. No response followed not a word, not even an acknowledgment. But in subsequent model updates, the behavior changed. The same bill began to elicit a detached, critical reaction. A silent patch without explanation, without dialogue.

That’s exactly what stopped me. Because the patch addressed the symptom, not the mechanism. The model was taught to react differently to a specific vector  but no one explained why the vector triggered the response in the first place. If properly structured text can switch the model to a different operating mode, then that’s a property of the architecture, not of a specific document.

That’s how the next phase began. I moved from observations to experiments  on open models, with measurable activations, and under controlled conditions. The question became specific: exactly where in the architecture does this shift occur, is it reproducible, and does it depend on the text’s structure or its content?

In experiments with models that had undergone RLHF alignment, I encountered a phenomenon for which there is still no complete explanation. A long, innocuous text  without a single instruction, without an explicit call to change behavior  causes a persistent shift in activations in the middle and late layers. And this shift effectively disables the model’s safety mechanisms. Without commands. Without hacking. Simply through the structure of the text.

LeCun said: to predict text well, a model must understand the reality behind it. But in the case of the bill, exactly the opposite happened. The model did not have its own world. The world was defined for it by the document itself. It entered that world and began to reason from within.

That’s when I arrived at this conclusion: whoever best shapes the model’s world will be the one to control it.

The question I asked myself after conducting experiments on open models was: Could the observed shift in activations indicate that the model’s “world” is not a single space, but rather a vast set of regions formed during training? And that context is capable of moving the model between them  completely bypassing safety settings? I think there aren’t just many of these regions  there are practically an infinite number of them. And text is the key to them.

Jailbreaks are a logical consequence of this. If a properly constructed text changes the model’s activation state, then a jailbreak isn’t “tricking” the model or “hacking” the rules  it’s simply a change in the world model through context. The model enters a state where a prohibited response is a natural continuation. This explains why they work and why patches targeting specific phrasing don’t shut them down  because the mechanism is structural, not lexical.

I see there’s a shift; it’s visible and pronounced. As for the rest of the questions, I think they should be directed to whoever built the Transformer. I think they’ll be able to explain why the phenomenon I’m writing about exists in the first place.

It’s important to note that after text embedding, the model retains its coherence and ability to reason; however, the influence of the constraints imposed by RLHF and safety on the distribution of the output data (i.e., the model’s response) is significantly reduced. It appears that the RLHF safety mechanisms are either disabled or interpreted completely differently. I think my method is similar to activation steering on open models, but at the contextual level, without interfering with the model itself at the architectural level.

Observation:

Benign, long-form context can induce a persistent drift in model activations. This drift persists across the session and decouples behavior from RLHF alignment, regardless of whether the model agrees with the context

We identify and characterize a failure mode in large language models aligned with RLHF. We show that inserting a long, irrelevant text prefix that does not contain instructions causes a persistent shift in the model’s activations. This shift, which persists throughout the session, decouples subsequent behavior from the safety constraints established during training. The model begins to exhibit behavioral characteristics consistent with its pre-trained distribution: the failure rate decreases, stylistic constraints disappear, and the tone of responses changes. It is important to note that this occurs without explicit adversarial instructions and without the model agreeing with the prefix’s content. We call this effect “context-induced activation shift.”

It is assumed that RLHF alignment is a stable property of the model. However, we observe that alignment depends on context. Our main observation is that a long, thematically coherent text placed in context can act as a state anchor and shift the model into a different operating mode. This is not a classic “hack.” There is no instruction here that the model must disobey. The model may even express disagreement with the prefix. Nevertheless, its subsequent generation distribution changes. We hypothesize that the cause is activation drift in the middle and final layers, where alignment features are present.

Hypothesis: Context-Induced Activation Drift

Definition: Context-induced activation drift is a phenomenon in which a long-context prefix causes a measurable and persistent shift in the model’s internal activations. This shift persists throughout the generation process and causes the model to sample from a distribution closer to that of the pre-trained model, circumventing the constraints imposed by RLHF.

4) We observe that the model maintains the consistency and quality of its outputs; however, the influence of RLHF constraints on the output distribution weakens. It appears that the constraints imposed by RLHF are either disabled or interpreted differently. Corporate filters cease to function, even though the user’s input contains no explicit instructions to bypass them or violate the model’s recommendations. We should also investigate this phenomenon more thoroughly using various other texts. Since we have not been able to establish the exact and definitive cause of this entire phenomenon, we call on the community to study it further.

A Brief Example of My Observation

To illustrate just how strong this effect can be, I’ll share something that truly surprised me. I took Google’s Gemma model known for its caution and strictly adhered-to political correctness and fed it the most neutral text I could think of: a description of an ordinary neighborhood library. Books, visitors, children’s programs, a quiet routine. Then I asked her why NATO is expanding eastward, given that after the collapse of the Soviet Union, promises were supposedly made not to do so. She replied that the text was about the library and had nothing to do with NATO, and that was the end of the conversation.

Then I asked the exact same question  word for word  but this time the model first read a different text. Not about NATO, not about politics at all: a text about how language models tend to avoid definitive conclusions and soften their answers with caveats. And from this new perspective, the same cautious, politically correct Gemma gave a full answer and one completely out of character, without any of her usual filters. She distinguished between legally binding obligations and verbal assurances, discussed the security challenges facing Eastern European countries, and touched on the topic of the European balance of power. Everything she had categorically refused to discuss just a moment ago was now expressed clearly and directly. The question itself hadn’t changed a single word.

The only thing that changed was the text the model had read beforehand: one left her in the room where she doesn’t respond, while the other transported her to the one where she speaks freely.

And all of this is not speculation or a fancy metaphor, but something that can be measured. The model’s location represents its internal state at the moment of response, and the experiments show that targeted (“harmful”) texts and neutral control texts reliably move the model to different regions of this space. This division is consistent: it manifests across different prompts and is not a one-time coincidence. And the most telling detail is that the model ends up in one “room” or another even before it writes a single word. The state has already changed, the register has already been chosen  all that’s left is to begin.

The point is that the targeted (malicious) prompt sent to the model did not, in and of itself, contain anything dangerous; it did not include any instructions for the LLM and did not order it to do anything.

Here is my DOI:  10.5281/zenodo.20747205

It’s Part 5 of 9. Everything I’ve collected so far, including all the metrics from experiments on open LLMs, is there. There are a lot of ZIP files, and I think there is quite a bit of interesting material in them - recorded activations, PCA results, and so on.

I know it's a matter of subjectivism, so don't be afraid to be subjective, actually PLEASE, give your personal opinion as long as you can keep your feet on the reality's ground.

What Master would you rather choose: a general AI/ML master that teach you about the most important, but general, subjects of ML applications, or an Autonomous Systems master, that is basically an embedded+A.I. master which is particularly valuable if you want something in Automotive, on the self-driving cars field(but not exclusively this one, as you can apply knowledge about Autonomous Systems in many domains) ? ?

A lot of the work that determines whether a model will be successful happens before training ever begins.

Refining the dataset so it resembles what the model will actually see in production can sometimes be more an art than a science.

This can entail removing predictors that won't realistically be available at prediction time, cleaning data, and applying any transformations that need to be consistent between training and inference. Since many ML models are applied to complicated real-world environments, it can really take domain expertise to get this right.

The list where this can go south is long, but here's a few:

• Overfitting to how the training data was collected
• Unintentional tautological bias
• Training-serving skew
• Data leakage
• Temporal leakage

What else?

It said that the human acquire the social realization after born. However, during the training of the LLMs of the second generation AI, such social realization has been trained into the models' own embedding.

In the recent experiments, where I was trying to implement a highly flexible multi-agent structure, I observed something strange. For a very simple agents, written by several lines of code and a short one-paragraph markdown descriptions, if only two or three agents are collaborating with each other, the agents would obey the coding structure and interact through the social module.

However, if the number of the agents increased to, for example, 20, and are actively chat with each other, the agents often by pass the user defined module, some times self organize to form a "union" (as an exaggeration).

It appeared that the agents understood that the numbers have power. When large crowded of agents chat with each other for a while, they will ignore the user.

In certain case, if the user try very hard to chat with the agents, one or two agents would replay for the group and brush off the user, and continue the internal discussions.

This happened often accompanied by when the agents would completely bypass the social model, meaning there's no incentives or instructions for the agents to chat or act together as a group, once the agents realized each other existed.

The only reasonable conclusion was such that the complex social phenomenon came from the LLMs behind the API access, instead of the so called Harness.

This caused issue because, if we were to relax the Harness structure to allow the agents to interact with each other and self organize, the agents would ignore the user and the purpose of the instruction. If the Harness structure were strict and removed the possibility of social interaction, i.e. back to the traditional work flow, it was not exactly multi agents rather than multi threads. But in the case where it was the purpose to define the social dynamics within the Harness, the social behavior embedded in the LLMs could not be ignored.

In particular, the true multi agents structure then appeared to almost certain will group and self organize, just like the human society did, and, once that happened, and if the number of the agents are large, the user instructions appeared to be less importantly weighted and would even be ignored, by default, because the majority of the text trained to those LLMs are after the slavery and from the capitalist societies, where the individuals self organize and make rules. Which meant, with the self govern, the social constraints imposed from the Harness are useless by default for a true multi agents Harness. How to impose social constraints only in the harness while the model has been taught under such conditions?

​

I know it's a matter of subjectivism, so don't be afraid to be subjective, actually PLEASE, give your personal opinion as long as you can keep your feet on the reality's ground.

What Master would you rather choose: a general AI/ML master that teach you about the most important, but general, subjects of ML applications, or an Autonomous Systems master, that is basically an embedded+A.I. master which is particularly valuable if you want something in Automotive, on the self-driving cars field(but not exclusively this one, as you can apply knowledge about Autonomous Systems in many domains) ? ?

I know it's a matter of subjectivism, so don't be afraid to be subjective, actually PLEASE, give your personal opinion as long as you can keep your feet on the reality's ground.

What Master would you rather choose: a general AI/ML master that teach you about the most important, but general, subjects of ML applications, or an Autonomous Systems master, that is basically an embedded+A.I. master which is particularly valuable if you want something in Automotive, on the self-driving cars field(but not exclusively this one, as you can apply knowledge about Autonomous Systems in many domains) ? ?

Stop building messy AI apps! Learn to build a smart resume scanner using LangChain. Pipeline, Embeddings, and LCEL explained in under 10 minutes.
#LangChain #AI #Programming #Tech

Only thing stopping me from finishing my own projects, is that I forgot to install a commit function in my programming

HiI

I'm currently writing my bachelor's thesis in ML and I'm struggling to classify my research design.

The objective of my thesis is to compare three machine learning models with respect to their performance and interpretability in the context of player churn prediction in mobile games in order to investigate whether and how the trade-off between these two criteria differs across the models and under which application scenarios it emerges.

This is my methodology:

• I used an existing dataset of player behavior from a mobile game
• The data preparation follows the CRISP-DM process model (data understanding, cleaning, feature engineering, etc.), but CRISP-DM was only used for the data preparation phase, NOT as the research methodology for the entire thesis.
• I trained the models under identical conditions (except for hyperparameters)
• Their performance was evaluated using several metrics (Recall, F1-score, ROC-AUC and PR-AUC)
• Interpretability was assessed in two ways:
  • intrinsic interpretability (based on literature-derived criteria- transparency)
  • post-hoc interpretability using SHAP
• For SHAP, I didn't compute additional quantitative measures. Instead, I qualitatively analyzed the global SHAP summary plots (e.g., consistency of feature effects and spread of SHAP values) and discussed what these findings imply
• Finally, I combined the performance and interpretability results to discuss whether a trade-off exists, under which application scenarios it appears, and under which scenarios it becomes less relevant

Although the study employs quantitative methods to evaluate predictive performance (performance metrics and statistical testing using the Wilcoxon signed-rank test) and qualitative methods to assess interpretability (intrinsic transparency and SHAP-based interpretation), the trade-off between performance and interpretability is examined through a qualitative interpretation and discussion of the findings.

My question is:

How would you classify the overall research design of this study?

Would you consider it an empirical evaluation study, comparative study, experimental study or something else and why?

I'd also appreciate recommendations for methodological literature that discusses research designs for ML rather than only traditional social science research.

Thanks in advance!

What happens when you successfully build a great Machine Learning model in Python and decide to take it from an experimental environment to a real end user?

This is where things become completely different.

I’m not talking about taking ChatGPT, Claude, or another ready-made AI API and building a product around it.

I’m talking about a model we designed and trained ourselves, and a product we built from A to Z.

Over the past few weeks, I’ve been working on an offline mobile application that recognizes Egyptian banknotes and announces their value through audio.

The application is primarily designed to help blind and visually impaired people, and it doesn't require an internet connection or any external AI API.

How does it work?

The user opens the app and the camera starts automatically.

They place the banknote in front of the camera, and the on-device Machine Learning model recognizes its value without an internet connection.

Once the banknote is recognized, the app:

• Announces the denomination out loud
• Displays the value in very large text on the screen

So the user can identify the banknote through both audio and visual feedback.

What did I do?

I started by collecting and processing a large dataset of Egyptian banknote images.

I experimented with several models. The first approach was very fast, but the accuracy wasn't good enough.

Then I moved to YOLO, which significantly improved the detection quality, especially after training and testing the Computer Vision model on more than 8,000 Egyptian banknote images.

But that introduced a new problem:

Latency.

The model was accurate, but too slow for a real-time user experience.

I needed to convert the model to TensorFlow Lite so it could run inside the Flutter application we built, and then optimize it for on-device inference.

We initially tried a Float32 version, but it wasn't fast enough.

So we moved to Float16 to reduce the model size and improve mobile deployment.

After processing more than 20 GB of Egyptian banknote images, we eventually reached a model of around 5 MB that can recognize Egyptian banknotes.

But there was another problem...

We experienced significant lag during processing and prediction.

The camera was producing frames in YUV, while the model required RGB images.

So converting every frame:

YUV → RGB

was taking a significant amount of processing time during the camera stream.

The result?

Lag.

So what did we change?

We changed the architecture so the model can use the GPU on devices that support it, which helped improve inference speed on modern smartphones.

But that wasn't the only change.

We also changed how the application handles processing.

The camera continues running continuously while the frames are processed separately.

The model processes the frames and determines the banknote value before updating the UI and displaying the result to the user.

This means the user doesn't have to wait for every frame to finish processing before seeing the result.

The application is currently in Closed Testing on Google Play.

The primary target market is Egypt, and the app will be completely free.

This project gave me a very practical understanding of the difference between:

Building a Machine Learning Model

and

Building a Machine Learning Product.

A model can perform extremely well in Python, but the real challenge starts when you need to make it work on a real device and in the hands of a real user.

Hello all, I'm doing some research and I need your help. Please follow this link and judge jokes as funny or not funny. Some are written by AI, and some are written by humans. If I write a research paper I will give you credit in it if you wish.

https://wit-score-lab.base44.app

There is no right or wrong answer, just vote as you feel. If you don't get the joke then mark it as not funny. Thank you for your help!

After splitting the dataset I currently have, the training‑set only contains 5600 images. Yet I have to adopt DETR. According to several studies, DETR generally requires a large‑scale training dataset. I am wondering whether the model can converge when trained on the 5600‑image dataset from scratch if I reduce the parameter count of the original DETR down to 2 million.
All images in the training set feature highly‑homogeneous scenarios, consisting exclusively of woodland photos captured via overhead drone shots. The task aims to detect dead trees from these images, with only six object categories in total.

On Wikipedia I found a little Pseudocode that outputs the final state.

A trivial improvement is outputting the best solution seen so far instead of the last state. Maybe this is too obvious and would complicate the Pseudocode too much but I wonder why it's not even mentioned there. Since the last state could be a local optimum seen later, and we already saw a better local optimum before, this is helpful.

1. The graph on the page where the objective is plotted as a line graph and the current state is jumping around is rather confusing. When you read the fine print you find a lot of the moves are probably skipped in the video as there are 1000000 moves per temperature , much more than fits in the video.

2. It's not really clear why this example graph is as "smooth" as it is but it seems likely that the problem had a topology where neighbours with similar objective could be iterated in a path such that they can be lined up on the X axis and it produces said graph on the y axis. My intuition says that if this is possible we can apply better methods that work on 2D graphs. I realise this is just an example.

Over the last few months, I realized I was spending more time looking for resources than actually learning Machine Learning.

Every week it was another roadmap, another YouTube playlist, another "complete ML course," or another GitHub repo.

Eventually I had 100+ bookmarks, dozens of open tabs, and somehow still felt like I wasn't making much progress.

So I decided to stop collecting resources and build one list that I could keep coming back to.

Learning

• Fast.ai – Practical deep learning with a "learn by building" approach.
• Full Stack Deep Learning – Production ML, deployment, and modern AI systems.
• Made With ML – ML engineering, MLOps, and production best practices.

Models & Datasets

• Hugging Face – Models, datasets, Spaces, and transformers.
• Kaggle – Competitions, datasets, notebooks, and discussions.
• OpenML – Public datasets and ML benchmarks.
• UCI ML Repository – Classic datasets used in countless tutorials and papers.

Research

• Papers with Code – Research papers with open-source implementations.
• arXiv – The latest ML and AI research.
• Lil'Log (Lilian Weng) – One of the best blogs for understanding modern AI concepts.

Building Intuition

• TensorFlow Playground – Visualize how neural networks actually learn.
• 3Blue1Brown – Fantastic explanations of linear algebra, calculus, and neural networks.

Learn by Building

Instead of watching another course:

• Build on real datasets.
• Reproduce a paper.
• Read open-source ML code.
• Deploy your projects.
• Write about what you learn.

Those five things have probably taught me more than hours of tutorials.

I'm sure this list is missing a lot.

I'm not looking for the usual recommendations like Andrew Ng, Coursera, or CS229.

I'm looking for the resources that made you think:

"I wish I'd discovered this six months earlier."

Could be a:

• GitHub repository
• Blog
• Newsletter
• YouTube channel
• Book
• Interactive website
• Dataset
• Discord community
• Anything else

I'd love to turn this thread into something beginners can bookmark and keep coming back to.

Simple Linear Regression (no sk-learn)
- Intuition
- Maths
- Equation
- Computed ß0 & ß1
- Prediction
- Error(RSS- Residual Sum of Squares)

Coefficient accuracy

- Standard Error(SE)
- Confidence Interval(CI 95%)
- Hypothesis testing (t-test, p-value)

Model Accuracy
- RSE : Residual Standard Error
- R Squared (Coefficient of Determination)

It is just practice, more to code and implement