135 lines
4.3 KiB
Julia
135 lines
4.3 KiB
Julia
# Multi-step Reasoning - MCTS with Chain of Thought
|
|
|
|
This example demonstrates MCTS for multi-step reasoning problems, where the LLM generates chain-of-thought reasoning at each step.
|
|
|
|
```julia
|
|
using LLMMCTS
|
|
|
|
# State tracks the reasoning process
|
|
# thought_history: Dict mapping thought/action keys to their content
|
|
|
|
function reasoning_transition(state::Dict, args::NamedTuple)
|
|
current_step = get(state, :step, 0)
|
|
thought_history = get(state, :thought_history, Dict{String, String}())
|
|
problem = state[:problem]
|
|
|
|
if current_step == 0
|
|
# Step 1: Understand the problem
|
|
thought = "First, I need to understand what the problem is asking. The problem requires me to analyze the given information and determine the solution approach."
|
|
action = "Identify the key components of the problem"
|
|
|
|
new_thought_history = copy(thought_history)
|
|
new_thought_history["thought_1"] = thought
|
|
new_thought_history["action_1"] = action
|
|
|
|
newstate = Dict(
|
|
:step => 1,
|
|
:thought_history => new_thought_history,
|
|
:reward => 1.0,
|
|
:isterminal => false
|
|
)
|
|
progressvalue = 3.0
|
|
elseif current_step == 1
|
|
# Step 2: Break down the problem
|
|
thought = "Next, I should break this down into smaller sub-problems. This will make it easier to solve step by step."
|
|
action = "Divide the problem into manageable parts"
|
|
|
|
new_thought_history = copy(thought_history)
|
|
new_thought_history["thought_2"] = thought
|
|
new_thought_history["action_2"] = action
|
|
|
|
newstate = Dict(
|
|
:step => 2,
|
|
:thought_history => new_thought_history,
|
|
:reward => 2.0,
|
|
:isterminal => false
|
|
)
|
|
progressvalue = 5.0
|
|
elseif current_step == 2
|
|
# Step 3: Solve each sub-problem
|
|
thought = "Now I'll solve each sub-problem individually, using appropriate methods for each."
|
|
action = "Apply solution methods to each sub-problem"
|
|
|
|
new_thought_history = copy(thought_history)
|
|
new_thought_history["thought_3"] = thought
|
|
new_thought_history["action_3"] = action
|
|
|
|
newstate = Dict(
|
|
:step => 3,
|
|
:thought_history => new_thought_history,
|
|
:reward => 3.0,
|
|
:isterminal => false
|
|
)
|
|
progressvalue = 7.0
|
|
elseif current_step == 3
|
|
# Step 4: Combine solutions
|
|
thought = "Finally, I'll combine all the solutions to form the complete answer to the original problem."
|
|
action = "Integrate solutions and verify the answer"
|
|
|
|
new_thought_history = copy(thought_history)
|
|
new_thought_history["thought_4"] = thought
|
|
new_thought_history["action_4"] = action
|
|
|
|
newstate = Dict(
|
|
:step => 4,
|
|
:thought_history => new_thought_history,
|
|
:reward => 4.0,
|
|
:isterminal => true # Reasoning complete
|
|
)
|
|
progressvalue = 10.0
|
|
else
|
|
newstate = Dict(
|
|
:step => current_step,
|
|
:thought_history => thought_history,
|
|
:reward => 10.0,
|
|
:isterminal => true
|
|
)
|
|
progressvalue = 10.0
|
|
end
|
|
|
|
return Dict(
|
|
:newNodeKey => "reasoning_step_$current_step",
|
|
:newstate => newstate,
|
|
:progressvalue => progressvalue
|
|
)
|
|
end
|
|
|
|
# Initial state
|
|
initialstate = Dict(
|
|
:step => 0,
|
|
:problem => "Explain how photosynthesis works",
|
|
:thought_history => Dict{String, String}(),
|
|
:reward => 0,
|
|
:isterminal => false
|
|
)
|
|
|
|
# Transition arguments
|
|
transitionargs = (max_steps = 4,)
|
|
|
|
# Run MCTS
|
|
result = runMCTS(
|
|
initialstate,
|
|
reasoning_transition,
|
|
transitionargs;
|
|
maxiterations = 25,
|
|
explorationweight = 1.0,
|
|
maxSimulationDepth = 4,
|
|
horizontalSampleExpansionPhase = 3
|
|
)
|
|
|
|
# Display results
|
|
println("Multi-step Reasoning Example")
|
|
println("=============================")
|
|
println()
|
|
println("Problem: ", initialstate[:problem])
|
|
println()
|
|
println("Reasoning steps:")
|
|
for (key, value) in result.bestTerminalState[:thought_history]
|
|
println(" $key: $value")
|
|
end
|
|
println()
|
|
println("Reasoning complete! ✓")
|
|
println("Root node visits: ", result.root.visits)
|
|
println("Total steps in reasoning chain: ", result.bestTerminalState[:step])
|
|
```
|