Module: Legion::Extensions::Agentic::Learning::MetaLearning::Runners::MetaLearning

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

Instance Method Summary collapse

Instance Method Details

#apply_transfer_bonus(source_domain_id:, target_domain_id:) ⇒ Object 



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

def apply_transfer_bonus(source_domain_id:, target_domain_id:, **)
  result = engine.apply_transfer(source_domain_id: source_domain_id, target_domain_id: target_domain_id)
  log.info "[meta_learning] transfer applied=#{result[:applied]}"
  result
end

#check_transfer_learning(source_domain_id:, target_domain_id:) ⇒ Object 



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

def check_transfer_learning(source_domain_id:, target_domain_id:, **)
  result = engine.transfer_check(source_domain_id: source_domain_id, target_domain_id: target_domain_id)
  log.debug "[meta_learning] transfer check eligible=#{result[:eligible]}"
  result
end

#create_learning_domain(name:, learning_rate: Helpers::Constants::DEFAULT_LEARNING_RATE, related_domains: []) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
 
# File 'lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb', line 13

def create_learning_domain(name:, learning_rate: Helpers::Constants::DEFAULT_LEARNING_RATE,
                           related_domains: [], **)
  result = engine.create_domain(name: name, learning_rate: learning_rate, related_domains: related_domains)
  if result.is_a?(Hash) && result[:error]
    log.warn "[meta_learning] create_domain failed: #{result[:error]}"
    return result
  end

  log.debug "[meta_learning] domain created: #{result.name} id=#{result.id[0..7]}"
  result.to_h
end

#learning_curve_report(domain_id:) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb', line 79

def learning_curve_report(domain_id:, **)
  result = engine.learning_curve(domain_id: domain_id)
  if result.is_a?(Hash) && result[:error]
    log.warn "[meta_learning] learning_curve failed: #{result[:error]}"
    return result
  end

  log.debug "[meta_learning] learning curve domain=#{result[:domain]} " \
            "episodes=#{result[:curve].size}"
  result
end

#learning_domain_ranking(limit: 10) ⇒ Object 



67
68
69
70
71
 
# File 'lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb', line 67

def learning_domain_ranking(limit: 10, **)
  ranking = engine.domain_ranking(limit: limit)
  log.debug "[meta_learning] domain ranking returned #{ranking.size} domains"
  { ranking: ranking, count: ranking.size }
end

#learning_strategy_ranking(limit: 10) ⇒ Object 



73
74
75
76
77
 
# File 'lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb', line 73

def learning_strategy_ranking(limit: 10, **)
  ranking = engine.strategy_ranking(limit: limit)
  log.debug "[meta_learning] strategy ranking returned #{ranking.size} strategies"
  { ranking: ranking, count: ranking.size }
end

#meta_learning_stats ⇒ Object 



100
101
102
103
104
105
 
# File 'lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb', line 100

def meta_learning_stats(**)
  stats = engine.to_h
  log.debug "[meta_learning] stats domains=#{stats[:domain_count]} " \
            "strategies=#{stats[:strategy_count]} efficiency=#{stats[:overall_efficiency]}"
  stats
end

#recommend_learning_strategy(domain_id:) ⇒ Object 



48
49
50
51
52
53
 
# File 'lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb', line 48

def recommend_learning_strategy(domain_id:, **)
  result = engine.recommend_strategy(domain_id: domain_id)
  log.debug "[meta_learning] strategy recommendation domain=#{domain_id[0..7]} " \
            "recommendation=#{result[:recommendation]}"
  result
end

#record_learning_episode(domain_id:, success:, strategy_id: nil) ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb', line 36

def record_learning_episode(domain_id:, success:, strategy_id: nil, **)
  result = engine.record_episode(domain_id: domain_id, strategy_id: strategy_id, success: success)
  if result.is_a?(Hash) && result[:error]
    log.warn "[meta_learning] record_episode failed: #{result[:error]}"
    return result
  end

  log.debug "[meta_learning] episode recorded domain=#{result[:domain_name]} " \
            "success=#{success} proficiency=#{result[:proficiency].round(4)}"
  result
end

#register_learning_strategy(name:, strategy_type:) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
 
# File 'lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb', line 25

def register_learning_strategy(name:, strategy_type:, **)
  result = engine.create_strategy(name: name, strategy_type: strategy_type)
  if result.is_a?(Hash) && result[:error]
    log.warn "[meta_learning] create_strategy failed: #{result[:error]}"
    return result
  end

  log.debug "[meta_learning] strategy registered: #{result.name} type=#{result.strategy_type}"
  result.to_h
end

#update_meta_learning ⇒ Object 



91
92
93
94
95
96
97
98
 
# File 'lib/legion/extensions/agentic/learning/meta_learning/runners/meta_learning.rb', line 91

def update_meta_learning(**)
  adapt_result = engine.adapt_rates
  prune_result = engine.prune_stale_domains
  stats        = engine.to_h
  log.info "[meta_learning] update: adapted=#{adapt_result[:count]} " \
           "pruned=#{prune_result[:pruned]} domains=#{stats[:domain_count]}"
  { adapt: adapt_result, prune: prune_result, stats: stats }
end