updates

Author: shreymodi1

eval_protocol/training/gepa_trainer.py

@@ -153,6 +153,22 @@ def __init__(
                 module_factory=module_factory,
             )
 
+        # Debug: Verify program structure
+        print("\n🔍 DEBUG [GEPATrainer] PROGRAM STRUCTURE:")
+        print(f"   Program type: {type(self.program).__name__}")
+        print(f"   Has .predict: {hasattr(self.program, 'predict')}")
+        if hasattr(self.program, "predict"):
+            print(f"   predict type: {type(self.program.predict).__name__}")
+            print(f"   predict.signature: {self.program.predict.signature}")
+            print(
+                f"   predict.signature.instructions (first 300 chars): {(self.program.predict.signature.instructions or '')[:300]}..."
+            )
+        print(f"   Named predictors: {[name for name, _ in self.program.named_predictors()]}")
+        for name, pred in self.program.named_predictors():
+            print(
+                f"     - '{name}': {pred.signature.instructions[:100] if pred.signature.instructions else 'None'}..."
+            )
+
         # Convert EP rows to DSPy Examples
         self.train_set: List[Example] = evaluation_rows_to_dspy_examples(train_rows, input_field, output_field)
         self.val_set: List[Example] = evaluation_rows_to_dspy_examples(val_rows, input_field, output_field)
@@ -348,6 +364,20 @@ def train(
                 marker = " 🏆" if i == results.best_idx else ""
                 print(f"   Candidate {i}: {score:.3f}{marker}")
 
+            # Show all candidate instructions
+            print("\n📝 ALL CANDIDATE INSTRUCTIONS:")
+            if hasattr(results, "candidates") and results.candidates:
+                for i, cand_prog in enumerate(results.candidates):
+                    marker = " 🏆 BEST" if i == results.best_idx else ""
+                    print(f"\n   --- Candidate {i}{marker} (score: {results.val_aggregate_scores[i]:.3f}) ---")
+                    # Get instructions from the candidate program
+                    for name, pred in cand_prog.named_predictors():
+                        instr = pred.signature.instructions or ""
+                        print(f"   Predictor '{name}' instructions (first 500 chars):")
+                        print(f"   {instr[:500]}...")
+                        if len(instr) > 500:
+                            print(f"   ... ({len(instr)} total chars)")
+
         optimized_instructions = self.get_optimized_system_prompt(optimized_program)
         print("\n🎯 OPTIMIZED SYSTEM PROMPT:")
         print("-" * 60)

eval_protocol/training/gepa_utils.py

@@ -110,6 +110,14 @@ def gold_and_pred_to_row(gold: Example, pred: Prediction) -> EvaluationRow:
 
     content = pred.get("answer", "")
 
+    # Debug: print conversion details (only first few)
+    import os
+
+    if os.environ.get("EP_DEBUG_GEPA"):
+        print("\n  [gold_and_pred_to_row] Converting:")
+        print(f"    gold.answer type: {type(gt)}, value preview: {str(gt)[:100]}...")
+        print(f"    pred.answer type: {type(content)}, value preview: {str(content)[:100]}...")
+
     return EvaluationRow(
         messages=[
             Message(role="assistant", content=str(content))
@@ -325,6 +333,14 @@ def create_single_turn_program(
             module_factory=lambda sig: MyCustomModule(sig)
         )
     """
+    print("\n" + "⚙️" * 20)
+    print("DEBUG [create_single_turn_program] CREATING DSPY MODULE")
+    print("⚙️" * 20)
+    print(f"  input_field: '{input_field}'")
+    print(f"  output_field: '{output_field}'")
+    print(f"  module_type: {module_type}")
+    print(f"  system_prompt (first 200 chars): {(system_prompt or '')[:200]}...")
+
     # Create the signature
     sig = create_signature(
         input_field=input_field,
@@ -334,8 +350,12 @@ def create_single_turn_program(
         output_desc=output_desc,
     )
 
+    print(f"\n  Created signature: {sig}")
+    print(f"  Signature instructions (first 200 chars): {(sig.instructions or '')[:200]}...")
+
     # Use custom factory if provided
     if module_factory is not None:
+        print("  Using custom module factory")
         return module_factory(sig)
 
     # Convert string to enum if needed
@@ -344,14 +364,22 @@ def create_single_turn_program(
 
     # Create the appropriate module type
     if module_type == DSPyModuleType.PREDICT:
-        return dspy.Predict(sig)
+        program = dspy.Predict(sig)
     elif module_type == DSPyModuleType.CHAIN_OF_THOUGHT:
-        return dspy.ChainOfThought(sig)
+        program = dspy.ChainOfThought(sig)
     elif module_type == DSPyModuleType.PROGRAM_OF_THOUGHT:
-        return dspy.ProgramOfThought(sig)
+        program = dspy.ProgramOfThought(sig)
     else:
         raise ValueError(f"Unknown module type: {module_type}")
 
+    print(f"\n  Created module: {type(program).__name__}")
+    print(f"  Named predictors: {[name for name, _ in program.named_predictors()]}")
+    for name, pred in program.named_predictors():
+        print(f"    '{name}' signature.instructions (first 200 chars): {(pred.signature.instructions or '')[:200]}...")
+    print("⚙️" * 20 + "\n")
+
+    return program
+
 
 def configure_dspy_lm(ep_params: EPParameters) -> None:
     """