Module: Legion::Extensions::Agentic::Attention::SignalDetection::Runners::SignalDetection

Includes:
Helpers::Lex
Included in:
Client
Defined in:
lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb

Instance Method Summary collapse

Instance Method Details

#adjust_detector_bias(detector_id:, amount:) ⇒ Object 



45
46
47
48
49
50
51
52
53
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 45

def adjust_detector_bias(detector_id:, amount:, **)
  result = detection_engine.adjust_bias(detector_id: detector_id, amount: amount)
  log.debug("[signal_detection] bias adjusted: id=#{detector_id[0..7]} " \
            "criterion=#{result[:criterion].round(3)} label=#{result[:bias_label]}")
  result
rescue KeyError => e
  log.warn("[signal_detection] adjust_bias failed: #{e.message}")
  { adjusted: false, reason: :not_found }
end

#best_detectors(limit: 5) ⇒ Object 



55
56
57
58
59
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 55

def best_detectors(limit: 5, **)
  detectors = detection_engine.best_detectors(limit: limit)
  log.debug("[signal_detection] best detectors: count=#{detectors.size} limit=#{limit}")
  { detectors: detectors, count: detectors.size }
end

#compute_detector_sensitivity(detector_id:) ⇒ Object 



35
36
37
38
39
40
41
42
43
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 35

def compute_detector_sensitivity(detector_id:, **)
  result = detection_engine.compute_sensitivity(detector_id: detector_id)
  log.debug("[signal_detection] sensitivity: id=#{detector_id[0..7]} " \
            "d_prime=#{result[:d_prime].round(3)} label=#{result[:sensitivity_label]}")
  result
rescue KeyError => e
  log.warn("[signal_detection] compute_sensitivity failed: #{e.message}")
  { found: false, reason: :not_found }
end

#create_detector(domain:) ⇒ Object 



13
14
15
16
17
18
19
20
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 13

def create_detector(domain:, **)
  detector = detection_engine.create_detector(domain: domain)
  log.info("[signal_detection] created detector id=#{detector.id[0..7]} domain=#{domain}")
  { created: true, detector_id: detector.id, domain: domain }
rescue ArgumentError => e
  log.warn("[signal_detection] create_detector failed: #{e.message}")
  { created: false, reason: e.message }
end

#detector_roc_point(detector_id:) ⇒ Object 



79
80
81
82
83
84
85
86
87
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 79

def detector_roc_point(detector_id:, **)
  result = detection_engine.roc_point(detector_id: detector_id)
  log.debug("[signal_detection] roc point: id=#{detector_id[0..7]} " \
            "hr=#{result[:hit_rate].round(3)} far=#{result[:false_alarm_rate].round(3)}")
  result
rescue KeyError => e
  log.warn("[signal_detection] roc_point failed: #{e.message}")
  { found: false, reason: :not_found }
end

#domain_detectors(domain:) ⇒ Object 



61
62
63
64
65
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 61

def domain_detectors(domain:, **)
  detectors = detection_engine.by_domain(domain: domain)
  log.debug("[signal_detection] domain detectors: domain=#{domain} count=#{detectors.size}")
  { detectors: detectors, count: detectors.size, domain: domain }
end

#optimal_detector_criterion(detector_id:, signal_probability: 0.5) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 67

def optimal_detector_criterion(detector_id:, signal_probability: 0.5, **)
  result = detection_engine.optimal_criterion(
    detector_id:        detector_id,
    signal_probability: signal_probability
  )
  log.debug("[signal_detection] optimal criterion: id=#{detector_id[0..7]} optimal=#{result[:optimal_criterion].round(3)}")
  result
rescue KeyError => e
  log.warn("[signal_detection] optimal_criterion failed: #{e.message}")
  { found: false, reason: :not_found }
end

#record_detection_trial(detector_id:, signal_present:, responded_present:) ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 22

def record_detection_trial(detector_id:, signal_present:, responded_present:, **)
  result = detection_engine.record_trial(
    detector_id:       detector_id,
    signal_present:    signal_present,
    responded_present: responded_present
  )
  log.debug("[signal_detection] trial: id=#{detector_id[0..7]} outcome=#{result[:outcome]} count=#{result[:trial_count]}")
  result
rescue KeyError => e
  log.warn("[signal_detection] record_trial failed: #{e.message}")
  { recorded: false, reason: :not_found }
end

#signal_detection_stats ⇒ Object 



95
96
97
98
99
100
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 95

def signal_detection_stats(**)
  {
    total_detectors: detection_engine.count,
    top_detectors:   detection_engine.best_detectors(limit: 3)
  }
end

#update_signal_detection ⇒ Object 



89
90
91
92
93
 
# File 'lib/legion/extensions/agentic/attention/signal_detection/runners/signal_detection.rb', line 89

def update_signal_detection(**)
  decayed = detection_engine.decay_all
  log.debug("[signal_detection] decay cycle: detectors_updated=#{decayed}")
  { decayed: decayed }
end