# We're All Finetuning Incorrectly

Tanmay Chopra, Emissary | MLOps Podcast | Episode 304 | 1:00:31
Hosted by Demetrios Brinkmann

Source: https://www.youtube.com/watch?v=mulsjmhXbaQ
Channel: MLOps Community, now AAIF Live (https://www.youtube.com/@AAIFLive-x1r). Summarised by MLOps Talks.
Page: https://mlopstalks.com/talks/were-all-finetuning-incorrectly
Published: 2025-04-08
Tags: classical-ml, evals, fine-tuning, guardrails

## TL;DR
- AI systems work best when their role matches the user's expertise, because experts need deterministic, accurate assistance while beginners can use AI as a coach.
- Prompting can bootstrap an initial system, but owning the model lets a team optimize for its actual objective function instead of only predicting the next word.
- Production AI systems need explicit evaluations, thresholds, fallback paths, and continuous improvement rather than a one-time model release.

## Summary
Tanmay Chopra argues that many teams call extended pretraining or prompt changes fine-tuning, while missing the older machine learning practices that make systems improve for a specific task. Prompting is useful for reaching an initial version, especially when data is scarce, but it cannot change the model's objective. A specialized model can optimize for classifications, confidence thresholds, or whether generated content matches reality. Chopra also argues that LLMs should become components inside larger ML systems. A classifier can decide whether an LLM should answer, while deterministic retrieval or smaller local models can reduce uncertainty and latency. Teams should choose problems where they have a differentiated feedback loop and enough economic value to justify ongoing maintenance. The conversation ends with an infrastructure and language constraint: serious customization often requires a Python-based AI backend because much of the ML tooling is built around PyTorch, TensorFlow, and related libraries.

## Key ideas
### AI is useful in different ways for experts and beginners
[03:22](https://www.youtube.com/watch?v=mulsjmhXbaQ&t=202s)
Tanmay Chopra separates AI as a supervisor from AI as an assistant. A beginner can use code generation to get started, check the result, and learn when the system fails. An expert working in a familiar area may be slowed down because repeatability, determinism, accuracy, and latency matter more than conversational help. Chopra gives infrastructure engineering as an example: code generation can be valuable for an infrastructure engineer doing frontend work, while it can slow that same person down on a difficult infrastructure problem. The usefulness depends on the user's expertise and ability to verify the output.

### General models create too much distance between a prompt and a usable workflow
[07:58](https://www.youtube.com/watch?v=mulsjmhXbaQ&t=478s)
Chopra says generalized systems are trained on broad knowledge, so they rarely produce the best workflow for a particular company. A system would need to see many examples pairing prompts with the ideal resulting pipelines to reduce the edits needed after its first output. He also describes a deeper mismatch with machine learning. Traditional ML takes inputs and outputs and searches for a function, while newer systems often ask users to explain their process in a prompt. That puts the burden of describing a workflow onto people who may not know the right terminology or process.

### Teams need to define what good means before they can improve an AI system
[09:47](https://www.youtube.com/watch?v=mulsjmhXbaQ&t=587s)
Chopra says his company first asks customers to define success for their own system. That could mean having the right files, producing the right text, or matching a business outcome. He distinguishes an AI system being generally good from being good for a particular user or task. Evaluations based on gut feeling add another layer of uncertainty, yet deterministic evaluation remains uncommon. He says evaluation is difficult because the target can sit between a technical measure and a business metric. AI systems also differ from conventional software because they are perishable and need a plan for retraining and improvement from the start.

### Prompting can bootstrap version zero, while model ownership changes the objective
[14:30](https://www.youtube.com/watch?v=mulsjmhXbaQ&t=870s)
Chopra does not reject prompting. He recommends using it until it stops being good enough, then deciding whether owning a model is justified. Prompt optimization cannot change the objective function, because the underlying model still cares about predicting the next word. Enterprise tasks may instead care about classification or whether an investment memo maps to reality. Owning the model allows optimization against that task-specific objective. He compares maintaining a specialized model to a lifelong commitment, since the team must retrain and care for it over time rather than release it once and walk away.

### Specialized systems can use math to optimize a task instead of guessing through prompts
[18:49](https://www.youtube.com/watch?v=mulsjmhXbaQ&t=1129s)
Chopra describes optimization as a mathematical way to reduce loss when a team can define what good looks like. He connects this to DeepSeek's GRPO approach and says the industry lost sight of older fine-tuning methods by focusing on generalized next-token prediction. Prompting guides still have a place because an LLM lets a team bootstrap an initial version with far less labeled data than older ML workflows required. That first version can then become a source of real user feedback. The long-term system should improve from that feedback rather than wait passively for the next foundation model.

### LLMs should be components inside ML systems, with smaller models handling clear decisions
[29:27](https://www.youtube.com/watch?v=mulsjmhXbaQ&t=1767s)
Chopra recommends treating an LLM as one node in a larger pipeline. In a chatbot, a classifier can decide whether a question is in scope before the LLM answers it. This lets the system reject uncertain requests or fall back to an older workflow. He says teams can convert an LLM into classifiers, regressors, and other traditional model types while retaining knowledge from the model's internal layers. With a confidence score and a threshold, an enterprise can measure error rates and adjust how often the system answers. This is safer than making an LLM answer with similar confidence when it knows the answer and when it is guessing.

### System design can replace uncertain generation with deterministic retrieval and infill
[44:06](https://www.youtube.com/watch?v=mulsjmhXbaQ&t=2646s)
For localized advertising, Chopra proposes retrieving a suitable human model from a database and then using inpainting rather than generating an entirely new person. The country lookup can be deterministic, while the image edit handles the flexible part. He describes this as turning a generation problem into retrieval plus infill, which reduces uncertainty and makes separate parts of the pipeline easier to optimize. The same design principle applies more broadly: use as little AI as possible, assign clear tasks to each component, and avoid adding uncertainty through generated orchestration when an expert can specify the workflow directly.

### Serious customization often requires a separate Python-based AI backend
[53:24](https://www.youtube.com/watch?v=mulsjmhXbaQ&t=3204s)
Chopra says teams can start by calling foundation-model APIs from any language, but they may hit a ceiling when they need local models, custom evaluation, model management, or lower latency. Embedding a query locally is one example where a small model can avoid a network call. The difficulty is that much of the ML ecosystem is built in Python, including PyTorch, TensorFlow, and transformer libraries. His recommendation for teams committed to AI is to consider a dedicated AI backend that owns evaluation, API calls, model management, and gateway management. An MVP can remain in an existing language if the team accepts that a later move may be required.

## Notable quotes
- Tanmay Chopra: "The probability of this happening in the next 5 years is probably not that high." (03:42)
- Tanmay Chopra: "The first thing we ask every customer to do on our platform is to stop and think, tell me what good looks like." (10:47)
- Tanmay Chopra: "The model still only cares about the next word. Most enterprise tasks care about things other than the next word." (15:51)
- Tanmay Chopra: "The LLM is never able to say no." (34:17)
- Tanmay Chopra: "You should use as less machine learning or AI as you feasibly can to build your system." (25:35)

## Tools & references mentioned
- Emissary
- MLOps Community
- DeepSeek
- GRPO
- OpenAI
- Anthropic
- ChatGPT
- GPT-5
- TikTok
- Python
- PyTorch
- TensorFlow
- Hugging Face
- Transformers
- Ruby
- JavaScript
- TypeScript
- Go
- A10

## Who should watch
- You are building an AI product and need to decide whether prompting is enough or whether a specialized model is worth maintaining.
- Your LLM produces plausible answers without a reliable way to reject uncertain requests or fall back to an older workflow.
- Your team is moving from API calls in an existing language toward local models, custom evaluation, and a dedicated AI backend.

## Related talks

- [Fine-Tuning is Broken](https://mlopstalks.com/talks/fine-tuning-is-broken) (Tanmay Chopra, Neeva, 25:27)
- [Fine-Tuned Models Are Getting Out of Hand](https://mlopstalks.com/talks/fine-tuned-models-are-getting-out-of-hand) (Jaipal Singh Goud, Prem AI, 36:48)
- [Fine-Tuning LLMs: Best Practices and When to Go Small](https://mlopstalks.com/talks/fine-tuning-llms-best-practices-and-when-to-go-small) (Mark Kim-Huang, Preemo Inc., 53:48)
- [Everything We've Been Taught About ML is Wrong](https://mlopstalks.com/talks/everything-weve-been-taught-about-ml-is-wrong) (Emmanuel Ameisen, Anthropic, 27:08)
- [Making AI Reliable is the Greatest Challenge of the 2020s](https://mlopstalks.com/talks/making-ai-reliable-is-the-greatest-challenge-of-the-2020s) (Alon Bochman, RagMetrics, 1:01:38)