Datasets:
roanbrasil
/
devops-gitops-corpus

Dataset card Data Studio Files
xet
 Community
1
text
stringlengths
0
59.1k
class A data
class B,O pipeline
class C,D model
class G,H,I monitor
class N team
class J,K,L,M decision
`} />
## Key Evaluation Metrics
Fine, enough talking for now. Time to look at numbers. When you're evaluating an LLM, you need hard numbers to track progress and make decisions. But it's hard to choose the right numbers because different tasks demand different methodologies.
### Classic NLP Metrics
These are the old reliables that have been around for decades. They're not perfect for LLMs, but they're still good enough in most situations.
**BLEU (Bilingual Evaluation Understudy)** was designed originally for machine translation. It measures the similarity between your model's response and a reference response. Think of it as double-checking how many words and phrases are a good fit.
BLEU is fine when there is a "right" answer, such as translating a sentence. But it doesn't perform so well with creative tasks where there can be many good answers. If your model generates an excellent response but uses other words than the reference, BLEU may score it low.
**ROUGE (Recall-Oriented Understudy for Gisting Evaluation)** is precision-unoriented, recall-oriented. It's popular to use for summarization since it gauges if your model captured the source's most important information.
**METEOR** tries to outsmart **BLEU** because it considers synonyms and word stems. It's more flexible but more complex to compute.
When do you employ these? They're ideal for simple right-answer questions and when you're interested in tracking raw improvement over time. Just avoid them completely for tricky, open-ended questions.
### Current LLM Metrics
With the improving models, we needed improved evaluating methods. More recent metrics try to capture more semantic content rather than just word overlap.
**BERTScore** is comparing text based on contextual embeddings. It doesn't just match words, but it understands "happy" and "joyful" are about the same. That makes it a much better fit to be comparing paraphrases and creative writing.
**BLEURT** takes it a step further in that it's actually trained on human judgments. It learns to approximate how humans would rate text quality, so it's more in line with what really counts.
**Perplexity** measures how "surprised" a model is with a piece of text. Lower perplexity tends to mean the model has improved understanding of the text. It's especially useful for comparing models doing the same task.
These are more sophisticated but more expensive to compute. They're worth it when you need to measure fine-grained outputs or when vanilla metrics don't capture what is relevant for your application.
### Task-specific Metrics
At other times, you need to get more detailed about the things you're measuring. Broad metrics won't go so far as to indicate if your customer service chatbot is actually helping customers.
**Accuracy** is easy for classification issues. If your model has to classify support tickets, accuracy tells you how often it gets the category right.
**F1-score** is a balance between precision and recall. It is best used when false negatives and false positives are equally critical. For example, when you're getting key data from reports, you want high precision (don't get things wrong) and high recall (don't miss out on important things).
**Business-specific metrics** tend to be most important. Maybe you want customer satisfaction scores, task completion rates, or frequencies of follow-up questions. These are closely tied to business outcomes.
The key is matching your metrics to your goals. When creating a writing assistant for creative writing, grammatical correctness might be lower priority than engagement and uniqueness. If you're making a medical diagnosis system, only safety and correctness count.
## Best Practices
With hundreds of test configurations, some trends stand out. These practices will save you time and help you steer clear of common pitfalls.
### Evaluation Dataset Quality
Your test dataset is the foundation of all else. Screw this up, and your entire measurements are junk.
Variability matters. Your test set needs to cover the whole input distribution that you're going to see in production. That includes easy cases, hard cases, edge cases, and adversarial cases. If you only test your model against nice, well-formed questions, you'll be surprised when real users start tossing curveballs at...
Keep your evaluation data separate from training data. This goes without saying, but data leakage happens more often than you might think. Any overlap, no matter how slight, will overestimate your scores and mislead you.
Update your evaluation data from time to time. User behavior evolves, new edge cases emerge, and business requirements change. Your evaluation has to change, too. Develop a strategy to refresh at least 20% of your test cases every quarter.
Size your dataset appropriately. Bigger is not always better. A tight dataset of 500 decent examples typically performs better than a spread set of 5,000 poor ones. Opt for coverage and quality over quantity.
### Multiple Metric Approach
Never tune with one metric. Every metric has its blind spots, and tuning to one single one often creates problems elsewhere.
Choose metrics that align with your goals. If user satisfaction is what matters, include metrics that correlate with satisfaction. If speed is critical, track latency alongside quality measures. If safety is paramount, include specific safety evaluations.
Look for metric disagreements. When metrics tell different stories, that's usually where the interesting insights hide. Maybe your model is getting more accurate but less helpful, or more creative but less consistent.
Weight your metrics by business impact. Not every metric is created equal. Be explicit in which ones matter most in your specific use case and weight your overall evaluation accordingly.
Keep an eye on metric stability over time. A metric that swings wildly may not be stable enough to base decisions on. Go with metrics that produce consistent, understandable results.
### Regular Re-evaluation
Model performance varies. What is working for you today may not be tomorrow, especially as your user base changes and expands.
Schedule periodic review sessions. Monthly deep dives are a good fit for most apps. Look at trends, investigate anomalies, and tweak your evaluation approach based on what you learn.
Re-check when change happens. New functionality, changes in user interface, or changes in user behavior can all impact model performance in unexpected ways. Don't let the next scheduled review roll around if you suspect something is off.
Compare against fresh baselines periodically. Maybe your fancy model still beats last year's plain baseline, but would it beat this year's improved plain approaches? Technology changes rapidly, and your reference points should too.
### Documentation and Reproducibility
Current you will curse future tests if you don't document well.
Trust me on this point.
Documentation detailing the evaluation methodology must be done carefully. State what you're testing, why you're testing with these measurements, how you collected your test data, and what the outcome is. Your new team member should be able to repeat and comprehend your evaluation based solely on your documentation.
Version your output and evaluation data. When you modify things, note what you modified and why. That history is invaluable when you're debugging or attempting to observe performance trends.
Keep your evaluation reproducible. Version control your test data and your evaluation. Randomly seed where necessary. Note any manual operations that aren't automatable.