desiru 0.1.0 → 0.2.0

data/lib/desiru/modules/react.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require_relative '../module'
+require_relative 'chain_of_thought'
+
+module Desiru
+  module Modules
+    # ReAct (Reasoning and Acting) module for tool-using AI agents
+    # This module allows the language model to iteratively reason about a task
+    # and use tools to gather information before producing a final answer
+    class ReAct < Desiru::Module
+      attr_reader :max_iterations, :tools, :react_module, :extract_module
+
+      def initialize(signature, tools: [], max_iterations: 5, model: nil)
+        super(signature, model: model)
+        @tools = normalize_tools(tools)
+        @max_iterations = max_iterations
+
+        # Build the ReAct signature for reasoning and tool selection
+        react_signature = build_react_signature
+        @react_module = ChainOfThought.new(react_signature, model: @model)
+
+        # Build extraction signature for final output
+        extract_signature = build_extract_signature
+        @extract_module = ChainOfThought.new(extract_signature, model: @model)
+      end
+
+      def forward(inputs)
+        trajectory = []
+
+        max_iterations.times do |_iteration|
+          # Get the next action from the model
+          react_inputs = prepare_react_inputs(inputs, trajectory)
+          react_output = react_module.call(react_inputs)
+
+          # Extract the tool name and arguments
+          tool_name = react_output[:next_tool_name]
+          tool_args = parse_tool_args(react_output[:next_tool_args])
+
+          # Add reasoning to trajectory
+          trajectory << {
+            thought: react_output[:next_thought],
+            tool: tool_name,
+            args: tool_args
+          }
+
+          # Check if we're done
+          break if tool_name == "finish"
+
+          # Execute the tool
+          begin
+            tool_result = execute_tool(tool_name, tool_args)
+            trajectory.last[:observation] = tool_result
+          rescue StandardError => e
+            trajectory.last[:observation] = "Error: #{e.message}"
+          end
+        end
+
+        # Extract final outputs from trajectory
+        extract_inputs = prepare_extract_inputs(inputs, trajectory)
+        extract_module.call(extract_inputs)
+      end
+
+      private
+
+      def normalize_tools(tools)
+        # Convert tools to a consistent format
+        normalized = {}
+
+        tools.each do |tool|
+          case tool
+          when Hash
+            # Assume hash has name and function keys
+            normalized[tool[:name] || tool["name"]] = tool[:function] || tool["function"]
+          when Array
+            # Assume array of [name, function] pairs
+            name, function = tool
+            normalized[name] = function
+          else
+            # Assume it's a callable with a name method
+            if tool.respond_to?(:name) && tool.respond_to?(:call)
+              normalized[tool.name] = tool
+            elsif tool.is_a?(Method) || tool.is_a?(Proc)
+              # Use the method/proc name or generate one
+              name = tool.respond_to?(:name) ? tool.name.to_s : "tool_#{normalized.size}"
+              normalized[name] = tool
+            end
+          end
+        end
+
+        # Always include the finish tool
+        normalized["finish"] = -> { "Task completed" }
+
+        normalized
+      end
+
+      def build_react_signature
+        # Build signature for reasoning and tool selection
+        input_fields = signature.input_fields.keys.join(", ")
+
+        # Create the ReAct signature
+        react_sig = "#{input_fields}, trajectory -> next_thought, next_tool_name, next_tool_args"
+
+        # Add instructions
+        instructions = <<~INST
+          You are an AI agent that can use tools to accomplish tasks.
+
+          Available tools:
+          #{format_tool_descriptions}
+
+          Based on the input and trajectory so far, reason about what to do next.
+          Then select a tool to use and provide the arguments for that tool.
+
+          When you have gathered enough information to answer the question,
+          use the "finish" tool to complete the task.
+        INST
+
+        Signature.new(react_sig, descriptions: { 'next_thought' => instructions })
+      end
+
+      def build_extract_signature
+        # Build signature for extracting final outputs
+        input_fields = signature.input_fields.keys.join(", ")
+        output_fields = signature.output_fields.keys.join(", ")
+
+        extract_sig = "#{input_fields}, trajectory -> #{output_fields}"
+
+        instructions = <<~INST
+          Based on the trajectory of thoughts and tool observations,
+          extract the final #{output_fields} to answer the original question.
+        INST
+
+        Signature.new(extract_sig, descriptions: { output_fields => instructions })
+      end
+
+      def format_tool_descriptions
+        tools.map do |name, function|
+          if name == "finish"
+            "- finish: Mark the task as complete when you have enough information"
+          else
+            # Try to extract description from function
+            desc = if function.respond_to?(:description)
+                     function.description
+                   elsif function.respond_to?(:to_s)
+                     function.to_s
+                   else
+                     "Tool: #{name}"
+                   end
+            "- #{name}: #{desc}"
+          end
+        end.join("\n")
+      end
+
+      def prepare_react_inputs(inputs, trajectory)
+        inputs.merge(
+          trajectory: format_trajectory(trajectory)
+        )
+      end
+
+      def prepare_extract_inputs(inputs, trajectory)
+        inputs.merge(
+          trajectory: format_trajectory(trajectory)
+        )
+      end
+
+      def format_trajectory(trajectory)
+        return "No actions taken yet." if trajectory.empty?
+
+        trajectory.map.with_index do |step, i|
+          parts = ["Step #{i + 1}:"]
+          parts << "Thought: #{step[:thought]}" if step[:thought]
+          parts << "Tool: #{step[:tool]}" if step[:tool]
+          parts << "Args: #{step[:args]}" if step[:args] && !step[:args].empty?
+          parts << "Observation: #{step[:observation]}" if step[:observation]
+          parts.join("\n")
+        end.join("\n\n")
+      end
+
+      def parse_tool_args(args_string)
+        # Parse tool arguments from string format
+        return {} if args_string.nil? || args_string.strip.empty?
+
+        # Try to parse as JSON first
+        begin
+          require 'json'
+          JSON.parse(args_string, symbolize_names: true)
+        rescue JSON::ParserError
+          # Fallback: parse simple key:value pairs
+          parse_simple_args(args_string)
+        end
+      end
+
+      def parse_simple_args(args_string)
+        # Parse simple key:value format
+        args = {}
+
+        # Match patterns like key:value or key=value
+        args_string.scan(/(\w+)[:=]\s*([^,]+)/).each do |key, value|
+          # Clean up the value
+          value = value.strip.gsub(/^["']|["']$/, '') # Remove quotes
+
+          # Try to convert to appropriate type
+          args[key.to_sym] = case value.downcase
+                             when 'true' then true
+                             when 'false' then false
+                             when /^\d+$/ then value.to_i
+                             when /^\d+\.\d+$/ then value.to_f
+                             else value
+                             end
+        end
+
+        args
+      end
+
+      def execute_tool(tool_name, args)
+        tool = tools[tool_name]
+
+        raise "Unknown tool: #{tool_name}" unless tool
+
+        # Call the tool with arguments
+        if tool.arity.zero?
+          tool.call
+        elsif tool.arity == 1 && args.is_a?(Hash)
+          # Pass args as keyword arguments if possible
+          if tool.respond_to?(:parameters)
+            param_types = tool.parameters.map(&:first)
+            if param_types.include?(:keyreq) || param_types.include?(:key)
+              tool.call(**args)
+            else
+              tool.call(args)
+            end
+          else
+            tool.call(args)
+          end
+        else
+          # Pass args as positional arguments
+          tool.call(*args.values)
+        end
+      end
+
+      # Support for truncating trajectory if it gets too long
+      def truncate_trajectory(trajectory, max_length: 3000)
+        formatted = format_trajectory(trajectory)
+
+        return trajectory if formatted.length <= max_length
+
+        # Remove oldest steps until we're under the limit
+        truncated = trajectory.dup
+
+        # Keep removing the oldest steps until we're under the limit
+        while truncated.length > 1
+          truncated_formatted = format_trajectory(truncated)
+          break if truncated_formatted.length <= max_length
+
+          truncated.shift
+        end
+
+        # If even a single step is too long, truncate its content
+        if truncated.length == 1 && format_trajectory(truncated).length > max_length
+          step = truncated[0]
+          # Truncate the observation if it exists and is long
+          if step[:observation] && step[:observation].length > 100
+            step[:observation] = "#{step[:observation][0..100]}... (truncated)"
+          end
+          # Truncate thought if it's very long
+          step[:thought] = "#{step[:thought][0..100]}... (truncated)" if step[:thought] && step[:thought].length > 100
+        end
+
+        truncated
+      end
+    end
+  end
+end

data/lib/desiru/modules/retrieve.rb

@@ -21,6 +21,7 @@ module Desiru
       def forward(**inputs)
         query = inputs[:query]
         # Handle k parameter - it might come as nil if optional
+        # Note: 'k' is the standard parameter name in information retrieval
         k = inputs.fetch(:k, 5)
         k = 5 if k.nil? # Ensure we have a value even if nil was passed
 
@@ -67,7 +68,7 @@ module Desiru
         raise NotImplementedError, 'Subclasses must implement #add'
       end
 
-      def search(_query, k: 5)
+      def search(_query, k: 5) # rubocop:disable Naming/MethodParameterName
         raise NotImplementedError, 'Subclasses must implement #search'
       end
 
@@ -83,6 +84,7 @@ module Desiru
     # In-memory backend implementation for development and testing
     class InMemoryBackend < Backend
       def initialize(distance_metric: :cosine)
+        super()
         @documents = []
         @embeddings = []
         @distance_metric = distance_metric
@@ -107,7 +109,7 @@ module Desiru
         @embeddings.concat(embeddings)
       end
 
-      def search(query, k: 5)
+      def search(query, k: 5) # rubocop:disable Naming/MethodParameterName
         return [] if @documents.empty?
 
         # Generate query embedding

data/lib/desiru/optimizers/base.rb

@@ -22,7 +22,21 @@ module Desiru
 
       def evaluate(program, dataset)
         scores = dataset.map do |example|
-          prediction = program.call(example.reject { |k, _| %i[answer output].include?(k) })
+          # Extract inputs (exclude answer/output fields)
+          inputs = {}
+          if example.respond_to?(:to_h)
+            example.to_h.each do |k, v|
+              inputs[k] = v unless %i[answer output].include?(k)
+            end
+          elsif example.is_a?(Hash)
+            example.each do |k, v|
+              inputs[k] = v unless %i[answer output].include?(k.to_sym)
+            end
+          else
+            inputs = example
+          end
+
+          prediction = program.call(inputs)
           score_prediction(prediction, example)
         end
 
@@ -55,6 +69,10 @@ module Desiru
           f1_score(prediction, ground_truth)
         when :accuracy
           accuracy_score(prediction, ground_truth)
+        when :confidence
+          confidence_score(prediction, ground_truth)
+        when :consistency
+          consistency_score(prediction, ground_truth)
         else
           raise OptimizerError, "Unknown metric: #{@metric}"
         end
@@ -86,13 +104,23 @@ module Desiru
         exact_match_score(prediction, ground_truth)
       end
 
+      def confidence_score(prediction, ground_truth)
+        # Simple confidence score based on exact match
+        # In a real implementation, this would use model confidence scores
+        (exact_match_score(prediction, ground_truth) * 0.9) + 0.1
+      end
+
+      def consistency_score(prediction, ground_truth)
+        # Simple consistency score based on exact match
+        # In a real implementation, this would track consistency across examples
+        (exact_match_score(prediction, ground_truth) * 0.8) + 0.2
+      end
+
       def extract_answer(data)
         case data
-        when ModuleResult, ProgramResult
+        when ModuleResult, ProgramResult, Hash
           # Try common answer fields
           data[:answer] || data[:output] || data[:result] || data.values.first
-        when Hash
-          data[:answer] || data[:output] || data[:result] || data.values.first
         else
           data
         end

data/lib/desiru/optimizers/bootstrap_few_shot.rb

@@ -80,7 +80,7 @@ module Desiru
 
           begin
             # Get module prediction
-            inputs = example.reject { |k, _| %i[answer output].include?(k) }
+            inputs = example.except(:answer, :output)
             prediction = module_instance.call(inputs)
 
             # Score the prediction
@@ -110,7 +110,7 @@ module Desiru
         # Add labeled examples if available
         labeled = examples.select { |ex| ex[:answer] || ex[:output] }
         labeled_demos = labeled.first(config[:max_labeled_demos]).map do |ex|
-          inputs = ex.reject { |k, _| %i[answer output].include?(k) }
+          inputs = ex.except(:answer, :output)
           {
             input: format_demo_input(inputs),
             output: format_demo_output(ex),

data/lib/desiru/optimizers/copro.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Optimizers
+    # COPRO (Cooperative Prompt Optimization) optimizer
+    # Generates and refines instructions for each module using coordinate ascent
+    class COPRO < Base
+      def initialize(config = {})
+        super
+        @max_iterations = config[:max_iterations] || 10
+        @num_candidates = config[:num_candidates] || 5
+        @temperature = config[:temperature] || 0.7
+        @improvement_threshold = config[:improvement_threshold] || 0.01
+      end
+
+      def compile(program, trainset, valset = nil, **kwargs)
+        valset ||= trainset # Use trainset for validation if no valset provided
+
+        # Initialize best score
+        best_score = evaluate_program(program, valset, kwargs[:metric])
+        best_program = program.dup
+
+        Desiru.logger.info("[COPRO] Initial score: #{best_score}")
+
+        # Iterate through optimization rounds
+        @max_iterations.times do |iteration|
+          Desiru.logger.info("[COPRO] Starting iteration #{iteration + 1}/#{@max_iterations}")
+
+          # Try to improve each predictor
+          improved = false
+
+          program.predictors.each do |name, predictor|
+            Desiru.logger.info("[COPRO] Optimizing predictor: #{name}")
+
+            # Generate instruction candidates
+            candidates = generate_instruction_candidates(predictor, trainset, name)
+
+            # Evaluate each candidate
+            best_candidate_score = best_score
+            best_candidate_instruction = nil
+
+            candidates.each do |instruction|
+              # Create program with new instruction
+              candidate_program = create_program_with_instruction(
+                best_program,
+                name,
+                instruction
+              )
+
+              # Evaluate
+              score = evaluate_program(candidate_program, valset, kwargs[:metric])
+
+              if score > best_candidate_score
+                best_candidate_score = score
+                best_candidate_instruction = instruction
+              end
+            end
+
+            # Update if improved
+            next unless best_candidate_instruction && (best_candidate_score - best_score) > @improvement_threshold
+
+            Desiru.logger.info("[COPRO] Improved #{name}: #{best_score} -> #{best_candidate_score}")
+            best_program = create_program_with_instruction(
+              best_program,
+              name,
+              best_candidate_instruction
+            )
+            best_score = best_candidate_score
+            improved = true
+          end
+
+          # Early stopping if no improvement
+          break unless improved
+        end
+
+        Desiru.logger.info("[COPRO] Final score: #{best_score}")
+        best_program
+      end
+
+      private
+
+      def generate_instruction_candidates(predictor, trainset, predictor_name)
+        candidates = []
+
+        # Get examples of good performance
+        good_examples = select_good_examples(predictor, trainset)
+
+        # Generate initial instruction based on signature
+        signature = predictor.signature
+        base_instruction = generate_base_instruction(signature, predictor_name)
+        candidates << base_instruction
+
+        # Generate variations
+        (@num_candidates - 1).times do |i|
+          variation_prompt = build_variation_prompt(
+            base_instruction,
+            signature,
+            good_examples,
+            i
+          )
+
+          response = model.complete(
+            messages: [{ role: 'user', content: variation_prompt }],
+            temperature: @temperature
+          )
+
+          instruction = extract_instruction(response[:content])
+          candidates << instruction if instruction
+        end
+
+        candidates.compact.uniq
+      end
+
+      def generate_base_instruction(signature, predictor_name)
+        instruction = "You are solving a #{predictor_name} task.\n\n"
+
+        # Add input description
+        if signature.input_fields.any?
+          instruction += "Given the following inputs:\n"
+          signature.input_fields.each do |name, field|
+            instruction += "- #{name}: #{field.description || field.type}\n"
+          end
+          instruction += "\n"
+        end
+
+        # Add output description
+        if signature.output_fields.any?
+          instruction += "Produce the following outputs:\n"
+          signature.output_fields.each do |name, field|
+            instruction += "- #{name}: #{field.description || field.type}\n"
+          end
+        end
+
+        instruction
+      end
+
+      def build_variation_prompt(base_instruction, signature, good_examples, variation_index)
+        prompt = "Improve the following instruction for better performance:\n\n"
+        prompt += "Current instruction:\n#{base_instruction}\n\n"
+
+        # Add task context
+        prompt += "Task signature: #{signature}\n\n"
+
+        # Add examples of good performance
+        if good_examples.any?
+          prompt += "Examples of successful completions:\n"
+          good_examples.take(3).each do |example|
+            prompt += format_example(example)
+          end
+        end
+
+        # Request specific type of improvement
+        improvement_types = [
+          "Make the instruction more specific and detailed",
+          "Add helpful constraints or guidelines",
+          "Clarify any ambiguous requirements",
+          "Add examples or patterns to follow",
+          "Emphasize important aspects of the task"
+        ]
+
+        prompt += "\n#{improvement_types[variation_index % improvement_types.length]}.\n"
+        prompt += "Provide only the improved instruction:"
+
+        prompt
+      end
+
+      def select_good_examples(predictor, trainset)
+        good_examples = []
+
+        trainset.each do |example|
+          # Run predictor on example inputs
+          result = predictor.call(example[:inputs])
+
+          # Check if output matches expected
+          good_examples << example if outputs_match?(result, example[:outputs])
+        rescue StandardError
+          # Skip failed examples
+        end
+
+        good_examples
+      end
+
+      def outputs_match?(actual, expected)
+        return false unless actual.is_a?(Hash) && expected.is_a?(Hash)
+
+        expected.all? do |key, expected_value|
+          actual_value = actual[key]
+
+          # Flexible matching for different types
+          case expected_value
+          when String
+            actual_value.to_s.strip.downcase == expected_value.strip.downcase
+          when Numeric
+            (actual_value.to_f - expected_value.to_f).abs < 0.001
+          else
+            actual_value == expected_value
+          end
+        end
+      end
+
+      def format_example(example)
+        formatted = "\nExample:\n"
+
+        if example[:inputs]
+          formatted += "Inputs: "
+          formatted += example[:inputs].map { |k, v| "#{k}=#{v}" }.join(", ")
+          formatted += "\n"
+        end
+
+        if example[:outputs]
+          formatted += "Outputs: "
+          formatted += example[:outputs].map { |k, v| "#{k}=#{v}" }.join(", ")
+          formatted += "\n"
+        end
+
+        formatted
+      end
+
+      def extract_instruction(response)
+        # Clean up the response
+        instruction = response.strip
+
+        # Remove any meta-commentary
+        instruction = instruction.sub(/^(Here's |This is )?the improved instruction:?\s*/i, '')
+        instruction = instruction.sub(/^Improved instruction:?\s*/i, '')
+
+        # Remove quotes if wrapped
+        instruction.gsub(/^["']|["']$/, '')
+      end
+
+      def create_program_with_instruction(program, predictor_name, instruction)
+        new_program = program.dup
+
+        # Get the predictor
+        predictor = new_program.predictors[predictor_name]
+        return new_program unless predictor
+
+        # Create new predictor with updated instruction
+        new_predictor = predictor.dup
+        new_predictor.instance_variable_set(:@instruction, instruction)
+
+        # Update the program
+        new_program.instance_variable_set("@#{predictor_name}", new_predictor)
+
+        new_program
+      end
+
+      def evaluate_program(program, dataset, metric)
+        scores = []
+
+        dataset.each do |example|
+          # Run program
+          prediction = program.forward(**example[:inputs])
+
+          # Calculate score
+          score = metric.call(prediction, example[:outputs])
+          scores << score
+        rescue StandardError => e
+          Desiru.logger.debug("[COPRO] Evaluation error: #{e.message}")
+          scores << 0.0
+        end
+
+        # Return average score
+        scores.empty? ? 0.0 : scores.sum.to_f / scores.length
+      end
+    end
+  end
+end