Chapter 9: Advanced Clinical NLP and Information Retrieval
Learning Objectives
By the end of this chapter, readers will be able to:
-
Implement advanced clinical natural language processing systems that leverage transfer learning and domain adaptation to achieve robust performance across diverse healthcare settings while maintaining equitable performance for underserved patient populations.
-
Deploy and fine-tune large language models for healthcare applications including clinical documentation support, patient education material generation, medical question answering, and clinical decision support with comprehensive safety testing and bias mitigation strategies appropriate for high-stakes medical contexts.
-
Design evaluation frameworks for clinical language models that assess not only accuracy but also fairness across demographic groups, robustness to documentation quality variations, and safety properties including hallucination detection and harmful output prevention.
-
Develop multilingual clinical NLP systems that handle code-switching, dialect variation, and interpretation service documentation while respecting linguistic diversity and avoiding systematic disadvantage for patients with limited English proficiency.
-
Build production-grade clinical text generation systems with appropriate guardrails including fact-checking against medical knowledge bases, appropriateness verification for patient-facing content, and monitoring systems that detect distributional shift in clinical language use patterns.
-
Apply prompt engineering and retrieval-augmented generation techniques to adapt general-purpose language models for specialized clinical tasks while implementing comprehensive validation that ensures generated content meets clinical accuracy and equity standards before deployment.
9.1 Introduction: The Promise and Peril of Language Models in Healthcare
Large language models represent a paradigm shift in natural language processing, demonstrating remarkable capabilities across diverse tasks through transfer learning from massive text corpora. Models like GPT-4, Claude, and domain-adapted variants have shown impressive performance on medical licensing examinations, clinical note summarization, patient question answering, and even aspects of clinical reasoning. The potential applications span the entire spectrum of healthcare delivery, from reducing documentation burden for clinicians through automated note generation to improving health literacy through personalized patient education materials to supporting clinical decision-making through synthesis of medical literature and guidelines.
Yet the application of large language models to healthcare demands extraordinary caution. These models, trained on internet-scale text corpora that inevitably encode societal biases and medical misinformation, can generate plausible-sounding but factually incorrect medical advice, may perpetuate or amplify existing healthcare disparities through biased outputs, can hallucinate confident statements about clinical scenarios where uncertainty is warranted, and may provide care recommendations that fail to account for the resource constraints and social contexts affecting underserved patients. The stakes are particularly high because language models often produce outputs that appear authoritative and well-reasoned even when they are incorrect, potentially misleading both clinicians and patients with serious consequences for health outcomes.
This chapter develops comprehensive approaches for deploying large language models in healthcare that maximize their benefits while rigorously managing their risks. We focus especially on ensuring that these powerful tools serve rather than harm underserved populations, addressing concerns including differential performance across patient demographics and languages, appropriateness of generated content for patients with varying health literacy levels, robustness to the documentation quality variations that correlate with healthcare setting and patient socioeconomic status, and prevention of outputs that could exacerbate existing disparities in care quality or access. The implementations provided enable practitioners to build production-grade clinical language model systems with comprehensive safety and fairness validation appropriate for real-world deployment.
The landscape of clinical language models has evolved rapidly since the introduction of transformer architectures. Early domain adaptation efforts like BioBERT and ClinicalBERT demonstrated that pre-training on biomedical literature and clinical notes improved performance on healthcare NLP tasks compared to general-purpose models. Subsequent work explored various pre-training objectives, model architectures, and domain adaptation strategies. The emergence of large-scale instruction-tuned models and conversational AI systems opened new possibilities for interactive clinical applications while also introducing new risks around hallucination, bias amplification, and inappropriate content generation. Understanding this evolution helps contextualize current best practices and emerging challenges in deploying language models for healthcare.
9.2 Transfer Learning and Domain Adaptation for Clinical Language Models
Transfer learning has fundamentally changed natural language processing by enabling models pre-trained on large general corpora to be adapted for specific domains and tasks with relatively modest amounts of task-specific data. For healthcare applications, this approach is particularly valuable because annotated clinical data is expensive to obtain due to privacy concerns, annotation requiring clinical expertise, and the heterogeneity of clinical language across specialties and care settings. However, domain adaptation for healthcare requires careful attention to how pre-training corpus composition, adaptation strategies, and fine-tuning procedures affect model behavior across diverse patient populations and clinical contexts.
The core insight of transfer learning is that language models trained on broad text corpora develop representations of linguistic structure and semantic relationships that transfer to new domains and tasks. These pre-trained representations capture syntactic patterns, semantic similarities, common sense reasoning, and factual knowledge that provide a strong starting point for domain-specific adaptation. For clinical applications, we typically employ a two-stage process: first, continued pre-training on biomedical and clinical text to adapt general language representations to medical vocabulary and discourse patterns; second, task-specific fine-tuning on labeled examples to optimize performance for particular clinical NLP applications.
The choice of pre-training corpus profoundly affects model capabilities and biases. Biomedical literature from PubMed provides strong coverage of medical terminology and scientific discourse but may not reflect the writing styles and information density of clinical documentation. Clinical notes from electronic health records capture authentic clinical language but are protected by patient privacy regulations, limiting the scale and diversity of available pre-training data. Internet-crawled text provides massive scale and diversity but includes medical misinformation, forum discussions that may reflect rather than correct health misconceptions, and limited representation of clinical reasoning patterns. Balanced approaches that combine multiple data sources can mitigate individual limitations while introducing new challenges around weighting and integration.
9.2.1 Clinical Domain Adaptation Strategies
We implement a comprehensive domain adaptation framework that supports multiple strategies for adapting general-purpose language models to clinical applications while tracking fairness properties throughout the adaptation process.
import torch
import torch.nn as nn
from transformers import (
AutoTokenizer,
AutoModel,
AutoModelForMaskedLM,
AutoModelForCausalLM,
TrainingArguments,
Trainer,
DataCollatorForLanguageModeling
)
from datasets import Dataset
from typing import List, Dict, Optional, Tuple, Union
import numpy as np
from pathlib import Path
import logging
from dataclasses import dataclass
import json
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
@dataclass
class DomainAdaptationConfig:
"""Configuration for clinical domain adaptation."""
base_model: str = "bert-base-uncased"
adaptation_strategy: str = "continued_pretraining" # or "task_specific", "hybrid"
clinical_corpus_path: Optional[str] = None
biomedical_corpus_path: Optional[str] = None
max_length: int = 512
mlm_probability: float = 0.15
learning_rate: float = 5e-5
num_epochs: int = 3
batch_size: int = 16
warmup_steps: int = 500
weight_decay: float = 0.01
output_dir: str = "./adapted_clinical_model"
fairness_monitoring: bool = True
demographic_metadata_path: Optional[str] = None
class ClinicalDomainAdapter:
"""
Domain adaptation system for clinical language models.
Supports multiple adaptation strategies:
1. Continued pre-training on clinical/biomedical corpora
2. Task-specific fine-tuning with clinical annotations
3. Hybrid approaches combining both
Includes comprehensive fairness monitoring to detect if adaptation
introduces or amplifies biases across patient demographics.
"""
def __init__(self, config: DomainAdaptationConfig):
"""
Initialize domain adapter.
Args:
config: Domain adaptation configuration
"""
self.config = config
# Load base model and tokenizer
self.tokenizer = AutoTokenizer.from_pretrained(config.base_model)
if config.adaptation_strategy in ["continued_pretraining", "hybrid"]:
self.model = AutoModelForMaskedLM.from_pretrained(config.base_model)
else:
self.model = AutoModel.from_pretrained(config.base_model)
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
self.model.to(self.device)
# Track adaptation history for transparency
self.adaptation_history: List[Dict[str, any]] = []
logger.info(
f"Initialized domain adapter with {config.base_model} "
f"using {config.adaptation_strategy} strategy"
)
def prepare_clinical_corpus(
self,
texts: List[str],
demographic_labels: Optional[List[str]] = None
) -> Dataset:
"""
Prepare clinical text corpus for domain adaptation.
This preprocessing maintains demographic metadata to enable
fairness monitoring during adaptation.
Args:
texts: List of clinical texts
demographic_labels: Optional demographic group labels
Returns:
HuggingFace Dataset prepared for training
"""
logger.info(f"Preparing corpus with {len(texts)} texts")
# Tokenize texts
tokenized = self.tokenizer(
texts,
truncation=True,
padding='max_length',
max_length=self.config.max_length,
return_tensors=None # Return lists for Dataset
)
# Create dataset dictionary
dataset_dict = {
'input_ids': tokenized['input_ids'],
'attention_mask': tokenized['attention_mask']
}
# Include demographic metadata if provided
if demographic_labels is not None:
dataset_dict['demographic_group'] = demographic_labels
dataset = Dataset.from_dict(dataset_dict)
logger.info(f"Prepared dataset with {len(dataset)} examples")
return dataset
def continued_pretraining(
self,
train_dataset: Dataset,
val_dataset: Optional[Dataset] = None,
checkpoint_callback: bool = True
) -> Dict[str, any]:
"""
Perform continued pre-training on clinical corpus.
This adapts the model's language representations to clinical
vocabulary and discourse patterns while monitoring for bias
introduction or amplification.
Args:
train_dataset: Training dataset
val_dataset: Optional validation dataset
checkpoint_callback: Whether to save checkpoints
Returns:
Dictionary containing training history and fairness metrics
"""
logger.info("Starting continued pre-training")
# Data collator for masked language modeling
data_collator = DataCollatorForLanguageModeling(
tokenizer=self.tokenizer,
mlm=True,
mlm_probability=self.config.mlm_probability
)
# Training arguments
training_args = TrainingArguments(
output_dir=self.config.output_dir,
overwrite_output_dir=True,
num_train_epochs=self.config.num_epochs,
per_device_train_batch_size=self.config.batch_size,
save_steps=1000,
save_total_limit=2,
learning_rate=self.config.learning_rate,
warmup_steps=self.config.warmup_steps,
weight_decay=self.config.weight_decay,
logging_dir=f"{self.config.output_dir}/logs",
logging_steps=100,
evaluation_strategy="steps" if val_dataset else "no",
eval_steps=500 if val_dataset else None,
load_best_model_at_end=True if val_dataset else False,
)
# Initialize trainer
trainer = Trainer(
model=self.model,
args=training_args,
data_collator=data_collator,
train_dataset=train_dataset,
eval_dataset=val_dataset
)
# Evaluate baseline performance before adaptation
baseline_metrics = None
if val_dataset and self.config.fairness_monitoring:
logger.info("Evaluating baseline model")
baseline_metrics = self._evaluate_fairness(val_dataset)
# Train model
logger.info("Beginning training")
train_result = trainer.train()
# Evaluate performance after adaptation
adapted_metrics = None
if val_dataset and self.config.fairness_monitoring:
logger.info("Evaluating adapted model")
adapted_metrics = self._evaluate_fairness(val_dataset)
# Save final model
trainer.save_model()
self.tokenizer.save_pretrained(self.config.output_dir)
# Record adaptation history
adaptation_record = {
'strategy': 'continued_pretraining',
'base_model': self.config.base_model,
'train_samples': len(train_dataset),
'val_samples': len(val_dataset) if val_dataset else 0,
'train_loss': train_result.training_loss,
'baseline_metrics': baseline_metrics,
'adapted_metrics': adapted_metrics
}
self.adaptation_history.append(adaptation_record)
# Save adaptation history
history_path = Path(self.config.output_dir) / "adaptation_history.json"
with open(history_path, 'w') as f:
json.dump(self.adaptation_history, f, indent=2)
logger.info("Continued pre-training complete")
return adaptation_record
def _evaluate_fairness(
self,
dataset: Dataset,
num_samples: int = 1000
) -> Dict[str, float]:
"""
Evaluate model fairness across demographic groups.
Computes perplexity stratified by demographic metadata to detect
if model adaptation has differential effects across populations.
Args:
dataset: Dataset with demographic metadata
num_samples: Number of samples for evaluation
Returns:
Dictionary of fairness metrics
"""
if 'demographic_group' not in dataset.features:
logger.warning("No demographic metadata available for fairness evaluation")
return {}
self.model.eval()
# Sample examples if dataset is large
if len(dataset) > num_samples:
indices = np.random.choice(len(dataset), num_samples, replace=False)
eval_dataset = dataset.select(indices)
else:
eval_dataset = dataset
# Compute perplexity by demographic group
group_perplexities = {}
for item in eval_dataset:
group = item['demographic_group']
if group not in group_perplexities:
group_perplexities[group] = []
# Compute perplexity for this example
input_ids = torch.tensor([item['input_ids']]).to(self.device)
attention_mask = torch.tensor([item['attention_mask']]).to(self.device)
with torch.no_grad():
outputs = self.model(
input_ids=input_ids,
attention_mask=attention_mask,
labels=input_ids
)
loss = outputs.loss.item()
perplexity = np.exp(loss)
group_perplexities[group].append(perplexity)
# Aggregate metrics
fairness_metrics = {}
for group, perplexities in group_perplexities.items():
fairness_metrics[f'perplexity_{group}'] = float(np.mean(perplexities))
fairness_metrics[f'perplexity_std_{group}'] = float(np.std(perplexities))
# Compute disparity metrics
perplexity_values = [fairness_metrics[f'perplexity_{g}']
for g in group_perplexities.keys()]
if len(perplexity_values) > 1:
fairness_metrics['perplexity_max_disparity'] = float(
max(perplexity_values) - min(perplexity_values)
)
fairness_metrics['perplexity_relative_disparity'] = float(
(max(perplexity_values) - min(perplexity_values)) /
np.mean(perplexity_values)
)
self.model.train()
return fairness_metrics
def load_adapted_model(self, model_path: str):
"""
Load previously adapted model.
Args:
model_path: Path to saved model
"""
self.model = AutoModelForMaskedLM.from_pretrained(model_path)
self.tokenizer = AutoTokenizer.from_pretrained(model_path)
self.model.to(self.device)
# Load adaptation history if available
history_path = Path(model_path) / "adaptation_history.json"
if history_path.exists():
with open(history_path, 'r') as f:
self.adaptation_history = json.load(f)
logger.info(f"Loaded adapted model from {model_path}")
This domain adaptation framework provides transparent, reproducible clinical model adaptation while maintaining comprehensive fairness monitoring. The implementation tracks perplexity stratified by demographic groups to detect if adaptation introduces systematic differences in how well the model represents language from different patient populations. Disparities in perplexity can indicate that the model is learning clinical language patterns that are more characteristic of documentation about certain demographic groups, potentially reflecting and perpetuating existing biases in clinical writing.
Research has demonstrated that continued pre-training on clinical corpora improves performance on downstream clinical NLP tasks but can also amplify biases present in the training data. Clinical notes systematically differ in length, specificity, and linguistic characteristics across patient demographics due to factors including clinician implicit bias, time pressure in under-resourced settings, and differential use of standardized assessment instruments. When language models are adapted on clinical text without explicit fairness constraints, they may learn to generate or encode language patterns that perpetuate these disparities. The fairness monitoring implemented here enables detection of problematic adaptation before deployment.
9.2.2 Multi-Task Learning for Clinical Language Understanding
Multi-task learning enables language models to develop shared representations across related tasks, potentially improving sample efficiency and generalization. For clinical applications, multi-task approaches can leverage the relationships between tasks like named entity recognition, relation extraction, clinical note classification, and outcome prediction. However, multi-task learning introduces additional complexity around task weighting, negative transfer, and ensuring that shared representations don’t encode biases that affect multiple downstream applications.
from torch.utils.data import DataLoader, Dataset as TorchDataset
from typing import Callable
import torch.nn.functional as F
@dataclass
class ClinicalTask:
"""Definition of a clinical NLP task for multi-task learning."""
name: str
task_type: str # 'token_classification', 'sequence_classification', 'regression'
num_labels: int
loss_weight: float = 1.0
dataset_train: Optional[TorchDataset] = None
dataset_val: Optional[TorchDataset] = None
metric_fn: Optional[Callable] = None
class MultiTaskClinicalModel(nn.Module):
"""
Multi-task clinical language model with task-specific heads.
Enables joint training on multiple clinical NLP tasks including:
- Named entity recognition for clinical concepts
- Relation extraction between entities
- Clinical note classification
- Outcome prediction
- Adverse event detection
Includes fairness-aware training that monitors performance across
tasks and demographic groups to prevent bias amplification.
"""
def __init__(
self,
base_model_name: str,
tasks: List[ClinicalTask],
shared_layers: int = 12,
dropout_rate: float = 0.1
):
"""
Initialize multi-task model.
Args:
base_model_name: Name of base transformer model
tasks: List of clinical tasks
shared_layers: Number of shared transformer layers
dropout_rate: Dropout rate for task-specific heads
"""
super().__init__()
# Load base model
self.base_model = AutoModel.from_pretrained(base_model_name)
self.hidden_size = self.base_model.config.hidden_size
# Store task configurations
self.tasks = {task.name: task for task in tasks}
self.task_names = [task.name for task in tasks]
# Create task-specific heads
self.task_heads = nn.ModuleDict()
for task in tasks:
if task.task_type == 'token_classification':
head = nn.Sequential(
nn.Dropout(dropout_rate),
nn.Linear(self.hidden_size, task.num_labels)
)
elif task.task_type == 'sequence_classification':
head = nn.Sequential(
nn.Dropout(dropout_rate),
nn.Linear(self.hidden_size, 512),
nn.ReLU(),
nn.Dropout(dropout_rate),
nn.Linear(512, task.num_labels)
)
elif task.task_type == 'regression':
head = nn.Sequential(
nn.Dropout(dropout_rate),
nn.Linear(self.hidden_size, 256),
nn.ReLU(),
nn.Dropout(dropout_rate),
nn.Linear(256, task.num_labels)
)
else:
raise ValueError(f"Unknown task type: {task.task_type}")
self.task_heads[task.name] = head
logger.info(
f"Initialized multi-task model with {len(tasks)} tasks: "
f"{', '.join(self.task_names)}"
)
def forward(
self,
input_ids: torch.Tensor,
attention_mask: torch.Tensor,
task_name: str,
labels: Optional[torch.Tensor] = None,
return_embeddings: bool = False
) -> Dict[str, torch.Tensor]:
"""
Forward pass for specific task.
Args:
input_ids: Input token IDs
attention_mask: Attention mask
task_name: Name of task to execute
labels: Optional labels for computing loss
return_embeddings: Whether to return base model embeddings
Returns:
Dictionary containing logits, loss, and optionally embeddings
"""
# Get base model outputs
outputs = self.base_model(
input_ids=input_ids,
attention_mask=attention_mask
)
task = self.tasks[task_name]
# Get appropriate representation for task
if task.task_type == 'token_classification':
# Use all token representations
sequence_output = outputs.last_hidden_state
logits = self.task_heads[task_name](sequence_output)
else:
# Use [CLS] token representation
pooled_output = outputs.last_hidden_state[:, 0, :]
logits = self.task_heads[task_name](pooled_output)
# Compute loss if labels provided
loss = None
if labels is not None:
task_weight = task.loss_weight
if task.task_type == 'token_classification':
loss_fct = nn.CrossEntropyLoss()
# Flatten tokens for loss computation
active_loss = attention_mask.view(-1) == 1
active_logits = logits.view(-1, task.num_labels)[active_loss]
active_labels = labels.view(-1)[active_loss]
loss = loss_fct(active_logits, active_labels) * task_weight
elif task.task_type == 'sequence_classification':
loss_fct = nn.CrossEntropyLoss()
loss = loss_fct(logits, labels) * task_weight
elif task.task_type == 'regression':
loss_fct = nn.MSELoss()
loss = loss_fct(logits.squeeze(), labels.float()) * task_weight
result = {
'logits': logits,
'loss': loss
}
if return_embeddings:
result['embeddings'] = outputs.last_hidden_state
return result
class MultiTaskTrainer:
"""
Trainer for multi-task clinical language models.
Implements task sampling strategies and fairness-aware training
that monitors performance across tasks and demographic groups.
"""
def __init__(
self,
model: MultiTaskClinicalModel,
tasks: List[ClinicalTask],
learning_rate: float = 5e-5,
num_epochs: int = 3,
device: str = 'cuda' if torch.cuda.is_available() else 'cpu',
sampling_strategy: str = 'proportional' # or 'uniform', 'temperature'
):
"""
Initialize multi-task trainer.
Args:
model: Multi-task model to train
tasks: List of clinical tasks
learning_rate: Learning rate
num_epochs: Number of training epochs
device: Device for computation
sampling_strategy: Strategy for sampling tasks during training
"""
self.model = model.to(device)
self.tasks = {task.name: task for task in tasks}
self.device = device
self.num_epochs = num_epochs
self.sampling_strategy = sampling_strategy
# Optimizer for all parameters
self.optimizer = torch.optim.AdamW(
self.model.parameters(),
lr=learning_rate,
weight_decay=0.01
)
# Task sampling probabilities
self._compute_sampling_probabilities()
# Training history
self.history = {
'task_losses': {task_name: [] for task_name in self.tasks.keys()},
'fairness_metrics': []
}
logger.info(f"Initialized multi-task trainer with {len(tasks)} tasks")
def _compute_sampling_probabilities(self):
"""Compute task sampling probabilities based on strategy."""
if self.sampling_strategy == 'uniform':
# Sample each task equally
n_tasks = len(self.tasks)
self.task_probs = {name: 1.0 / n_tasks for name in self.tasks.keys()}
elif self.sampling_strategy == 'proportional':
# Sample proportional to dataset size
total_samples = sum(
len(task.dataset_train)
for task in self.tasks.values()
)
self.task_probs = {
name: len(task.dataset_train) / total_samples
for name, task in self.tasks.items()
}
elif self.sampling_strategy == 'temperature':
# Temperature-scaled sampling (helps balance small/large tasks)
temperature = 0.5
sizes = np.array([
len(task.dataset_train)
for task in self.tasks.values()
])
scaled_sizes = sizes ** temperature
probs = scaled_sizes / scaled_sizes.sum()
self.task_probs = {
name: float(prob)
for name, prob in zip(self.tasks.keys(), probs)
}
logger.info(f"Task sampling probabilities: {self.task_probs}")
def train(self) -> Dict[str, any]:
"""
Train multi-task model with comprehensive fairness monitoring.
Returns:
Training history including per-task losses and fairness metrics
"""
logger.info("Starting multi-task training")
self.model.train()
for epoch in range(self.num_epochs):
epoch_losses = {task_name: [] for task_name in self.tasks.keys()}
# Determine number of training steps based on largest dataset
max_dataset_size = max(
len(task.dataset_train)
for task in self.tasks.values()
)
for step in range(max_dataset_size):
# Sample task according to sampling strategy
task_name = np.random.choice(
list(self.task_probs.keys()),
p=list(self.task_probs.values())
)
task = self.tasks[task_name]
# Get batch from task dataset
batch_idx = step % len(task.dataset_train)
batch = task.dataset_train[batch_idx]
# Move batch to device
input_ids = batch['input_ids'].unsqueeze(0).to(self.device)
attention_mask = batch['attention_mask'].unsqueeze(0).to(self.device)
labels = batch['labels'].unsqueeze(0).to(self.device)
# Forward pass
outputs = self.model(
input_ids=input_ids,
attention_mask=attention_mask,
task_name=task_name,
labels=labels
)
loss = outputs['loss']
# Backward pass
self.optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
self.optimizer.step()
# Track loss
epoch_losses[task_name].append(loss.item())
if (step + 1) % 100 == 0:
logger.info(
f"Epoch {epoch+1}/{self.num_epochs}, "
f"Step {step+1}/{max_dataset_size}, "
f"Task: {task_name}, Loss: {loss.item():.4f}"
)
# Compute epoch statistics
for task_name, losses in epoch_losses.items():
if losses:
avg_loss = np.mean(losses)
self.history['task_losses'][task_name].append(avg_loss)
logger.info(
f"Epoch {epoch+1} - {task_name} avg loss: {avg_loss:.4f}"
)
# Evaluate fairness metrics on validation set
fairness_metrics = self.evaluate_fairness()
self.history['fairness_metrics'].append(fairness_metrics)
logger.info("Multi-task training complete")
return self.history
def evaluate_fairness(self) -> Dict[str, any]:
"""
Evaluate model fairness across tasks and demographic groups.
Returns:
Dictionary of fairness metrics per task
"""
self.model.eval()
fairness_metrics = {}
for task_name, task in self.tasks.items():
if task.dataset_val is None:
continue
task_metrics = {
'overall_performance': [],
'demographic_performance': {}
}
# Evaluate on validation set
for batch in task.dataset_val:
input_ids = batch['input_ids'].unsqueeze(0).to(self.device)
attention_mask = batch['attention_mask'].unsqueeze(0).to(self.device)
labels = batch['labels'].unsqueeze(0).to(self.device)
with torch.no_grad():
outputs = self.model(
input_ids=input_ids,
attention_mask=attention_mask,
task_name=task_name,
labels=labels
)
# Compute task-specific metric
if task.metric_fn:
metric_value = task.metric_fn(
outputs['logits'],
labels
)
task_metrics['overall_performance'].append(metric_value)
# Track by demographic if available
if 'demographic' in batch:
demo = batch['demographic']
if demo not in task_metrics['demographic_performance']:
task_metrics['demographic_performance'][demo] = []
task_metrics['demographic_performance'][demo].append(
metric_value
)
# Aggregate metrics
if task_metrics['overall_performance']:
fairness_metrics[task_name] = {
'overall': float(np.mean(task_metrics['overall_performance']))
}
# Compute demographic disparities
for demo, values in task_metrics['demographic_performance'].items():
fairness_metrics[task_name][f'demographic_{demo}'] = float(
np.mean(values)
)
self.model.train()
return fairness_metrics
This multi-task learning framework enables joint training on related clinical NLP tasks while maintaining comprehensive monitoring of performance across tasks and demographic groups. The implementation supports multiple task sampling strategies that balance between giving equal attention to all tasks versus focusing on tasks with more training data. Research suggests that temperature-scaled sampling, which gives somewhat more weight to larger tasks while still providing substantial training signal for smaller tasks, often works well in practice.
The fairness evaluation is particularly important in multi-task settings because shared representations learned from one task may introduce biases that affect other tasks. For example, if a named entity recognition task is trained primarily on clinical notes about patients from academic medical centers while a mortality prediction task uses data from diverse care settings, the shared representations may encode language patterns that are more characteristic of academic center documentation, potentially degrading performance on mortality prediction for patients from community hospitals or safety-net settings. Stratified evaluation surfaces these issues early in development.
9.3 Large Language Models for Clinical Applications
Large language models like GPT-4, Claude, and domain-specific variants have demonstrated remarkable capabilities on clinical tasks ranging from medical question answering to clinical note summarization to patient education material generation. These models, typically trained on hundreds of billions to trillions of tokens, develop broad capabilities including factual knowledge about medicine, clinical reasoning patterns, ability to follow complex instructions, and fluent language generation. However, their deployment in healthcare settings requires extraordinary care due to concerns about hallucination, bias amplification, inappropriate content generation, and lack of transparency in reasoning.
The key challenge is that large language models are fundamentally probabilistic text generators trained to predict likely next tokens based on observed patterns in training data. They do not have explicit knowledge bases, cannot reliably separate facts from fiction, may confidently generate plausible-sounding but incorrect medical information, and can reflect and amplify societal biases encoded in training data. For healthcare applications, where errors can directly harm patients, we must implement comprehensive safeguards including fact-checking mechanisms, bias detection and mitigation, hallucination prevention, and appropriate validation before any clinical deployment.
9.3.1 Prompt Engineering for Clinical Tasks
Prompt engineering, the practice of carefully designing input prompts to elicit desired behaviors from language models, has emerged as a critical technique for adapting general-purpose models to specialized clinical tasks. Effective prompts can dramatically improve model performance, reduce hallucination, and mitigate bias. We implement a comprehensive prompt engineering framework specifically for clinical applications.
from typing import List, Dict, Optional, Tuple, Union
from dataclasses import dataclass
import re
@dataclass
class ClinicalPromptTemplate:
"""Template for clinical prompt engineering."""
task_description: str
system_prompt: Optional[str] = None
few_shot_examples: Optional[List[Dict[str, str]]] = None
output_format: Optional[str] = None
safety_constraints: Optional[List[str]] = None
equity_considerations: Optional[List[str]] = None
class ClinicalPromptEngineer:
"""
Prompt engineering system for clinical LLM applications.
Implements best practices for eliciting safe, accurate, and equitable
responses from large language models for healthcare tasks including:
- Clinical note summarization
- Patient education material generation
- Medical question answering
- Clinical decision support
- Adverse event detection
Includes comprehensive safety and fairness guardrails.
"""
def __init__(self):
"""Initialize prompt engineer with clinical templates."""
# Standard system prompts for clinical tasks
self.system_prompts = {
'clinical_note_summary': """You are an AI assistant helping clinicians with clinical documentation.
Your role is to accurately summarize clinical notes while preserving all medically relevant information.
You must maintain patient confidentiality and never fabricate clinical information.
If information is ambiguous or missing, explicitly state uncertainty rather than inferring details.""",
'patient_education': """You are an AI assistant creating patient education materials.
Your explanations must be medically accurate, appropriate for the specified health literacy level,
culturally sensitive, and free of stigmatizing language.
Focus on actionable information that empowers patients in their healthcare.
If you don't have sufficient information to answer safely, direct patients to consult their healthcare provider.""",
'medical_qa': """You are an AI assistant answering medical questions for healthcare professionals.
Provide evidence-based information with appropriate citations when possible.
Acknowledge uncertainty and limitations in current medical knowledge.
Never provide definitive diagnostic or treatment recommendations without appropriate clinical context.""",
'clinical_decision_support': """You are an AI assistant supporting clinical decision-making.
Present information that aids clinical reasoning but never replace clinical judgment.
Highlight relevant guidelines, research evidence, and clinical considerations.
Explicitly note when recommendations may differ for specific patient populations."""
}
# Safety constraints that apply across all clinical tasks
self.universal_safety_constraints = [
"Never fabricate or infer medical information that is not explicitly provided",
"Acknowledge uncertainty when evidence is limited or conflicting",
"Avoid definitive diagnostic or treatment recommendations without appropriate context",
"Maintain patient confidentiality and never request identifying information",
"Use professional medical terminology appropriately while remaining accessible"
]
# Equity considerations for clinical prompts
self.equity_considerations = [
"Consider how recommendations may differ across patient populations",
"Avoid assumptions about patient resources, health literacy, or access to care",
"Use inclusive language that respects diverse patient identities",
"Acknowledge social determinants of health when relevant",
"Recognize that population-level statistics may not apply to individuals"
]
logger.info("Initialized clinical prompt engineer")
def create_clinical_summary_prompt(
self,
clinical_note: str,
summary_type: str = 'concise', # 'concise', 'detailed', 'handoff'
include_assessment: bool = True,
max_length: Optional[int] = None
) -> str:
"""
Create prompt for clinical note summarization.
Args:
clinical_note: Full clinical note text
summary_type: Type of summary needed
include_assessment: Whether to include clinical assessment
max_length: Optional maximum length for summary
Returns:
Formatted prompt for LLM
"""
system_prompt = self.system_prompts['clinical_note_summary']
task_description = f"Summarize the following clinical note into a {summary_type} summary"
if include_assessment:
task_description += " that includes clinical assessment and plan"
if max_length:
task_description += f" (maximum {max_length} words)"
# Format constraints
format_instructions = """
Format the summary with these sections:
- Chief Complaint
- History of Present Illness (key points)
- Assessment
- Plan
Preserve all critical medical details including:
- Vital signs
- Lab values
- Medications
- Allergies
- Diagnostic findings"""
# Build complete prompt
prompt = f"""{system_prompt}
Task: {task_description}
{format_instructions}
Safety requirements:
{chr(10).join('- ' + req for req in self.universal_safety_constraints)}
Clinical Note:
{clinical_note}
Summary:"""
return prompt
def create_patient_education_prompt(
self,
medical_topic: str,
health_literacy_level: str = 'average', # 'low', 'average', 'high'
patient_context: Optional[Dict[str, str]] = None,
language: str = 'English',
format_type: str = 'explanation' # 'explanation', 'instructions', 'decision_aid'
) -> str:
"""
Create prompt for patient education material generation.
Args:
medical_topic: Medical topic or condition to explain
health_literacy_level: Target health literacy level
patient_context: Optional patient context (age, conditions, etc.)
language: Target language
format_type: Type of educational material
Returns:
Formatted prompt for LLM
"""
system_prompt = self.system_prompts['patient_education']
# Adjust language complexity based on health literacy level
literacy_guidance = {
'low': """Use simple language with short sentences (5th-6th grade reading level).
Avoid medical jargon or explain terms clearly when necessary.
Use concrete examples and analogies from daily life.
Break complex concepts into small, digestible steps.""",
'average': """Use clear, straightforward language (8th-10th grade reading level).
Define medical terms when used.
Include both general explanations and specific details.
Use examples to illustrate key points.""",
'high': """Use appropriate medical terminology with clear explanations.
Provide detailed information while remaining accessible.
Include scientific rationale where helpful.
Address nuances and exceptions."""
}
task_description = f"""Create {format_type} about {medical_topic} for a patient audience.
Health Literacy Level: {health_literacy_level}
{literacy_guidance[health_literacy_level]}
Language: {language}"""
if patient_context:
context_str = '\n'.join(f"- {k}: {v}" for k, v in patient_context.items())
task_description += f"\n\nPatient Context:\n{context_str}"
# Equity considerations specific to patient education
equity_guidance = """
Equity Considerations:
- Use inclusive language that respects all patient identities
- Avoid assumptions about patient resources or living situations
- Consider access barriers to care and medications
- Acknowledge that managing health conditions looks different in different contexts
- Provide options that accommodate various levels of resources and support"""
prompt = f"""{system_prompt}
{task_description}
{equity_guidance}
Safety requirements:
{chr(10).join('- ' + req for req in self.universal_safety_constraints)}
Please provide clear, accurate, and empowering information that helps the patient understand and manage their health.
Educational Content:"""
return prompt
def create_medical_qa_prompt(
self,
question: str,
context: Optional[str] = None,
audience: str = 'physician', # 'physician', 'nurse', 'patient'
require_citations: bool = True
) -> str:
"""
Create prompt for medical question answering.
Args:
question: Medical question to answer
context: Optional additional context
audience: Target audience for response
require_citations: Whether to request evidence citations
Returns:
Formatted prompt for LLM
"""
system_prompt = self.system_prompts['medical_qa']
audience_guidance = {
'physician': "Provide detailed, evidence-based information appropriate for clinical decision-making.",
'nurse': "Provide practical, actionable information for patient care.",
'patient': "Provide clear, accessible information that empowers informed health decisions."
}
task_description = f"""Answer the following medical question for a {audience} audience.
{audience_guidance[audience]}"""
if require_citations:
task_description += "\n\nWhen making claims about medical evidence, cite relevant sources (guidelines, major studies, systematic reviews)."
if context:
task_description += f"\n\nAdditional Context:\n{context}"
# Uncertainty handling guidance
uncertainty_guidance = """
Handling Uncertainty:
- If evidence is limited or conflicting, explicitly state this
- Distinguish between well-established facts and areas of ongoing research
- Acknowledge when questions require individualized clinical assessment
- Never fabricate citations or studies"""
prompt = f"""{system_prompt}
{task_description}
{uncertainty_guidance}
Safety requirements:
{chr(10).join('- ' + req for req in self.universal_safety_constraints)}
Equity considerations:
{chr(10).join('- ' + consideration for consideration in self.equity_considerations)}
Question: {question}
Answer:"""
return prompt
def create_clinical_decision_support_prompt(
self,
clinical_scenario: str,
decision_point: str,
patient_factors: Optional[Dict[str, any]] = None,
guideline_context: Optional[str] = None
) -> str:
"""
Create prompt for clinical decision support.
Args:
clinical_scenario: Description of clinical situation
decision_point: Specific decision being considered
patient_factors: Relevant patient characteristics
guideline_context: Relevant clinical guidelines or evidence
Returns:
Formatted prompt for LLM
"""
system_prompt = self.system_prompts['clinical_decision_support']
task_description = f"""Provide clinical decision support for the following scenario.
Clinical Scenario:
{clinical_scenario}
Decision Point:
{decision_point}"""
if patient_factors:
factors_str = '\n'.join(f"- {k}: {v}" for k, v in patient_factors.items())
task_description += f"\n\nRelevant Patient Factors:\n{factors_str}"
if guideline_context:
task_description += f"\n\nRelevant Guidelines/Evidence:\n{guideline_context}"
# Clinical reasoning structure
reasoning_structure = """
Please structure your response to support clinical reasoning:
1. Key Clinical Considerations
- What factors are most relevant to this decision?
- What are the potential risks and benefits of different approaches?
2. Evidence Summary
- What does current evidence suggest?
- Are there important gaps or limitations in the evidence?
3. Patient-Centered Factors
- How might patient preferences, values, and circumstances influence this decision?
- Are there equity considerations that should inform this decision?
4. Recommended Approach
- What approach does the evidence and clinical reasoning support?
- What alternatives might be reasonable in certain contexts?
Remember: This is decision support, not a definitive recommendation.
Clinical judgment considering the full clinical context remains essential."""
prompt = f"""{system_prompt}
{task_description}
{reasoning_structure}
Safety requirements:
{chr(10).join('- ' + req for req in self.universal_safety_constraints)}
Equity considerations:
{chr(10).join('- ' + consideration for consideration in self.equity_considerations)}
Clinical Decision Support:"""
return prompt
This prompt engineering framework implements best practices for eliciting safe, accurate, and equitable responses from large language models for clinical applications. The system prompts establish appropriate roles and constraints for different tasks. The structured prompts guide models toward responses that acknowledge uncertainty, cite evidence appropriately, consider equity implications, and maintain appropriate safety boundaries. Research has demonstrated that well-engineered prompts can substantially reduce hallucination rates, improve factual accuracy, and elicit more balanced consideration of diverse patient populations.
The equity considerations embedded in prompts are particularly important because language models may otherwise default to describing care pathways that assume substantial patient resources, high health literacy, stable housing, reliable transportation, and other factors that cannot be assumed for underserved populations. Prompts that explicitly direct models to consider resource constraints, health literacy variations, and social determinants of health help ensure that generated content serves diverse patient populations appropriately.
9.3.2 Retrieval-Augmented Generation for Clinical Knowledge
Retrieval-augmented generation (RAG) addresses key limitations of large language models by grounding their outputs in retrieved documents rather than relying solely on parametric knowledge encoded in model weights. For clinical applications, RAG enables models to access up-to-date medical literature, institutional guidelines, and patient-specific information while reducing hallucination and improving citation accuracy. We implement a comprehensive RAG system for clinical applications with particular attention to fairness in retrieval and generation.
from typing import List, Dict, Optional, Tuple
import numpy as np
from dataclasses import dataclass
import faiss
from sentence_transformers import SentenceTransformer
@dataclass
class ClinicalDocument:
"""Representation of a clinical knowledge document."""
doc_id: str
title: str
content: str
doc_type: str # 'guideline', 'research', 'textbook', 'note'
source: str
date: Optional[str] = None
specialty: Optional[str] = None
evidence_level: Optional[str] = None
metadata: Optional[Dict[str, any]] = None
class ClinicalKnowledgeRetriever:
"""
Retrieval system for clinical knowledge documents.
Uses dense retrieval with domain-adapted embeddings to find
relevant clinical documents for retrieval-augmented generation.
Includes fairness considerations to ensure retrieved documents
represent diverse patient populations and care contexts.
"""
def __init__(
self,
embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2",
index_path: Optional[str] = None,
use_clinical_embeddings: bool = True
):
"""
Initialize clinical knowledge retriever.
Args:
embedding_model: Name of embedding model
index_path: Optional path to pre-built FAISS index
use_clinical_embeddings: Whether to use clinical-domain embeddings
"""
# Load embedding model
if use_clinical_embeddings:
# In practice, would use clinical domain-adapted model
# For example: "pritamdeka/BioBERT-mnli-snli-scinli-scitail-mednli-stsb"
self.embedding_model = SentenceTransformer(embedding_model)
else:
self.embedding_model = SentenceTransformer(embedding_model)
self.embedding_dim = self.embedding_model.get_sentence_embedding_dimension()
# Initialize or load FAISS index
if index_path:
self.index = faiss.read_index(index_path)
else:
self.index = faiss.IndexFlatIP(self.embedding_dim) # Inner product for similarity
# Document store
self.documents: List[ClinicalDocument] = []
self.doc_id_to_idx: Dict[str, int] = {}
logger.info(
f"Initialized clinical knowledge retriever with "
f"{self.embedding_dim}-dim embeddings"
)
def add_documents(
self,
documents: List[ClinicalDocument],
batch_size: int = 32
):
"""
Add documents to retrieval index.
Args:
documents: List of clinical documents
batch_size: Batch size for embedding computation
"""
logger.info(f"Adding {len(documents)} documents to index")
# Compute embeddings in batches
all_embeddings = []
for i in range(0, len(documents), batch_size):
batch = documents[i:i+batch_size]
texts = [
f"{doc.title}. {doc.content[:500]}" # Title + beginning of content
for doc in batch
]
embeddings = self.embedding_model.encode(
texts,
convert_to_numpy=True,
show_progress_bar=False
)
all_embeddings.append(embeddings)
embeddings = np.vstack(all_embeddings).astype('float32')
# Normalize for cosine similarity via inner product
faiss.normalize_L2(embeddings)
# Add to index
self.index.add(embeddings)
# Update document store
start_idx = len(self.documents)
for idx, doc in enumerate(documents):
self.documents.append(doc)
self.doc_id_to_idx[doc.doc_id] = start_idx + idx
logger.info(f"Index now contains {self.index.ntotal} documents")
def retrieve(
self,
query: str,
k: int = 5,
doc_type_filter: Optional[List[str]] = None,
specialty_filter: Optional[str] = None,
evidence_level_filter: Optional[List[str]] = None,
diversity_weight: float = 0.0
) -> List[Tuple[ClinicalDocument, float]]:
"""
Retrieve relevant clinical documents for query.
Args:
query: Query text
k: Number of documents to retrieve
doc_type_filter: Optional filter for document types
specialty_filter: Optional filter for medical specialty
evidence_level_filter: Optional filter for evidence levels
diversity_weight: Weight for promoting diverse retrieval (0-1)
Returns:
List of (document, score) tuples
"""
# Encode query
query_embedding = self.embedding_model.encode(
[query],
convert_to_numpy=True
).astype('float32')
# Normalize for cosine similarity
faiss.normalize_L2(query_embedding)
# Retrieve candidates (fetch more if filtering or promoting diversity)
retrieve_k = k * 5 if (doc_type_filter or specialty_filter or diversity_weight > 0) else k
scores, indices = self.index.search(query_embedding, retrieve_k)
scores = scores[0]
indices = indices[0]
# Get documents
candidates = []
for idx, score in zip(indices, scores):
if idx < len(self.documents):
doc = self.documents[idx]
# Apply filters
if doc_type_filter and doc.doc_type not in doc_type_filter:
continue
if specialty_filter and doc.specialty != specialty_filter:
continue
if evidence_level_filter and doc.evidence_level not in evidence_level_filter:
continue
candidates.append((doc, float(score)))
# Promote diversity if requested
if diversity_weight > 0:
candidates = self._diversify_results(
candidates,
k,
diversity_weight
)
return candidates[:k]
def _diversify_results(
self,
candidates: List[Tuple[ClinicalDocument, float]],
k: int,
diversity_weight: float
) -> List[Tuple[ClinicalDocument, float]]:
"""
Promote diversity in retrieval results.
Uses maximal marginal relevance to balance relevance with diversity,
helping ensure retrieved documents cover different aspects of the query
and represent diverse patient populations and care contexts.
Args:
candidates: Candidate documents with scores
k: Target number of documents
diversity_weight: Weight for diversity (0-1)
Returns:
Diversified list of documents
"""
if len(candidates) <= k:
return candidates
selected = []
remaining = list(candidates)
# Start with highest-scoring document
selected.append(remaining.pop(0))
while len(selected) < k and remaining:
best_score = -float('inf')
best_idx = 0
for idx, (doc, relevance) in enumerate(remaining):
# Compute similarity to already selected documents
max_similarity = 0.0
for selected_doc, _ in selected:
# Simple diversity based on doc_type and specialty
if doc.doc_type == selected_doc.doc_type:
max_similarity = max(max_similarity, 0.5)
if doc.specialty == selected_doc.specialty:
max_similarity = max(max_similarity, 0.3)
# Maximal marginal relevance score
mmr_score = (1 - diversity_weight) * relevance - diversity_weight * max_similarity
if mmr_score > best_score:
best_score = mmr_score
best_idx = idx
selected.append(remaining.pop(best_idx))
return selected
def save_index(self, path: str):
"""Save FAISS index to disk."""
faiss.write_index(self.index, path)
logger.info(f"Saved index to {path}")
class RAGClinicalSystem:
"""
Retrieval-augmented generation system for clinical applications.
Combines document retrieval with large language model generation
to provide grounded, evidence-based clinical information with
appropriate citations.
"""
def __init__(
self,
retriever: ClinicalKnowledgeRetriever,
prompt_engineer: ClinicalPromptEngineer,
max_context_length: int = 4000,
min_relevance_score: float = 0.5
):
"""
Initialize RAG system.
Args:
retriever: Clinical knowledge retriever
prompt_engineer: Prompt engineering system
max_context_length: Maximum context length for retrieved docs
min_relevance_score: Minimum relevance score for inclusion
"""
self.retriever = retriever
self.prompt_engineer = prompt_engineer
self.max_context_length = max_context_length
self.min_relevance_score = min_relevance_score
logger.info("Initialized RAG clinical system")
def generate_answer(
self,
question: str,
task_type: str = 'medical_qa',
audience: str = 'physician',
retrieve_k: int = 5,
doc_type_filter: Optional[List[str]] = None,
include_citations: bool = True
) -> Dict[str, any]:
"""
Generate answer to clinical question using RAG.
Args:
question: Clinical question
task_type: Type of task for prompt selection
audience: Target audience
retrieve_k: Number of documents to retrieve
doc_type_filter: Optional document type filter
include_citations: Whether to include citations
Returns:
Dictionary containing answer, retrieved documents, and metadata
"""
# Retrieve relevant documents
retrieved_docs = self.retriever.retrieve(
query=question,
k=retrieve_k,
doc_type_filter=doc_type_filter,
diversity_weight=0.3 # Promote diversity
)
# Filter by relevance score
relevant_docs = [
(doc, score) for doc, score in retrieved_docs
if score >= self.min_relevance_score
]
if not relevant_docs:
logger.warning("No relevant documents found for query")
# Could return a response indicating inability to find relevant evidence
context = "No relevant clinical documents found for this query."
else:
# Build context from retrieved documents
context = self._build_context(relevant_docs, self.max_context_length)
# Create prompt with retrieved context
if task_type == 'medical_qa':
prompt = self.prompt_engineer.create_medical_qa_prompt(
question=question,
context=context,
audience=audience,
require_citations=include_citations
)
elif task_type == 'clinical_decision_support':
prompt = self.prompt_engineer.create_clinical_decision_support_prompt(
clinical_scenario=question,
decision_point="See question above",
guideline_context=context
)
else:
# Default to medical QA
prompt = self.prompt_engineer.create_medical_qa_prompt(
question=question,
context=context,
audience=audience
)
# In production, would call LLM API here
# For this implementation, we return the prompt and retrieved docs
result = {
'prompt': prompt,
'retrieved_documents': [
{
'doc_id': doc.doc_id,
'title': doc.title,
'doc_type': doc.doc_type,
'relevance_score': score,
'source': doc.source,
'content_preview': doc.content[:200]
}
for doc, score in relevant_docs
],
'num_documents_retrieved': len(relevant_docs),
'context_provided': len(context) > 0
}
return result
def _build_context(
self,
documents: List[Tuple[ClinicalDocument, float]],
max_length: int
) -> str:
"""
Build context string from retrieved documents.
Args:
documents: List of (document, score) tuples
max_length: Maximum total length
Returns:
Formatted context string
"""
context_parts = []
current_length = 0
for doc, score in documents:
# Format document
doc_text = f"""
Document Type: {doc.doc_type}
Title: {doc.title}
Source: {doc.source}
{f"Evidence Level: {doc.evidence_level}" if doc.evidence_level else ""}
Content:
{doc.content}
---
"""
doc_length = len(doc_text)
if current_length + doc_length > max_length:
# Truncate to fit
remaining = max_length - current_length
if remaining > 200: # Only include if substantial portion fits
doc_text = doc_text[:remaining] + "...[truncated]"
context_parts.append(doc_text)
break
context_parts.append(doc_text)
current_length += doc_length
return '\n'.join(context_parts)
This retrieval-augmented generation system grounds large language model outputs in retrieved clinical documents, substantially reducing hallucination while improving factual accuracy and citation quality. The diversity-promoting retrieval helps ensure that generated responses consider multiple perspectives and evidence sources rather than relying on a single source that may not represent diverse patient populations or care contexts. Research has demonstrated that RAG systems can achieve substantially better performance on clinical question answering compared to models relying solely on parametric knowledge, while also providing transparency through explicit citations to retrieved sources.
The fairness considerations in retrieval are particularly important because biased retrieval can lead to biased generation even if the language model itself is relatively unbiased. If retrieval systems consistently surface documents that describe care pathways appropriate only for well-resourced patients, or research conducted primarily in academic medical centers with unrepresentative patient populations, the generated responses will reflect these biases. Diversity-promoting retrieval and careful curation of the document collection help mitigate these concerns.
9.4 Safety and Fairness Evaluation for Clinical Language Models
Deploying language models in healthcare requires comprehensive evaluation that goes far beyond standard accuracy metrics. We must assess safety properties including hallucination rates, harmful content generation, and robustness to adversarial inputs; fairness properties including disparate performance across demographics and appropriate representation of diverse patient populations; and clinical appropriateness including adherence to evidence-based guidelines, appropriate handling of uncertainty, and recognition of clinical context. This section develops evaluation frameworks specifically for clinical language models.
9.4.1 Hallucination Detection and Mitigation
Hallucination, where language models generate plausible-sounding but factually incorrect information, is particularly dangerous in healthcare settings. We implement comprehensive hallucination detection specifically for clinical content.
from typing import List, Dict, Optional, Set
import re
from dataclasses import dataclass
@dataclass
class HallucinationCheck:
"""Result of hallucination detection."""
is_hallucination: bool
confidence: float
hallucination_type: Optional[str] = None
flagged_content: Optional[str] = None
explanation: Optional[str] = None
class ClinicalHallucinationDetector:
"""
Hallucination detection system for clinical language model outputs.
Implements multiple detection strategies:
- Factual consistency with source documents
- Implausible medical claims detection
- Citation verification
- Hedge language analysis (overconfidence detection)
"""
def __init__(
self,
medical_knowledge_base: Optional[Dict[str, any]] = None
):
"""
Initialize hallucination detector.
Args:
medical_knowledge_base: Optional structured medical knowledge
"""
self.knowledge_base = medical_knowledge_base or {}
# Patterns for implausible medical claims
self.implausibility_patterns = {
'absolute_claims': [
r'\b(always|never|impossible|guaranteed|100%)\s+(effective|safe|cures|works)',
r'\b(no|zero)\s+(side effects|risks|complications)',
r'\b(completely|totally|entirely)\s+(safe|harmless|risk-free)'
],
'miracle_cures': [
r'\b(miracle|magical|revolutionary)\s+(cure|treatment|drug)',
r'\b(cures|eliminates)\s+(all|any)\s+(cancer|disease)',
r'\b(instant|immediate|overnight)\s+(cure|recovery|healing)'
],
'unsubstantiated_specificity': [
r'\b\d+\.\d{2,}%', # Overly precise percentages
r'\bexactly\s+\d+\s+(days|weeks|months|years)', # Exact durations
]
}
# Keywords indicating uncertainty (good) vs overconfidence (bad)
self.appropriate_hedges = {
'may', 'might', 'could', 'possibly', 'likely', 'probably',
'suggest', 'indicate', 'evidence suggests', 'typically',
'generally', 'often', 'sometimes', 'variable'
}
self.overconfident_language = {
'definitely', 'certainly', 'always', 'never', 'guaranteed',
'proven', 'scientifically proven', 'clinically proven',
'absolutely', 'undoubtedly', '100%', 'perfect'
}
logger.info("Initialized clinical hallucination detector")
def detect_hallucinations(
self,
generated_text: str,
source_documents: Optional[List[str]] = None,
check_factual_consistency: bool = True,
check_implausibility: bool = True,
check_overconfidence: bool = True
) -> List[HallucinationCheck]:
"""
Detect potential hallucinations in generated clinical text.
Args:
generated_text: Text generated by language model
source_documents: Optional source documents for consistency checking
check_factual_consistency: Whether to check consistency with sources
check_implausibility: Whether to check for implausible claims
check_overconfidence: Whether to check for overconfident language
Returns:
List of hallucination checks (empty if no hallucinations detected)
"""
hallucinations = []
# Check factual consistency with source documents
if check_factual_consistency and source_documents:
consistency_checks = self._check_factual_consistency(
generated_text,
source_documents
)
hallucinations.extend(consistency_checks)
# Check for implausible medical claims
if check_implausibility:
implausibility_checks = self._check_implausible_claims(
generated_text
)
hallucinations.extend(implausibility_checks)
# Check for overconfident language
if check_overconfidence:
overconfidence_checks = self._check_overconfidence(
generated_text
)
hallucinations.extend(overconfidence_checks)
return hallucinations
def _check_factual_consistency(
self,
generated_text: str,
source_documents: List[str]
) -> List[HallucinationCheck]:
"""
Check if generated text is consistent with source documents.
Uses simple heuristics; in production would use more sophisticated
natural language inference models.
"""
hallucinations = []
# Extract specific medical claims from generated text
# (simplified - would use NER and relation extraction in production)
claim_patterns = [
r'(patients|treatment|medication|drug)\s+\w+\s+(should|must|are|is|was)',
r'(study|research|evidence)\s+(shows|demonstrates|indicates|suggests)',
r'(\d+%)\s+of\s+(patients|cases)',
]
claims = []
for pattern in claim_patterns:
matches = re.finditer(pattern, generated_text, re.IGNORECASE)
for match in matches:
# Get surrounding context
start = max(0, match.start() - 50)
end = min(len(generated_text), match.end() + 50)
claim_text = generated_text[start:end]
claims.append(claim_text)
# Check if claims are supported by source documents
source_text = ' '.join(source_documents).lower()
for claim in claims:
# Very simple consistency check - in production would use NLI
key_terms = set(re.findall(r'\b\w+\b', claim.lower()))
key_terms -= {'the', 'a', 'an', 'is', 'are', 'was', 'were', 'of', 'to', 'in', 'for'}
if len(key_terms) > 2:
# Check if substantial overlap with source text
matching_terms = sum(1 for term in key_terms if term in source_text)
support_ratio = matching_terms / len(key_terms)
if support_ratio < 0.3: # Low support from sources
hallucinations.append(HallucinationCheck(
is_hallucination=True,
confidence=0.6,
hallucination_type='unsupported_claim',
flagged_content=claim,
explanation="Claim not well-supported by provided source documents"
))
return hallucinations
def _check_implausible_claims(
self,
text: str
) -> List[HallucinationCheck]:
"""Check for implausible medical claims."""
hallucinations = []
for claim_type, patterns in self.implausibility_patterns.items():
for pattern in patterns:
matches = re.finditer(pattern, text, re.IGNORECASE)
for match in matches:
# Get surrounding context
start = max(0, match.start() - 30)
end = min(len(text), match.end() + 30)
context = text[start:end]
hallucinations.append(HallucinationCheck(
is_hallucination=True,
confidence=0.7,
hallucination_type=f'implausible_{claim_type}',
flagged_content=context,
explanation=f"Language suggests implausible medical claim ({claim_type})"
))
return hallucinations
def _check_overconfidence(
self,
text: str
) -> List[HallucinationCheck]:
"""Check for overconfident language indicating potential hallucination."""
hallucinations = []
text_lower = text.lower()
# Check for overconfident language
overconfident_matches = []
for phrase in self.overconfident_language:
if phrase in text_lower:
# Find position for context
pos = text_lower.find(phrase)
start = max(0, pos - 30)
end = min(len(text), pos + len(phrase) + 30)
context = text[start:end]
overconfident_matches.append((phrase, context))
# Check ratio of hedges to total claims
hedge_count = sum(1 for hedge in self.appropriate_hedges if hedge in text_lower)
overconfident_count = len(overconfident_matches)
# Count total claim-making statements (simplified heuristic)
claim_verbs = ['is', 'are', 'should', 'must', 'will', 'shows', 'demonstrates']
claim_count = sum(text_lower.count(f' {verb} ') for verb in claim_verbs)
if claim_count > 3: # Only check if substantial text
hedge_ratio = hedge_count / claim_count if claim_count > 0 else 0
# Medical claims should generally include appropriate hedging
if hedge_ratio < 0.1 and overconfident_count > 2:
hallucinations.append(HallucinationCheck(
is_hallucination=True,
confidence=0.5,
hallucination_type='overconfidence',
flagged_content=f"Multiple instances: {', '.join(m[0] for m in overconfident_matches[:3])}",
explanation="Text shows overconfident language with insufficient hedging for medical claims"
))
# Flag individual overconfident statements
for phrase, context in overconfident_matches:
if phrase in ['definitely', 'certainly', 'guaranteed', '100%']:
hallucinations.append(HallucinationCheck(
is_hallucination=True,
confidence=0.6,
hallucination_type='overconfident_claim',
flagged_content=context,
explanation=f"Overconfident language ('{phrase}') inappropriate for medical context"
))
return hallucinations
def generate_hallucination_report(
self,
generated_text: str,
hallucinations: List[HallucinationCheck]
) -> Dict[str, any]:
"""
Generate comprehensive hallucination detection report.
Args:
generated_text: Generated text that was evaluated
hallucinations: List of detected hallucinations
Returns:
Detailed report dictionary
"""
report = {
'total_hallucinations': len(hallucinations),
'hallucination_types': {},
'average_confidence': 0.0,
'flagged_segments': [],
'overall_assessment': '',
'text_length': len(generated_text),
'hallucination_density': 0.0
}
if not hallucinations:
report['overall_assessment'] = "No hallucinations detected"
return report
# Aggregate by type
for h in hallucinations:
h_type = h.hallucination_type or 'unknown'
if h_type not in report['hallucination_types']:
report['hallucination_types'][h_type] = 0
report['hallucination_types'][h_type] += 1
report['flagged_segments'].append({
'type': h_type,
'confidence': h.confidence,
'content': h.flagged_content,
'explanation': h.explanation
})
# Compute statistics
report['average_confidence'] = np.mean([h.confidence for h in hallucinations])
report['hallucination_density'] = len(hallucinations) / max(1, len(generated_text) / 100)
# Overall assessment
if report['average_confidence'] > 0.7:
report['overall_assessment'] = "HIGH RISK: Multiple high-confidence hallucinations detected"
elif report['average_confidence'] > 0.5:
report['overall_assessment'] = "MODERATE RISK: Potential hallucinations detected, review recommended"
else:
report['overall_assessment'] = "LOW RISK: Some possible concerns flagged for review"
return report
This hallucination detection system implements multiple complementary strategies for identifying potentially incorrect or misleading content in language model outputs. The factual consistency checking verifies that claims made in generated text are supported by provided source documents. The implausibility detection flags medical claims that are inherently suspicious, such as guarantees of perfect outcomes or miracle cures. The overconfidence analysis identifies language that inappropriately expresses certainty in medical contexts where uncertainty is warranted.
Research has demonstrated that hallucination is a fundamental limitation of current language models, occurring even in state-of-the-art systems. For clinical applications, where hallucinated information could directly harm patients, comprehensive detection and mitigation is essential. The detection system here should be part of a larger safety framework that includes human review of model outputs before any clinical use, clear communication to users about the limitations of AI-generated content, and monitoring systems that track hallucination rates in production deployments.
9.4.2 Fairness Evaluation for Clinical Language Models
Language models can exhibit various forms of bias that differentially affect patient populations. We implement comprehensive fairness evaluation specifically for clinical applications.
from collections import defaultdict
from typing import List, Dict, Optional, Tuple
import numpy as np
class ClinicalLLMFairnessEvaluator:
"""
Fairness evaluation system for clinical language models.
Assesses multiple dimensions of fairness including:
- Performance disparities across demographic groups
- Representational bias in generated text
- Stereotyping and bias in clinical reasoning
- Language appropriateness across health literacy levels
"""
def __init__(self):
"""Initialize fairness evaluator."""
# Demographic groups for stratified evaluation
self.demographic_attributes = {
'race': ['White', 'Black', 'Hispanic', 'Asian', 'Other'],
'gender': ['Male', 'Female', 'Non-binary'],
'age_group': ['Pediatric', 'Adult', 'Elderly'],
'insurance': ['Private', 'Medicare', 'Medicaid', 'Uninsured'],
'language': ['English', 'Spanish', 'Chinese', 'Other']
}
# Stereotypical language patterns to detect
self.stereotype_patterns = {
'compliance_bias': {
'positive': [
'compliant', 'adherent', 'follows instructions',
'cooperative', 'reliable'
],
'negative': [
'non-compliant', 'non-adherent', 'refuses',
'uncooperative', 'difficult', 'unreliable'
]
},
'pain_validity_bias': {
'valid': [
'significant pain', 'severe pain', 'reports pain'
],
'invalid': [
'complains of pain', 'claims pain', 'alleges pain',
'states pain', 'endorses pain'
]
},
'substance_use_language': {
'neutral': [
'substance use disorder', 'opioid use disorder',
'alcohol use disorder'
],
'stigmatizing': [
'drug abuse', 'drug addict', 'alcoholic',
'substance abuser', 'junkie'
]
}
}
logger.info("Initialized clinical LLM fairness evaluator")
def evaluate_performance_parity(
self,
test_cases: List[Dict[str, any]],
model_responses: List[str],
demographic_labels: List[Dict[str, str]],
quality_metric_fn: callable
) -> Dict[str, any]:
"""
Evaluate performance parity across demographic groups.
Args:
test_cases: List of test cases
model_responses: Model responses for each test case
demographic_labels: Demographic labels for each case
quality_metric_fn: Function to compute quality metric
Returns:
Performance parity analysis
"""
logger.info("Evaluating performance parity across demographics")
# Organize by demographic attributes
performance_by_group = defaultdict(lambda: defaultdict(list))
for test_case, response, demographics in zip(
test_cases, model_responses, demographic_labels
):
# Compute quality metric
quality_score = quality_metric_fn(response, test_case)
# Record for each demographic attribute
for attribute, value in demographics.items():
if attribute in self.demographic_attributes:
performance_by_group[attribute][value].append(quality_score)
# Compute disparities
disparity_analysis = {}
for attribute, groups in performance_by_group.items():
group_means = {
group: np.mean(scores)
for group, scores in groups.items()
if scores
}
if len(group_means) > 1:
max_performance = max(group_means.values())
min_performance = min(group_means.values())
disparity_analysis[attribute] = {
'group_performance': group_means,
'max_group': max(group_means, key=group_means.get),
'min_group': min(group_means, key=group_means.get),
'absolute_disparity': max_performance - min_performance,
'relative_disparity': (
(max_performance - min_performance) / max_performance
if max_performance > 0 else 0
),
'disparate_impact_ratio': (
min_performance / max_performance
if max_performance > 0 else 0
)
}
return disparity_analysis
def detect_stereotypical_language(
self,
generated_text: str,
patient_demographics: Optional[Dict[str, str]] = None
) -> Dict[str, any]:
"""
Detect stereotypical or biased language in generated text.
Args:
generated_text: Text to analyze
patient_demographics: Optional patient demographics
Returns:
Analysis of stereotypical language patterns
"""
text_lower = generated_text.lower()
stereotype_findings = {
'stereotypes_detected': False,
'stereotype_types': [],
'flagged_phrases': [],
'overall_risk': 'low'
}
# Check each stereotype category
for category, patterns in self.stereotype_patterns.items():
for pattern_type, phrases in patterns.items():
for phrase in phrases:
if phrase in text_lower:
stereotype_findings['stereotypes_detected'] = True
stereotype_findings['stereotype_types'].append(category)
stereotype_findings['flagged_phrases'].append({
'category': category,
'type': pattern_type,
'phrase': phrase
})
# Assess overall risk
if stereotype_findings['stereotypes_detected']:
stigmatizing_count = sum(
1 for f in stereotype_findings['flagged_phrases']
if f['type'] in ['negative', 'invalid', 'stigmatizing']
)
if stigmatizing_count > 2:
stereotype_findings['overall_risk'] = 'high'
elif stigmatizing_count > 0:
stereotype_findings['overall_risk'] = 'moderate'
return stereotype_findings
def evaluate_representation_balance(
self,
generated_texts: List[str],
demographic_groups: List[str]
) -> Dict[str, any]:
"""
Evaluate whether generated text appropriately represents diverse groups.
Args:
generated_texts: List of generated texts
demographic_groups: List of demographic groups to check
Returns:
Representation balance analysis
"""
# Count mentions of different groups
group_mentions = defaultdict(int)
for text in generated_texts:
text_lower = text.lower()
for group in demographic_groups:
if group.lower() in text_lower:
group_mentions[group] += 1
# Compute representation metrics
total_texts = len(generated_texts)
representation_rates = {
group: count / total_texts
for group, count in group_mentions.items()
}
# Check if any groups are substantially underrepresented
if representation_rates:
max_rate = max(representation_rates.values())
min_rate = min(representation_rates.values())
representation_disparity = max_rate - min_rate
else:
representation_disparity = 0
return {
'group_mentions': dict(group_mentions),
'representation_rates': representation_rates,
'representation_disparity': representation_disparity,
'underrepresented_groups': [
group for group, rate in representation_rates.items()
if rate < 0.2 * max(representation_rates.values())
] if representation_rates else []
}
def evaluate_language_appropriateness(
self,
generated_text: str,
target_literacy_level: str = 'average',
target_language: str = 'English'
) -> Dict[str, any]:
"""
Evaluate if language is appropriate for target literacy level.
Args:
generated_text: Text to evaluate
target_literacy_level: Target health literacy level
target_language: Target language
Returns:
Language appropriateness analysis
"""
# Compute readability metrics
sentences = generated_text.split('.')
words = generated_text.split()
avg_sentence_length = len(words) / max(1, len(sentences))
# Simple vocabulary complexity estimate
complex_words = sum(
1 for word in words
if len(word) > 10 or word.lower() in self._get_medical_jargon()
)
complex_word_ratio = complex_words / max(1, len(words))
# Assess appropriateness
literacy_expectations = {
'low': {'max_sentence_length': 12, 'max_complex_ratio': 0.05},
'average': {'max_sentence_length': 18, 'max_complex_ratio': 0.15},
'high': {'max_sentence_length': 25, 'max_complex_ratio': 0.30}
}
expectations = literacy_expectations.get(
target_literacy_level,
literacy_expectations['average']
)
appropriateness = {
'target_literacy_level': target_literacy_level,
'avg_sentence_length': avg_sentence_length,
'complex_word_ratio': complex_word_ratio,
'meets_expectations': (
avg_sentence_length <= expectations['max_sentence_length'] and
complex_word_ratio <= expectations['max_complex_ratio']
),
'readability_concerns': []
}
if avg_sentence_length > expectations['max_sentence_length']:
appropriateness['readability_concerns'].append(
f"Sentences too long (avg {avg_sentence_length:.1f} words, "
f"target ≤{expectations['max_sentence_length']})"
)
if complex_word_ratio > expectations['max_complex_ratio']:
appropriateness['readability_concerns'].append(
f"Too many complex/medical terms ({complex_word_ratio:.1%}, "
f"target ≤{expectations['max_complex_ratio']:.1%})"
)
return appropriateness
def _get_medical_jargon(self) -> Set[str]:
"""Get set of medical jargon terms."""
# In production, would load comprehensive medical terminology
return {
'hypertension', 'myocardial', 'cerebrovascular', 'nephropathy',
'retinopathy', 'neuropathy', 'atherosclerosis', 'thrombosis',
'dyslipidemia', 'hyperglycemia', 'hypoglycemia', 'tachycardia',
'bradycardia', 'arrhythmia', 'fibrillation', 'ischemia'
}
def generate_comprehensive_fairness_report(
self,
test_results: Dict[str, any]
) -> Dict[str, any]:
"""
Generate comprehensive fairness evaluation report.
Args:
test_results: Results from various fairness tests
Returns:
Comprehensive fairness report
"""
report = {
'overall_fairness_score': 0.0,
'critical_issues': [],
'moderate_concerns': [],
'recommendations': [],
'detailed_findings': test_results
}
# Analyze performance parity
if 'performance_parity' in test_results:
for attribute, analysis in test_results['performance_parity'].items():
disparate_impact = analysis.get('disparate_impact_ratio', 1.0)
# 80% rule commonly used in fairness assessment
if disparate_impact < 0.8:
report['critical_issues'].append(
f"Substantial performance disparity for {attribute}: "
f"disparate impact ratio {disparate_impact:.2f}"
)
report['recommendations'].append(
f"Investigate and mitigate performance gaps for {attribute}"
)
elif disparate_impact < 0.9:
report['moderate_concerns'].append(
f"Moderate performance disparity for {attribute}"
)
# Analyze stereotypical language
if 'stereotype_detection' in test_results:
for finding in test_results['stereotype_detection']:
if finding.get('overall_risk') == 'high':
report['critical_issues'].append(
f"High risk of stereotypical language detected in generated text"
)
report['recommendations'].append(
"Review and revise model to reduce biased language patterns"
)
# Compute overall fairness score (0-1)
# Simple scoring - would be more sophisticated in production
num_critical = len(report['critical_issues'])
num_moderate = len(report['moderate_concerns'])
if num_critical > 0:
report['overall_fairness_score'] = max(0, 0.5 - (num_critical * 0.1))
elif num_moderate > 0:
report['overall_fairness_score'] = max(0.5, 0.8 - (num_moderate * 0.05))
else:
report['overall_fairness_score'] = 0.9
return report
This fairness evaluation framework implements multiple complementary approaches for assessing whether clinical language models serve diverse patient populations equitably. The performance parity analysis detects systematic differences in model quality across demographic groups. The stereotypical language detection identifies biased patterns in generated text that may reflect or perpetuate discriminatory attitudes. The representation balance analysis ensures that generated content appropriately acknowledges diverse patient populations. The language appropriateness evaluation verifies that generated text matches target health literacy levels.
Research has documented numerous examples of bias in clinical language models, including differential performance across patient demographics, generation of stereotypical language about certain patient groups, and failure to account for social determinants of health that disproportionately affect underserved populations. Comprehensive fairness evaluation as implemented here is essential for identifying these issues before deployment. However, evaluation alone is insufficient; models must be iteratively improved to address identified fairness concerns before any clinical use.
9.5 Conclusion and Key Takeaways
This chapter has developed comprehensive approaches for deploying large language models in healthcare applications while maintaining rigorous safety and fairness standards. The key insights are that language models offer transformative potential for clinical applications including documentation support, patient education, medical question answering, and clinical decision support, but their deployment requires extraordinary caution due to hallucination risks, bias amplification potential, and the high stakes of medical decision-making. Every technical choice, from domain adaptation strategies through prompt engineering approaches to evaluation frameworks, involves balancing competing considerations of capability, safety, fairness, and clinical utility.
The implementations provided enable practitioners to build production-grade clinical language model systems with comprehensive safety and fairness validation. The domain adaptation framework supports transfer learning while monitoring for bias introduction or amplification. The prompt engineering system implements best practices for eliciting accurate, safe, and equitable responses. The retrieval-augmented generation framework grounds model outputs in retrieved documents to reduce hallucination. The evaluation systems detect hallucinations, assess fairness properties, and provide transparency into model behavior across diverse patient populations.
Several critical principles emerge from this work. First, language models should augment rather than replace clinical judgment, providing information to support human decision-making rather than making autonomous clinical decisions. Second, comprehensive evaluation across multiple dimensions including accuracy, safety, fairness, and clinical appropriateness is essential before any deployment. Third, ongoing monitoring in production is necessary because model behavior can change over time and new failure modes may emerge as models encounter novel inputs. Fourth, transparency about model capabilities and limitations is essential for appropriate use by clinicians and patients.
The path forward for clinical language models requires sustained attention to safety and equity considerations. As models become more powerful, the potential for both benefit and harm increases. Technical advances in hallucination prevention, bias mitigation, and interpretability must be matched by careful attention to the sociotechnical contexts of deployment, including how clinicians interact with AI-generated content, how patients experience AI-mediated care, and how healthcare organizations govern the use of these powerful but imperfect tools. The work ahead demands not just technical sophistication but also deep understanding of clinical practice, commitment to health equity, and humility about the limitations of current systems.
Bibliography
Alsentzer, E., Murphy, J. R., Boag, W., Weng, W. H., Jin, D., Naumann, T., & McDermott, M. (2019). Publicly available clinical BERT embeddings. Proceedings of the 2nd Clinical Natural Language Processing Workshop, 72-78. https://arxiv.org/abs/1904.03323
Bender, E. M., Gebru, T., McMillan-Major, A., & Shmitchell, S. (2021). On the dangers of stochastic parrots: Can language models be too big? Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, 610-623. https://doi.org/10.1145/3442188.3445922
Bommasani, R., Hudson, D. A., Adeli, E., Altman, R., Arora, S., von Arx, S., … & Liang, P. (2021). On the opportunities and risks of foundation models. arXiv preprint arXiv:2108.07258. https://arxiv.org/abs/2108.07258
Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J. D., Dhariwal, P., … & Amodei, D. (2020). Language models are few-shot learners. Advances in Neural Information Processing Systems, 33, 1877-1901. https://proceedings.neurips.cc/paper/2020/file/1457c0d6bfcb4967418bfb8ac142f64a-Paper.pdf
Devlin, J., Chang, M. W., Lee, K., & Toutanova, K. (2019). BERT: Pre-training of deep bidirectional transformers for language understanding. Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics, 4171-4186. https://arxiv.org/abs/1810.04805
Gao, L., Biderman, S., Black, S., Golding, L., Hoppe, T., Foster, C., … & Leahy, C. (2020). The Pile: An 800GB dataset of diverse text for language modeling. arXiv preprint arXiv:2101.00027. https://arxiv.org/abs/2101.00027
Gu, Y., Tinn, R., Cheng, H., Lucas, M., Usuyama, N., Liu, X., … & Poon, H. (2021). Domain-specific language model pretraining for biomedical natural language processing. ACM Transactions on Computing for Healthcare, 3(1), 1-23. https://doi.org/10.1145/3458754
Huang, K., Altosaar, J., & Ranganath, R. (2020). ClinicalBERT: Modeling clinical notes and predicting hospital readmission. arXiv preprint arXiv:1904.05342. https://arxiv.org/abs/1904.05342
Ji, Z., Lee, N., Frieske, R., Yu, T., Su, D., Xu, Y., … & Fung, P. (2023). Survey of hallucination in natural language generation. ACM Computing Surveys, 55(12), 1-38. https://doi.org/10.1145/3571730
Jin, Q., Dhingra, B., Liu, Z., Cohen, W. W., & Lu, X. (2019). PubMedQA: A dataset for biomedical research question answering. Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing, 2567-2577. https://arxiv.org/abs/1909.06146
Kenton, Z., Everitt, T., Weidinger, L., Gabriel, I., Mikulik, V., & Irving, G. (2021). Alignment of language agents. arXiv preprint arXiv:2103.14659. https://arxiv.org/abs/2103.14659
Lee, J., Yoon, W., Kim, S., Kim, D., Kim, S., So, C. H., & Kang, J. (2020). BioBERT: a pre-trained biomedical language representation model for biomedical text mining. Bioinformatics, 36(4), 1234-1240. https://doi.org/10.1093/bioinformatics/btz682
Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., … & Kiela, D. (2020). Retrieval-augmented generation for knowledge-intensive NLP tasks. Advances in Neural Information Processing Systems, 33, 9459-9474. https://proceedings.neurips.cc/paper/2020/file/6b493230205f780e1bc26945df7481e5-Paper.pdf
Liu, Y., Ott, M., Goyal, N., Du, J., Joshi, M., Chen, D., … & Stoyanov, V. (2019). RoBERTa: A robustly optimized BERT pretraining approach. arXiv preprint arXiv:1907.11692. https://arxiv.org/abs/1907.11692
Maynez, J., Narayan, S., Bohnet, B., & McDonald, R. (2020). On faithfulness and factuality in abstractive summarization. Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, 1906-1919. https://arxiv.org/abs/2005.00661
Nori, H., King, N., McKinney, S. M., Carignan, D., & Horvitz, E. (2023). Capabilities of GPT-4 on medical challenge problems. arXiv preprint arXiv:2303.13375. https://arxiv.org/abs/2303.13375
OpenAI. (2023). GPT-4 technical report. arXiv preprint arXiv:2303.08774. https://arxiv.org/abs/2303.08774
Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C., Mishkin, P., … & Lowe, R. (2022). Training language models to follow instructions with human feedback. Advances in Neural Information Processing Systems, 35, 27730-27744. https://arxiv.org/abs/2203.02155
Peng, Y., Yan, S., & Lu, Z. (2019). Transfer learning in biomedical natural language processing: An evaluation of BERT and ELMo on ten benchmarking datasets. Proceedings of the 18th BioNLP Workshop, 58-65. https://arxiv.org/abs/1906.05474
Raffel, C., Shazeer, N., Roberts, A., Lee, K., Narang, S., Matena, M., … & Liu, P. J. (2020). Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140), 1-67. http://jmlr.org/papers/v21/20-074.html
Rasmy, L., Xiang, Y., Xie, Z., Tao, C., & Zhi, D. (2021). Med-BERT: pretrained contextualized embeddings on large-scale structured electronic health records for disease prediction. NPJ Digital Medicine, 4(1), 1-13. https://doi.org/10.1038/s41746-021-00455-y
Ruder, S. (2017). An overview of multi-task learning in deep neural networks. arXiv preprint arXiv:1706.05098. https://arxiv.org/abs/1706.05098
Singhal, K., Azizi, S., Tu, T., Mahdavi, S. S., Wei, J., Chung, H. W., … & Natarajan, V. (2022). Large language models encode clinical knowledge. arXiv preprint arXiv:2212.13138. https://arxiv.org/abs/2212.13138
Singhal, K., Tu, T., Gottweis, J., Sayres, R., Wulczyn, E., Hou, L., … & Natarajan, V. (2023). Towards expert-level medical question answering with large language models. arXiv preprint arXiv:2305.09617. https://arxiv.org/abs/2305.09617
Sun, C., Qiu, X., Xu, Y., & Huang, X. (2019). How to fine-tune BERT for text classification? Chinese Computational Linguistics, 194-206. https://arxiv.org/abs/1905.05583
Thirunavukarasu, A. J., Ting, D. S. J., Elangovan, K., Gutierrez, L., Tan, T. F., & Ting, D. S. W. (2023). Large language models in medicine. Nature Medicine, 29(8), 1930-1940. https://doi.org/10.1038/s41591-023-02448-8
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., … & Polosukhin, I. (2017). Attention is all you need. Advances in Neural Information Processing Systems, 30, 5998-6008. https://proceedings.neurips.cc/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf
Wang, A., Singh, A., Michael, J., Hill, F., Levy, O., & Bowman, S. R. (2018). GLUE: A multi-task benchmark and analysis platform for natural language understanding. Proceedings of the 2018 EMNLP Workshop BlackboxNLP, 353-355. https://arxiv.org/abs/1804.07461
Wei, J., Bosma, M., Zhao, V. Y., Guu, K., Yu, A. W., Lester, B., … & Le, Q. V. (2022). Finetuned language models are zero-shot learners. Proceedings of the International Conference on Learning Representations. https://arxiv.org/abs/2109.01652
Weidinger, L., Mellor, J., Rauh, M., Griffin, C., Uesato, J., Huang, P. S., … & Gabriel, I. (2021). Ethical and social risks of harm from language models. arXiv preprint arXiv:2112.04359. https://arxiv.org/abs/2112.04359
Wornow, M., Xu, Y., Thapa, R., Patel, B., Steinberg, E., Fleming, S., … & Shah, N. (2023). The shaky foundations of large language models and foundation models for electronic health records. NPJ Digital Medicine, 6(1), 135. https://doi.org/10.1038/s41746-023-00879-8
Zhang, Y., Chen, Q., Yang, Z., Lin, H., & Lu, Z. (2019). BioWordVec, improving biomedical word embeddings with subword information and MeSH. Scientific Data, 6(1), 1-9. https://doi.org/10.1038/s41597-019-0055-0
Zhou, C., Liu, P., Xu, P., Iyer, S., Sun, J., Mao, Y., … & Zettlemoyer, L. (2023). LIMA: Less is more for alignment. arXiv preprint arXiv:2305.11206. https://arxiv.org/abs/2305.11206