Teacher-Student Paradigm

class TeacherStudentSystem:
    """
    Asymmetric model interaction for performance enhancement

    Teacher: 8B parameter model trained for adaptive teaching
    Student: Any LLM (4B-70B+) requiring enhancement
    """

    def __init__(self, teacher_model, student_model):
        self.teacher = teacher_model  # ATLAS-8B-Thinking or ATLAS-8B-Instruct
        self.student = student_model  # GPT-4, Claude, Llama, etc.

    def enhance_response(self, prompt: str) -> EnhancedResponse:
        # Step 1: Diagnostic probe
        student_capability = self.teacher.assess_capability(prompt, self.student)

        # Step 2: Adaptive guidance
        teaching_strategy = self.teacher.generate_guidance(
            prompt=prompt,
            capability_level=student_capability
        )

        # Step 3: Enhanced generation
        enhanced_output = self.student.generate(
            prompt=prompt,
            guidance=teaching_strategy
        )

        return EnhancedResponse(
            baseline=self.student.generate(prompt),
            enhanced=enhanced_output,
            improvement=self.measure_improvement(baseline, enhanced_output)
        )

def assess_capability(self, task: str, student: Model) -> CapabilityLevel:
    """
    Diagnostic assessment of student's task-specific capability

    Returns:
        CapabilityLevel: Enum of WEAK, MODERATE, STRONG
    """
    # Generate diagnostic probe (≤50 tokens)
    probe = self.generate_probe(task)

    # Collect student response
    response = student.generate(probe, max_tokens=50)

    # Analyze response quality
    indicators = {
        'reasoning_depth': self.analyze_reasoning(response),
        'domain_knowledge': self.check_domain_terms(response),
        'problem_structure': self.evaluate_structure(response),
        'confidence': self.estimate_confidence(response)
    }

    # Classify capability level
    if indicators['reasoning_depth'] < 0.3:
        return CapabilityLevel.WEAK
    elif indicators['reasoning_depth'] < 0.7:
        return CapabilityLevel.MODERATE
    else:
        return CapabilityLevel.STRONG

def generate_guidance(self, task: str, capability: CapabilityLevel) -> str:
    """
    Generate capability-appropriate teaching guidance
    """
    if capability == CapabilityLevel.WEAK:
        return self.comprehensive_scaffolding(task)
    elif capability == CapabilityLevel.MODERATE:
        return self.targeted_hints(task)
    else:  # STRONG
        return self.minimal_intervention(task)

def comprehensive_scaffolding(self, task: str) -> str:
    """Full problem decomposition for weak students"""
    return f"""
    Break this problem into steps:
    1. Identify the core requirement: {self.extract_requirement(task)}
    2. Gather necessary information: {self.list_prerequisites(task)}
    3. Apply systematic approach: {self.generate_methodology(task)}
    4. Verify solution: {self.create_verification(task)}
    """

def targeted_hints(self, task: str) -> str:
    """Key insights for moderate students"""
    return f"""
    Key insight: {self.identify_critical_insight(task)}
    Common pitfall: {self.highlight_common_error(task)}
    """

def minimal_intervention(self, task: str) -> str:
    """Edge case awareness for strong students"""
    return f"""
    Consider edge case: {self.identify_edge_case(task)}
    """

# Using optimize_teaching.py for enhancement
from trainers.prompt_adapter import ATLASGEPAAdapter

adapter = ATLASGEPAAdapter(
    teacher_model=teacher_generate_fn,
    student_model=student_generate_fn,
    all_prompts=optimized_prompts
)
result = adapter.evaluate([{"question": user_query}])
enhanced_output = result.outputs[0]["student_with_teaching"]

# Efficient processing of multiple queries
queries = [{"question": q} for q in query_list]
results = adapter.evaluate(
    queries,
    capture_traces=True  # For analysis
)
enhanced_outputs = [r["student_with_teaching"] for r in results.outputs]

# Real-time enhancement for chat applications
class StreamingATLAS:
    def __init__(self, teacher, student):
        self.teacher = teacher
        self.student = student
        self.guidance_cache = {}

    async def stream_enhanced(self, prompt: str):
        # Get guidance once
        if prompt not in self.guidance_cache:
            self.guidance_cache[prompt] = await self.teacher.get_guidance(prompt)

        # Stream enhanced response
        async for token in self.student.stream(prompt, self.guidance_cache[prompt]):
            yield token