Class: Desiru::Core::Compiler

Inherits:
Object
  • Object
show all
Defined in:
lib/desiru/core/compiler.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(optimizer: nil, trace_collector: nil, config: {}) ⇒ Compiler

Returns a new instance of Compiler.



36
37
38
39
40
41
 
# File 'lib/desiru/core/compiler.rb', line 36

def initialize(optimizer: nil, trace_collector: nil, config: {})
  @optimizer = optimizer
  @trace_collector = trace_collector || Core.trace_collector
  @config = default_config.merge(config)
  @compilation_stack = []
end

Instance Attribute Details

#config ⇒ Object (readonly)

Returns the value of attribute config.



34
35
36
 
# File 'lib/desiru/core/compiler.rb', line 34

def config
  @config
end

#optimizer ⇒ Object (readonly)

Returns the value of attribute optimizer.



34
35
36
 
# File 'lib/desiru/core/compiler.rb', line 34

def optimizer
  @optimizer
end

#trace_collector ⇒ Object (readonly)

Returns the value of attribute trace_collector.



34
35
36
 
# File 'lib/desiru/core/compiler.rb', line 34

def trace_collector
  @trace_collector
end

Instance Method Details

#compile(program, training_set = []) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/desiru/core/compiler.rb', line 43

def compile(program, training_set = [])
  start_compilation(program)
  modules_traced = false

  begin
    # Clear previous traces if configured
    @trace_collector.clear if @config[:clear_traces]

    # Enable tracing for all modules
    enable_module_tracing(program)
    modules_traced = true

    # Run optimizer if provided
    if @optimizer
      if @optimizer.respond_to?(:compile)
        # MIPROv2 style optimizer
        optimized_program = @optimizer.compile(program, trainset: training_set)
      elsif @optimizer.respond_to?(:optimize)
        # Generic optimizer
        optimized_program = @optimizer.optimize(program, training_set)
      else
        raise ArgumentError, "Optimizer must implement either compile or optimize method"
      end
    else
      # Basic compilation without optimization
      optimized_program = compile_without_optimization(program, training_set)
    end

    # Collect compilation metrics
    metrics = collect_metrics(program, optimized_program, training_set)

    # Get relevant traces
    traces = @trace_collector.traces.dup

    end_compilation(
      program: optimized_program,
      metrics: metrics,
      traces: traces,
      metadata: { success: true, optimizer: @optimizer&.class&.name }
    )
  rescue StandardError => e
    end_compilation(
      program: program,
      metrics: {},
      traces: @trace_collector.respond_to?(:traces) ? @trace_collector.traces.dup : [],
      metadata: { success: false, error: e.message, error_class: e.class.name }
    )
  ensure
    disable_module_tracing(program) if @config[:restore_trace_state] && modules_traced
  end
end

#compile_module(mod, examples = []) ⇒ Object 



95
96
97
98
99
100
101
102
103
104
 
# File 'lib/desiru/core/compiler.rb', line 95

def compile_module(mod, examples = [])
  # Compile individual module with examples
  return mod if examples.empty?

  # Extract demonstrations from successful examples
  demos = examples.select { |ex| ex.is_a?(Example) }.take(@config[:max_demos])

  # Create new module instance with demos
  mod.with_demos(demos)
end