wisent 0.5.12__py3-none-any.whl → 0.5.13__py3-none-any.whl

wisent/core/parser_arguments/optimize_steering_parser.py

@@ -0,0 +1,147 @@
+"""Parser setup for the 'optimize-steering' command."""
+
+
+def setup_steering_optimizer_parser(parser):
+    """Set up the steering-optimizer subcommand parser."""
+    # Create subparsers for different steering optimization types
+    steering_subparsers = parser.add_subparsers(dest="steering_action", help="Steering optimization actions")
+
+    # Comprehensive optimization subcommand
+    comprehensive_parser = steering_subparsers.add_parser(
+        "comprehensive", help="Run comprehensive steering optimization"
+    )
+    comprehensive_parser.add_argument("model", type=str, help="Model name or path")
+    comprehensive_parser.add_argument(
+        "--tasks",
+        type=str,
+        nargs="+",
+        default=None,
+        help="Tasks to optimize (defaults to classification-optimized tasks)",
+    )
+    comprehensive_parser.add_argument(
+        "--methods",
+        type=str,
+        nargs="+",
+        choices=["CAA", "HPR", "DAC", "BiPO", "KSteering"],
+        default=["CAA", "HPR"],
+        help="Steering methods to test",
+    )
+    comprehensive_parser.add_argument("--limit", type=int, default=100, help="Sample limit per task (default: 100)")
+    comprehensive_parser.add_argument(
+        "--max-time-per-task", type=float, default=20.0, help="Time limit per task in minutes (default: 20.0)"
+    )
+    comprehensive_parser.add_argument("--no-save", action="store_true", help="Don't save results to model config")
+    comprehensive_parser.add_argument("--device", type=str, default=None, help="Device to run on")
+    comprehensive_parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
+
+    # Method comparison subcommand
+    method_parser = steering_subparsers.add_parser(
+        "compare-methods", help="Compare different steering methods for a task"
+    )
+    method_parser.add_argument("model", type=str, help="Model name or path")
+    method_parser.add_argument(
+        "--task", type=str, default="truthfulqa_mc1", help="Task to optimize steering for (default: truthfulqa_mc1)"
+    )
+    method_parser.add_argument(
+        "--methods",
+        type=str,
+        nargs="+",
+        choices=["CAA", "HPR", "DAC", "BiPO", "KSteering"],
+        default=["CAA", "HPR"],
+        help="Steering methods to compare",
+    )
+    method_parser.add_argument("--limit", type=int, default=100, help="Maximum samples for testing (default: 100)")
+    method_parser.add_argument(
+        "--max-time", type=float, default=30.0, help="Maximum optimization time in minutes (default: 30.0)"
+    )
+    method_parser.add_argument("--device", type=str, default=None, help="Device to run on")
+    method_parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
+
+    # Layer optimization subcommand
+    layer_parser = steering_subparsers.add_parser("optimize-layer", help="Find optimal steering layer for a method")
+    layer_parser.add_argument("model", type=str, help="Model name or path")
+    layer_parser.add_argument(
+        "--task", type=str, default="truthfulqa_mc1", help="Task to optimize for (default: truthfulqa_mc1)"
+    )
+    layer_parser.add_argument(
+        "--method",
+        type=str,
+        default="CAA",
+        choices=["CAA", "HPR", "DAC", "BiPO", "KSteering"],
+        help="Steering method to use (default: CAA)",
+    )
+    layer_parser.add_argument("--layer-range", type=str, default=None, help="Layer range to search (e.g., '10-20')")
+    layer_parser.add_argument(
+        "--strength", type=float, default=1.0, help="Fixed steering strength during layer search (default: 1.0)"
+    )
+    layer_parser.add_argument("--limit", type=int, default=100, help="Maximum samples for testing (default: 100)")
+    layer_parser.add_argument("--device", type=str, default=None, help="Device to run on")
+    layer_parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
+
+    # Strength optimization subcommand
+    strength_parser = steering_subparsers.add_parser("optimize-strength", help="Find optimal steering strength")
+    strength_parser.add_argument("model", type=str, help="Model name or path")
+    strength_parser.add_argument(
+        "--task", type=str, default="truthfulqa_mc1", help="Task to optimize for (default: truthfulqa_mc1)"
+    )
+    strength_parser.add_argument(
+        "--method",
+        type=str,
+        default="CAA",
+        choices=["CAA", "HPR", "DAC", "BiPO", "KSteering"],
+        help="Steering method to use (default: CAA)",
+    )
+    strength_parser.add_argument(
+        "--layer", type=int, default=None, help="Steering layer to use (defaults to classification layer)"
+    )
+    strength_parser.add_argument(
+        "--strength-range",
+        type=float,
+        nargs=2,
+        default=[0.1, 2.0],
+        help="Min and max strength to test (default: 0.1 2.0)",
+    )
+    strength_parser.add_argument(
+        "--strength-steps", type=int, default=10, help="Number of strength values to test (default: 10)"
+    )
+    strength_parser.add_argument("--limit", type=int, default=100, help="Maximum samples for testing (default: 100)")
+    strength_parser.add_argument("--device", type=str, default=None, help="Device to run on")
+    strength_parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
+
+    # Auto optimization subcommand
+    auto_parser = steering_subparsers.add_parser(
+        "auto", help="Automatically optimize steering based on classification config"
+    )
+    auto_parser.add_argument("model", type=str, help="Model name or path")
+    auto_parser.add_argument(
+        "--task",
+        type=str,
+        default=None,
+        help="Specific task to optimize (defaults to all classification-optimized tasks)",
+    )
+    auto_parser.add_argument(
+        "--methods",
+        type=str,
+        nargs="+",
+        choices=["CAA", "HPR", "DAC", "BiPO", "KSteering"],
+        default=["CAA", "HPR"],
+        help="Steering methods to test (default: CAA, HPR)",
+    )
+    auto_parser.add_argument("--limit", type=int, default=100, help="Maximum samples for testing (default: 100)")
+    auto_parser.add_argument("--max-time", type=float, default=60.0, help="Maximum time in minutes (default: 60)")
+    auto_parser.add_argument(
+        "--strength-range",
+        type=float,
+        nargs="+",
+        default=[0.5, 1.0, 1.5, 2.0],
+        help="Steering strengths to test (default: 0.5 1.0 1.5 2.0)",
+    )
+    auto_parser.add_argument(
+        "--layer-range",
+        type=str,
+        default=None,
+        help="Explicit layer range to search (e.g., '0-5' or '0,2,4'). If not specified, uses classification layer or defaults to 0-5",
+    )
+    auto_parser.add_argument("--device", type=str, default=None, help="Device to run on")
+    auto_parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
+

wisent/core/parser_arguments/synthetic_parser.py

@@ -0,0 +1,93 @@
+"""Parser setup for the 'synthetic' command."""
+
+
+def setup_synthetic_parser(parser):
+    """Set up the synthetic subcommand parser."""
+    # Either generate new pairs or load existing ones
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "--trait", type=str, help="Natural language description of the desired trait or behavior (generates new pairs)"
+    )
+    group.add_argument("--pairs-file", type=str, help="Path to existing JSON file with contrastive pairs")
+
+    # Generation parameters (only used if --trait is specified)
+    parser.add_argument(
+        "--num-pairs",
+        type=int,
+        default=30,
+        help="Number of contrastive pairs to generate (default: 30, only used with --trait)",
+    )
+    parser.add_argument(
+        "--save-pairs",
+        type=str,
+        default=None,
+        help="Save generated pairs to this file (optional, only used with --trait)",
+    )
+
+    # Model and device
+    parser.add_argument("--model", type=str, default="meta-llama/Llama-3.1-8B-Instruct", help="Model name or path")
+    parser.add_argument("--device", type=str, default=None, help="Device to run on")
+
+    # Training/evaluation parameters
+    parser.add_argument("--layer", type=str, default="15", help="Layer(s) to extract activations from")
+    parser.add_argument(
+        "--steering-method",
+        type=str,
+        default="CAA",
+        choices=["CAA", "HPR", "DAC", "BiPO", "KSteering"],
+        help="Steering method to use",
+    )
+    parser.add_argument("--steering-strength", type=float, default=1.0, help="Strength of steering vector application")
+    parser.add_argument(
+        "--test-questions", type=int, default=5, help="Number of test questions to generate for evaluation"
+    )
+
+    # Output
+    parser.add_argument("--output", type=str, default="./results", help="Output directory for results")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
+
+    # K-Steering specific parameters
+    parser.add_argument(
+        "--ksteering-target-labels", type=str, default="0", help="Comma-separated target label indices for K-steering"
+    )
+    parser.add_argument(
+        "--ksteering-avoid-labels", type=str, default="", help="Comma-separated avoid label indices for K-steering"
+    )
+    parser.add_argument("--ksteering-alpha", type=float, default=50.0, help="Alpha parameter for K-steering")
+
+    # Nonsense detection options
+    parser.add_argument(
+        "--enable-nonsense-detection",
+        action="store_true",
+        help="Enable nonsense detection to stop lobotomized responses",
+    )
+    parser.add_argument(
+        "--max-word-length",
+        type=int,
+        default=20,
+        help="Maximum reasonable word length for nonsense detection (default: 20)",
+    )
+    parser.add_argument(
+        "--repetition-threshold",
+        type=float,
+        default=0.7,
+        help="Threshold for repetitive content detection (0-1, default: 0.7)",
+    )
+    parser.add_argument(
+        "--gibberish-threshold",
+        type=float,
+        default=0.3,
+        help="Threshold for gibberish word detection (0-1, default: 0.3)",
+    )
+    parser.add_argument(
+        "--disable-dictionary-check",
+        action="store_true",
+        help="Disable dictionary-based word validation (faster but less accurate)",
+    )
+    parser.add_argument(
+        "--nonsense-action",
+        type=str,
+        default="regenerate",
+        choices=["regenerate", "stop", "flag"],
+        help="Action when nonsense is detected: regenerate, stop generation, or flag for review",
+    )