GenAI for Text, Language, Narrative, and Quality Estimation: Comprehensive Lecture Notes

Academic Context and Foundation

• Institution and Faculty: Vilnius TECH (Vilniaus Gedimino technikos universitetas).

• Lecturer: Lekt. Tautvydas Kvietkauskas.

• Core Focus Areas: Generative AI (GenAI) architectures for natural text, natural language processing, complex narrative systems, and comprehensive quality estimation frameworks across multiple generative modalities.

Evolution of Natural Language Processing and Text Analysis

• Early NLP Models:

  • Core Methods: Bag-of-Words (BoW), $n$-grams, and rule-based expert systems.

  • Analytical Focus: Analyzed separate, isolated tokens independently, ignoring semantic context and deeper syntactic dependencies.

• Deep Learning Era:

  • Core Methods: Word2Vec, GloVe (Global Vectors for Word Representation).

  • Analytical Focus: Shifted to semantic vector representations (dense embeddings) where tokens are mapped into a continuous vector space, analyzing their belonging to specific vectors and semantic clusters.

• Transformers and Large Language Models (LLMs):

  • Foundational Milestone: Introduced by Vaswani et al. (2017) in the seminal paper "Attention is All You Need".

  • Architectural Legacy: Provided the architectural foundation for modern foundation models, including Generative Pre-trained Transformer (GPT), Bidirectional Encoder Representations from Transformers (BERT), and Text-to-Text Transfer Transformer (T5).

  • Analytical Focus: Directly models the dynamic, multi-directional relationships between all elements across the entire sequence simultaneously.

Classical NLP Methodologies and Semantic Vector Representations

• Bag-of-Words (BoW):

  • Represents text as an unordered collection of words, tracking solely word frequency and disregarding grammatical structure and word order.

  • Example Sentence: "Artificial intelligence is transforming education."

  • Frequency Distribution:

  • Artificial: $1$

  • intelligence: $1$

  • is: $1$

  • transforming: $1$

  • education: $1$

• $n$-grams:

  • Extracts contiguous sequences of $n$ items from a given sample of text or speech to retain local sequential context.

  • 2-grams (Bigrams):

  • Artificial intelligence

  • intelligence is

  • is transforming

  • transforming education

  • 3-grams (Trigrams):

  • Artificial intelligence is

  • intelligence is transforming

  • is transforming education

• Rule-Based Systems:

  • Rely on explicit, deterministic IF-THEN conditional logic manually crafted by domain experts.

  • Example Rule: IF sentence contains "transforming" THEN sentiment = positive

  • Rule Execution Output: Generates a positive statement classification based on the presence of the trigger keyword.

• Semantic Vector Representations (Word2Vec and GloVe):

  • Project individual words into continuous, dense vector spaces where geometric distance reflects semantic relatedness.

  • High-Dimensional Embeddings Example:

  • $\text{Artificial} \rightarrow [0.23, 0.74, \dots]$

  • $\text{Intelligence} \rightarrow [0.18, 0.69, \dots]$

  • $\text{Education} \rightarrow [0.41, 0.55, \dots]$

  • Learned Proximities and Semantic Analogies:

  • $\text{Education} \approx \text{Learning}$

  • $\text{Intelligence} \approx \text{Knowledge}$

  • $\text{Education} \leftrightarrow \text{School}$

  • $\text{Education} \leftrightarrow \text{Learning}$

  • $\text{Intelligence} \leftrightarrow \text{Knowledge}$

Transformer Architecture and the Attention Mechanism

• Core Conceptual Paradigm:

  • Replaces recurrent and convolutional layers entirely with self-attention mechanisms, enabling global dependency modeling across an entire sequence in parallel.

  • Contextual Dependency Resolution Example: In the sentence "Artificial intelligence is transforming education," the action "transforming" connects bidirectionally up to "Artificial intelligence" and down to "education".

  • Structural Understanding: Identifies the subject as "Artificial intelligence", the action as "transforming", and the object as "education", synthesizing the core proposition: "Artificial intelligence transforms education."

  • Generative Completion: Given the context "Artificial intelligence is transforming …", the model generates probability distributions to predict plausible continuations such as education, healthcare, business, or society.

• Attention Mechanism Dynamics:

  • Allows every individual token to "attend" to every other token in the sequence, dynamically computing weighting coefficients to establish context.

  • For each input sequence, three dense matrices are computed from the input embeddings $X$ via learned projection weight matrices:

  • Query ($Q$): Derived via $Q = X \times W_Q$

  • Key ($K$): Derived via $K = X \times W_K$

  • Value ($V$): Derived via $V = X \times W_V$

  • Where $W_Q$ denotes query weights, $W_K$ denotes key weights, $W_V$ denotes value weights, and $d_k$ denotes the attention head dimension/size.

• Mathematical Formulation of Scaled Dot-Product Attention:

  • Dot Product Similarity: The dot product $Q K^T$ computes pairwise similarity between all token queries and keys across the sequence.

  • Normalization: The softmax activation normalizes these scaled scores into an attention weight distribution:   $S = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right)$

  • Contextual Output: The normalized attention weights $S$ are multiplied by the Value matrix $V$ to produce contextualized, context-aware token representations:   $\text{Attention Output} = S \times V$

  • Computational Implementation: Operations are executed as massive, highly parallelized matrix multiplications optimized for GPU/TPU tensor cores requiring high memory bandwidth.

• Attention Score Distribution Example:

  • Sequence: "I", "love", "tennis"

  • Attention Scores Matrix ($S$):

  • Row 1 ("I"): [0.7, 0.2, 0.1]

  • Row 2 ("love"): [0.05, 0.8, 0.05]

  • Row 3 ("tennis"): [0.05, 0.2, 0.75]

  • Attention Output ($S \times V$): Produces updated, context-aware embeddings for "I", "love", and "tennis" reflecting their contextual dependencies.

• Importance Weighting Case Study:

  • In "Artificial intelligence is transforming education", the attention mechanism dynamically allocates contextual importance:

  • Artificial: little importance

  • intelligence: great importance

  • is: little importance

  • education: great importance

  • Relational Extraction: Synthesizes the core relationship "Artificial intelligence" $\rightarrow$ "transforms" $\rightarrow$ "education".

Multi-Head Attention, Feed-Forward Networks, and Data Flow

• Multi-Head Attention:

  • Rather than relying on a single attention computation, Transformers employ multiple parallel attention heads.

  • Each head independently learns distinct semantic and syntactic relationship subspaces (e.g., syntax, coreference, named entities, sentiment).

• Feed-Forward Network (FFN):

  • Sits immediately after the multi-head attention layer, functioning as a position-wise feature transformation layer applied independently to each token.

  • Architecture: Implemented as a two-layer perceptron with an intermediate non-linear activation function.

  • Hardware Suitability: Computations are fully decoupled across token positions, enabling high parallelization and vectorized execution on specialized hardware.

  • Functional Division of Labor:

  • Attention Mechanism: Determines "Which words should I pay attention to?"

  • Feed-Forward Network: Determines "What should I do now with the information I have gathered?"

  • Operational Example: In "Artificial intelligence is transforming education," attention establishes the primary connection between "Artificial Intelligence" and "Education". The FFN processes this connection to synthesize the higher-order semantic inference: "Artificial intelligence has an impact on education."

• Transformer Hardware and Training Data Flow:

  • Input Preprocessing: Raw text undergoes tokenization, numerical encoding, and batch tensor construction.

  • GPU Memory Loading: Formatted input tensors are transferred directly into device memory (utilizing CUDA cores and tensor cores).

  • Forward Pass: Attention layers execute parallel matrix operations followed by non-linear FFN transformations, caching resulting activation tensors in GPU memory.

  • Backward Pass (Training): Gradients are computed using automatic differentiation frameworks (PyTorch, TensorFlow) and distributed across clusters via data or model parallelism.

  • Parameter Optimization: Optimizers such as AdamW or Adafactor update network weights, aggregating gradients across nodes via NCCL (NVIDIA Collective Communications Library).

  • Full Inference Pipeline:     $\text{Text} \rightarrow \text{Tokenization} \rightarrow \text{Embeddings} \rightarrow \text{Attention} \rightarrow \text{FFN} \rightarrow \text{Output Representation} \rightarrow \text{Next Token Prediction}$

  • Tokenized Sequence Example: ["Artificial", "intelligence", "is", "transforming", "education", "."]

  • Next Token Prediction Output: "Artificial intelligence is transforming education by enabling personalized learning."

• Output Layer and Next-Token Decoding Strategies:

  • The final hidden state is mapped across the entire vocabulary via a linear projection followed by a softmax function, yielding a discrete probability distribution over all possible tokens.

  • Greedy Decoding: Always selects the token with the absolute highest probability. Fast and deterministic, but prone to repetitive and degenerate loops.

  • Beam Search: Maintains a predetermined number of candidate hypotheses (beams) simultaneously, evaluating cumulative probabilities across sequence paths to generate balanced, coherent text.

  • Sampling-Based Methods: Introduces controlled stochasticity (e.g., Temperature, Top-p / Nucleus sampling) for open-ended, diverse, or creative text generation.

LLM Training Paradigms: Pretraining, Fine-Tuning, and RLHF

• Pretraining:

  • Data Corpus: Massive web-scale text collections, including books, Wikipedia, crawled web pages, and programming code.

  • Objective: Self-supervised next-token prediction, enabling the model to internalize syntax, world facts, commonsense reasoning, and grammatical structures, outputting a generalized Base Model.

• Supervised Fine-Tuning (SFT):

  • Adapts a broad base model to specialized downstream tasks (e.g., document summarization, dialogue, domain question-answering).

  • Utilizes smaller, highly curated datasets containing paired input prompts and verified ground-truth labels.

• Instruction Tuning and Reinforcement Learning from Human Feedback (RLHF):

  • Utilized by conversational models (e.g., ChatGPT) to align base capabilities with human values: helpfulness, safety, and relevance.

  • Human evaluators review and rank multiple model candidate outputs, training a reward model to optimize the generator's underlying policy.

  • Reinforcement Fine-Tuning Cycle:

  • Step 1 (Observe): Agent observes state from the environment.

  • Step 2 (Select Action): Agent selects an action using its current policy (e.g., deciding between Walk or Sit).

  • Step 3 (Action!): Agent executes the action (e.g., Action = Sit).

  • Step 4 (Get Reward or Penalty): Environment delivers feedback (e.g., Reward! via fish treat).

  • Step 5 (Update Policy): Agent executes learning step: "Sit = Good! Next time do it".

  • Step 6 (Iterate): Process repeats iteratively until an optimal operational policy is established.

System Architecture of LLM-Powered Chatbots

• User Interface (UI):

  • Handles multimodal input and output (text prompts, speech).

  • Technologies: Web applications, mobile applications, Interactive Voice Response (IVR) systems.

• Frontend Gateway:

  • Manages traffic routing, authentication, and communication between user interfaces and backend infrastructure.

  • Technologies: REST APIs, WebSockets.

• Dialogue Manager:

  • Maintains conversation state, multi-turn context tracking, and session memory.

  • Technologies: Session memory caches, vector stores.

• LLM Engine:

  • Executes core text reasoning, instruction following, and natural language response generation.

  • Technologies: GPT, Claude, Gemini.

• Knowledge Layer:

  • Supplies dynamic factual grounding and external domain knowledge to prevent factual hallucinations.

  • Technologies: Relational/NoSQL databases, Retrieval-Augmented Generation (RAG).

• Monitoring & Security:

  • Enforces content safety guardrails, filters toxic or sensitive content, and tracks system telemetry.

  • Technologies: Moderation APIs, enterprise observability and telemetry tools.

Functional Modalities of Generative AI

• GenAI for Text Generation:

  • Creative Writing: Automated synthesis of fictional stories, poetry, and dramatic scripts.

  • Content Creation: Generation of blog posts, news articles, marketing copy, and product descriptions.

  • Data-to-Text: Transforming structured tabular data into natural language reports (e.g., financial earnings summaries).

  • Text Completion: Real-time predictive typing and IDE autocompletion.

  • Core Controlling Techniques:

  • Prompt Engineering: Designing input instructions and few-shot exemplars to steer model behavior.

  • Temperature and Top-p Sampling: Hyperparameters that regulate the mathematical balance between deterministic focus and creative diversity.

  • Context Windows: Extended token capacities allowing models to process long-form inputs while maintaining global coherence.

• GenAI for Language Understanding and Manipulation:

  • Multilingual Translation: High-performance zero-shot and few-shot translation across diverse language pairs.

  • Text Summarization: Extractive summarization (selecting key passages) and abstractive summarization (re-synthesizing core ideas).

  • Reasoning and Question Answering: Powering conversational virtual assistants and analytical question answering.

  • Tone and Sentiment Adaptation: Detecting emotional sentiment and transforming stylistic tone (e.g., adjusting formal vs. casual register).

  • Cross-Lingual Capabilities: Models generalize across languages via shared multilingual semantic vector spaces, facilitating automated software localization and global accessibility.

• GenAI for Narrative and Storytelling:

  • Narrative Generation:

  • Character & Plot Development: Constructing complex character backstories, motivations, and evolving narrative arcs.

  • Worldbuilding: Generating fictional lore, geographical settings, and consistent rules for fantasy/sci-fi universes.

  • Adaptive Storytelling: Generating branching, personalized story structures driven dynamically by user choices in interactive media and gaming.

  • Coherence Challenges in Narrative: Mitigating narrative drift, causal inconsistencies, emotional flattening, and degenerative storyline loops.

  • Assisted Creativity (Co-Writing): Collaborative human-AI workflows where the model acts as a creative consultant, proposing alternative plot twists, structural edits, and character options.

Quality Estimation Frameworks and Core Dimensions

• Significance of Generative AI Quality Estimation:

  • Essential for establishing user trust, ensuring operational safety, maintaining user retention, validating deployment readiness, and monitoring production drift.

  • Evaluates distinct modalities: text (summaries, code, dialogue, translation), visual media, speech/audio, and multimodal video.

  • Core challenges include human subjectivity, absence of standardized ground-truth references, multimodal alignment complexity, and fundamental metric trade-offs (e.g., fluency versus factuality).

• The Nine Core Dimensions of Quality:

  • 1. Accuracy / Factuality / Faithfulness: Evaluates whether generated content is truthful, factually correct, and strictly grounded in reality or source reference data.

  • 2. Relevance / Prompt Alignment: Measures how effectively the generated output addresses the user's specific prompt instructions and covers intended scope.

  • 3. Fluency / Readability: Evaluates grammatical correctness, stylistic elegance, syntactic clarity, and natural linguistic flow.

  • 4. Coherence / Logical Structure: Assesses structural consistency in long-form outputs, logical progression of ideas, and avoidance of self-contradiction.

  • 5. Diversity / Creativity / Novelty: Measures freshness of concepts, lexical/syntactic variety, and avoidance of repetitive, formulaic phrasing.

  • 6. Realism / Naturalness: Primarily applied to visual, audio, and video modalities; measures whether outputs look, sound, and feel authentic.

  • 7. Controllability / Bias / Safety / Ethical Constraints: Verifies compliance with specified system constraints, avoidance of harmful or toxic content, and mitigation of algorithmic bias.

  • 8. Consistency / Stability: Assesses output invariance across repeated identical API calls, minor prompt variations, and input noise perturbations.

  • 9. Efficiency & Cost / Latency & Compute: Tracks inference latency, hardware resource consumption, memory footprints, and financial compute cost per query.

Modality-Specific Evaluation Metrics

• Classical Text Evaluation Metrics:

  • BLEU (Bilingual Evaluation Understudy): Computes the weighted geometric mean of modified $n$-gram precisions between candidate text and reference sets, incorporating a brevity penalty for short outputs.

  • ROUGE-N (Recall-Oriented Understudy for Gisting Evaluation): Computes $n$-gram recall between candidate generations and reference texts.

  • ROUGE-L: Evaluates structural sentence overlap using the Longest Common Subsequence (LCS).

  • METEOR: Computes the harmonic mean of unigram precision and recall (heavily weighting recall), incorporating stemming, synonym lookup, and fragmentation penalties.

  • CIDEr: Computes the cosine similarity of Term Frequency-Inverse Document Frequency (TF-IDF) weighted $n$-grams; standard metric in image captioning.

  • BERTScore: Computes pairwise token semantic similarity between candidate and reference sentences using contextual embeddings extracted from pretrained BERT models.

  • COMET: Supervised neural regression framework predicting human translation quality ratings using joint source, candidate, and reference embeddings.

  • Perplexity: Measures a language model's uncertainty on a held-out test dataset, calculated as the exponentiated cross-entropy loss.

• Faithfulness and Factuality Text Metrics:

  • FactCC / $Q^2$ (Question-Answering Consistency): Measures factual consistency by evaluating whether questions generated from source text can be correctly answered by the model's generated text.

  • NLI-Based Hallucination Rate: Employs Natural Language Inference models (classifying entailment, neutral, contradiction) to systematically identify ungrounded statements or direct contradictions.

  • SelfCheckGPT: Zero-resource hallucination detection metric that evaluates the consistency across multiple stochastic candidate completions generated by the model for the same prompt.

• Empirical Implementation of Sentence BLEU:

  • Evaluates lexical overlap between candidate hypotheses and reference sentences.

  • Dataset Configuration:

  • Hypothesis (hyp): str('she read the book because she was interested in world history').split()

  • Reference A (ref_a): str('she read the book because she was interested in world history').split()

  • Reference B (ref_b): str('she was interested in world history because she read the book').split()

  • Execution Results:

  • score_ref_a = bleu.sentence_bleu([ref_a], hyp) $\rightarrow$ Outputs 1.0 (exact string match).

  • score_ref_b = bleu.sentence_bleu([ref_b], hyp) $\rightarrow$ Outputs 0.7400828044922853 (penalized due to inverted clause order and altered $n$-gram overlap).

  • score_ref_ab = bleu.sentence_bleu([ref_a, ref_b], hyp) $\rightarrow$ Outputs 1.0 (when evaluated against multiple references, the maximum match against Reference A is returned).

• Image and Visual Generation Metrics:

  • Unique Requirements: Evaluates photorealism, fine visual fidelity (texture rendering, geometric consistency, lighting), alignment to text prompts, and physical plausibility.

  • FID (Fréchet Inception Distance): Calculates the Wasserstein-2 distance between multivariate Gaussian feature distributions of real versus generated images extracted from the Inception network.

  • Inception Score (IS): Measures generated image quality via "objectness" (low conditional entropy) and overall dataset diversity (high marginal entropy).

  • SSIM / PSNR: Classical low-level signal metrics measuring structural similarity and peak signal-to-noise ratios against ground-truth images.

  • GLIPS (Global-Local Image Perceptual Score): Combines global distributional statistics with localized perceptual similarity to align closely with human subjective assessments of photorealism.

• Audio and Speech Generation Metrics:

  • Unique Requirements: Intelligibility, accent naturalness, prosody, rhythm, temporal fidelity, and absence of audio artifacts.

  • PESQ (Perceptual Evaluation of Speech Quality): ITU-T standardized metric quantifying speech signal quality on a numerical scale ranging from $-0.5$ to $4.5$.

  • STOI (Short-Time Objective Intelligibility): Measures speech intelligibility by computing correlation coefficients between temporal envelopes of degraded and clean speech signals.

  • WER (Word Error Rate): Quantifies transcription inaccuracy by comparing automatic speech recognition (ASR) outputs against ground-truth text:   $\text{WER} = \frac{S + D + I}{N}$   Where $S$ denotes substitutions, $D$ denotes deletions, $I$ denotes insertions, and $N$ denotes the total number of words in the reference.

  • MOS (Mean Opinion Score): Standard human evaluation methodology scoring speech audio on a subjective discrete scale from $1$ to $5$.

• Video and Multimodal Metrics:

  • Unique Requirements: Audio-visual synchronization, temporal coherence across consecutive frames, dynamic physical plausibility, and scene consistency.

  • VMAF (Video Multi-Method Assessment Fusion): Machine-learning fused metric combining PSNR, SSIM, and detail loss features to predict perceived video quality on a scale from $0$ to $100$.

  • FVD (Fréchet Video Distance): Extends FID to the temporal domain, evaluating feature representations extracted via an Inflated 3D ConvNet (I3D).

  • CLIPScore: Computes the cosine similarity between multimodal text and image/video embeddings generated by Contrastive Language-Image Pre-training (CLIP).

  • LANSE (Language-Grounded Sparse Encoders): Decomposes visual-textual semantics to measure dimension-specific alignment across distinct attributes.

• Code and Structured Output Metrics:

  • Evaluates syntactic validity (compilation/parsing), semantic functional correctness (passing automated unit test suites), execution security, maintainability, and algorithmic robustness.

Human, Automated, and Hybrid Evaluation Paradigms

• Human Evaluation Methodologies:

  • Likert Scale Scoring: Evaluators score candidate outputs across defined criteria on a scale from $1$ to $5$ (where $1$ represents very poor, $3$ represents average, and $5$ represents excellent).

  • Example Scorecard: Clarity of response = $4/5$, Accuracy = $5/5$, Usefulness = $4/5$.

  • Pairwise Comparison (Side-by-Side): Human annotators review two anonymous model outputs for the same prompt and select the superior response.

  • Example Setup: Prompt: "Explain quantum computing." Evaluator selects AI Response A over AI Response B.

  • A/B Testing: Distributes distinct model versions across segmented live user populations to compare empirical engagement metrics.

  • Example Deployment: Cohort A interacts with GPT-4 while Cohort B interacts with GPT-5, comparing user satisfaction, task completion success, and usage retention.

• Automated Evaluation Frameworks:

  • Contextual Semantic Matching (BERTScore): Evaluates semantic preservation rather than superficial lexical matching.

  • Example: Reference text states "AI improves healthcare." Model outputs "Artificial intelligence enhances medical services." Despite differing tokens, identical semantic embeddings result in a high BERTScore.

  • LLM-as-a-Judge: Deploys an advanced LLM (e.g., GPT-4) as an automated evaluator.

  • Example Protocol: The judge receives the instruction: "Evaluate this answer for factual correctness and clarity on a scale from 1 to 10." The judge outputs a quantitative score accompanied by a qualitative justification.

  • Chain-of-Thought (CoT) Evaluation: Forces the judge LLM to generate an explicit reasoning trace before determining a final numerical score.

  • Reasoning Trace Workflow:

    • Step 1: Verify factual claims against source references.

    • Step 2: Analyze internal logical consistency.

    • Step 3: Evaluate completeness relative to prompt requirements.

    • Step 4: Output final numerical evaluation score.

• Hybrid Evaluation (Human-in-the-Loop):

  • Integrates high-volume automated screening with targeted expert review for high-stakes domains.

  • Healthcare Case Study: A medical diagnosis response generated by ChatGPT undergoes dual evaluation. Automated evaluation indicates high semantic accuracy ($90\%$). Expert clinical review identifies an incorrect medication dosage recommendation. The result is rejected, demonstrating the necessity of expert oversight in critical applications.

• Emerging Evaluation Frameworks:

  • LanSE (Language-Grounded Sparse Encoders): Evaluates synthetic images across multiple dimensions (prompt alignment, realism, physical plausibility, diversity) with interpretable visual grounding.

  • GLIPS: Refines photorealistic image quality evaluation beyond FID and IS to align with human perceptual judgments.

  • HYPE (Human Perceptual Evaluation): Standardized psychophysical benchmark measuring human ability to distinguish synthetic from real imagery under controlled exposure times.

  • G-Eval Frameworks: Structured evaluation protocols utilizing LLM-based chain-of-thought grading tailored to customized enterprise rubrics.

Quality Estimation Implementation Lifecycle and Workflow

• Stage 1: Define Requirements: Specify target use cases, output modalities, and core requirements across accuracy, creativity, safety, and legal compliance.

• Stage 2: Select Metrics: Identify relevant quality dimensions and select an optimal combination of human, automated, or hybrid evaluation methods.

• Stage 3: Prepare Data: Curate reference golden datasets, representative operational test prompts, and adversarial edge-case inputs.

• Stage 4: Automated Evaluation: Execute computational evaluation pipelines (BLEU, ROUGE, FID, BERTScore, LLM-as-a-Judge).

• Stage 5: Human Evaluation: Implement expert reviews, blind pairwise comparisons, A/B tests, and Likert-scale scoring.

• Stage 6: Analyze Results: Correlate automated scores with human judgments, calibrate metrics, and verify scoring reliability.

• Stage 7: Continuous Monitoring: Track production telemetry, monitor user feedback signals, detect model drift, and update evaluation suites.

• Stage 8: Ethics and Safety Checks: Conduct systematic audits for societal bias, toxicity, hallucination risks, privacy leaks, and regulatory compliance.

Engineering Challenges and Best Practices

• Core Challenges in Generative Evaluation:

  • High subjectivity and low inter-annotator agreement among human raters.

  • Reference scarcity in open-ended creative tasks where infinite valid outputs exist.

  • Overreliance on superficial lexical overlap metrics that fail to evaluate deep semantic factuality.

  • Difficulty establishing systematic, scalable metrics for fairness, safety, and toxicity.

  • Performance degradation under out-of-distribution (OOD) domain shifts.

  • Balancing evaluation depth against computational cost and latency.

• Industry Best Practices:

  • Directly map quality metrics to concrete end-user and business objectives.

  • Implement a two-tier evaluation strategy: automated metrics for high-throughput screening combined with human expert review for high-stakes tasks.

  • Construct explicit adversarial suites, negative examples, and edge-case prompt batteries.

  • Statistically validate that chosen automated metrics correlate strongly with human judgment in the target domain.

  • Ensure evaluation pipelines are reproducible, deterministic, and version-controlled.

  • Maintain continuous logging and telemetry to detect latency spikes, accuracy degradation, and data drift over time.

  • Actively identify and mitigate systematic evaluator biases (including self-enhancement bias in LLM-as-a-Judge pipelines).

Questions and Discussion

• Open Forum Discussion Points: Exploration of trade-offs between evaluation cost and metric reliability, strategies for resolving conflicting human and automated scores, and approaches for automating real-time safety guardrails in production conversational systems.