Planning algoritmy pro agenty
Planning algoritmy představují klíčovou komponentu moderních AI agentů, která jim umožňuje strategicky plánovat a provádět složité úkoly. Tyto algoritmy kombinují vyhledávání, optimalizaci a rozhodování pro vytvoření efektivních sekvencí akcí.
Planning algoritmy pro AI agenty: Od teorie k praxi
Planning algoritmy představují klíčovou komponentu moderních AI agentů, které potřebují rozhodovat o sekvenci akcí k dosažení definovaných cílů. Zatímco velké jazykové modely (LLM) excejlují v generování textu, jejich schopnost systematického plánování je často limitovaná. Proto se při vývoji produkčních agentů kombinují LLM s dedikovanými planning algoritmy.
Základní principy planning algoritmů
Planning v kontextu AI agentů spočívá v hledání sekvence akcí, která vede ze současného stavu do požadovaného cílového stavu. Klíčové komponenty zahrnují:
- State space - reprezentace možných stavů světa
- Action space - množina dostupných akcí
- Transition model - pravidla přechodů mezi stavy
- Goal specification - definice cílového stavu
- Cost function - ohodnocení jednotlivých akcí
Forward vs Backward Planning
Forward planning začína od současného stavu a postupuje směrem k cíli, zatímco backward planning začína od cíle a pracuje zpětně. Pro praktické nasazení s LLM je forward planning intuitivnější:
class ForwardPlanner:
def __init__(self, llm_client, max_steps=10):
self.llm = llm_client
self.max_steps = max_steps
def plan(self, current_state, goal, available_actions):
plan = []
state = current_state
for step in range(self.max_steps):
if self.is_goal_reached(state, goal):
break
# Využití LLM pro výběr nejlepší akce
prompt = f"""
Současný stav: {state}
Cíl: {goal}
Dostupné akce: {available_actions}
Vyber nejlepší akci pro dosažení cíle:
"""
action = self.llm.generate(prompt)
plan.append(action)
state = self.apply_action(state, action)
return plan
Hierarchical Task Network (HTN) Planning
HTN planning je obzvláště vhodný pro komplexní agenty, protože umožňuje dekompozici vysokoúrovňových úkolů na elementární akce. Tento přístup se dobře kombinuje s možnostmi LLM:
class HTNPlanner:
def __init__(self, llm_client):
self.llm = llm_client
self.methods = {} # Slovník metod pro dekompozici úkolů
def decompose_task(self, task, context):
"""Dekompozice složeného úkolu na podúkoly"""
if task in self.methods:
return self.methods[task](context)
# Využití LLM pro dynamickou dekompozici
prompt = f"""
Rozlož následující úkol na konkrétní kroky:
Úkol: {task}
Kontext: {context}
Vrať seznam podúkolů ve formátu JSON:
"""
response = self.llm.generate(prompt)
return self.parse_subtasks(response)
def plan_recursive(self, task, context, depth=0):
if self.is_primitive(task):
return [task] # Primitivní akce
subtasks = self.decompose_task(task, context)
plan = []
for subtask in subtasks:
subplan = self.plan_recursive(subtask, context, depth + 1)
plan.extend(subplan)
return plan
Monte Carlo Tree Search (MCTS) pro planning
MCTS kombinuje exploration a exploitation při hledání optimálního plánu. Pro agenty je cenný při práci s neúplnými informacemi:
import random
import math
class MCTSNode:
def __init__(self, state, action=None, parent=None):
self.state = state
self.action = action
self.parent = parent
self.children = []
self.visits = 0
self.reward = 0.0
def ucb_score(self, exploration_weight=1.4):
if self.visits == 0:
return float('inf')
exploitation = self.reward / self.visits
exploration = exploration_weight * math.sqrt(
math.log(self.parent.visits) / self.visits
)
return exploitation + exploration
class MCTSPlanner:
def __init__(self, llm_client, simulations=1000):
self.llm = llm_client
self.simulations = simulations
def search(self, root_state, goal):
root = MCTSNode(root_state)
for _ in range(self.simulations):
node = self.select(root)
if not self.is_terminal(node.state):
node = self.expand(node)
reward = self.simulate(node.state, goal)
self.backpropagate(node, reward)
return self.get_best_action(root)
def expand(self, node):
"""Rozšíření uzlu o nové možné akce"""
actions = self.get_possible_actions(node.state)
action = random.choice(actions)
new_state = self.apply_action(node.state, action)
child = MCTSNode(new_state, action, node)
node.children.append(child)
return child
Reactive Planning s LLM
V dynamickém prostředí je často potřeba reagovat na změny během vykonávání plánu. Reactive planning kombinuje předpřipravený plán s možností adaptace:
class ReactivePlanner:
def __init__(self, llm_client):
self.llm = llm_client
self.current_plan = []
self.execution_history = []
def execute_with_monitoring(self, initial_plan, environment):
self.current_plan = initial_plan.copy()
while self.current_plan:
action = self.current_plan.pop(0)
# Monitoring prostředí před akcí
current_state = environment.get_state()
if self.detect_plan_failure(current_state):
self.replan(current_state, environment.goal)
continue
# Vykonání akce
result = environment.execute(action)
self.execution_history.append((action, result))
# Kontrola po akci
if result.success:
continue
else:
# Reakce na selhání
recovery_action = self.generate_recovery(
action, result, current_state
)
if recovery_action:
self.current_plan.insert(0, recovery_action)
def replan(self, current_state, goal):
"""Dynamické přeplánování při změně podmínek"""
prompt = f"""
Původní plán selhal. Současná situace:
Stav: {current_state}
Cíl: {goal}
Historie: {self.execution_history[-3:]}
Navrhni nový plán od současného stavu:
"""
new_plan = self.llm.generate(prompt)
self.current_plan = self.parse_plan(new_plan)
Integrace s production systémy
Při nasazení planning algoritmů v produkci je klíčová optimalizace výkonu a spolehlivost. Doporučuje se:
- Caching - ukládání často používaných plánů
- Timeouts - omezení času pro planning
- Fallback mechanismy - záložní jednoduché strategie
- Monitoring - sledování úspěšnosti plánů
class ProductionPlanner:
def __init__(self, llm_client, cache_size=1000):
self.llm = llm_client
self.plan_cache = {}
self.performance_metrics = {
'planning_time': [],
'success_rate': 0.0,
'cache_hits': 0
}
async def plan_with_timeout(self, state, goal, timeout=30):
cache_key = self.get_cache_key(state, goal)
if cache_key in self.plan_cache:
self.performance_metrics['cache_hits'] += 1
return self.plan_cache[cache_key]
try:
plan = await asyncio.wait_for(
self.generate_plan(state, goal),
timeout=timeout
)
self.plan_cache[cache_key] = plan
return plan
except asyncio.TimeoutError:
# Fallback na jednoduchý heuristický plán
return self.simple_heuristic_plan(state, goal)
Shrnutí
Planning algoritmy jsou nezbytné pro vytváření spolehlivých AI agentů schopných komplexního rozhodování. Kombinace tradičních přístupů jako HTN planning nebo MCTS s možnostmi LLM otevírá nové možnosti pro adaptivní a inteligentní agenty. Klíčem k úspěchu je vhodná volba algoritmu podle konkrétního use case a pečlivá implementace s ohledem na výkon a spolehlivost v produkčním prostředí.