メニュー
Improves LLM-based evolutionary search by addressing context pollution, mode collapse, and weak collaboration through hierarchical context management, momentum-based backtracking, and adaptive sampling policies.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/ADu2021/skillXiv --skill paceevolve-evolution-searchコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
SOC 職業分類に基づく
SKILL.md を表示中
| name | paceevolve-evolution-search |
| title | PACEvolve: Enabling Long-Horizon Progress-Aware Consistent Evolution |
| version | 0.0.2 |
| engine | skillxiv-v0.0.2-claude-opus-4.6 |
| license | MIT |
| url | https://arxiv.org/abs/2601.10657 |
| keywords | ["evolutionary-search","LLM-optimization","long-horizon","progress-aware","context-management"] |
| description | Improves LLM-based evolutionary search by addressing context pollution, mode collapse, and weak collaboration through hierarchical context management, momentum-based backtracking, and adaptive sampling policies. |
Enhance LLM-driven evolutionary search for long-horizon optimization tasks. Address three key failure modes: context pollution from accumulated experiment data, mode collapse from imbalanced exploration-exploitation, and weak collaboration between parallel search trajectories.
Prevent context pollution by pruning irrelevant historical data.
# Hierarchical context management
class ContextManager:
def __init__(self, max_context_tokens=2000):
self.max_tokens = max_context_tokens
self.experiment_history = []
self.context_cache = {}
def maintain_context_hierarchy(self):
"""Organize context by relevance tiers"""
tiers = {
"recent": [], # Last N experiments
"best": [], # Best-performing experiments
"diverse": [] # Diverse solution approaches
}
# Tier 1: Most recent (lexical recency)
tiers["recent"] = self.experiment_history[-10:]
# Tier 2: Best performance
best_experiments = (
.experiment_history,
key= x: x[],
reverse=
)[:]
tiers[] = best_experiments
tiers[] = .select_diverse_representatives(
.experiment_history,
k=
)
tiers
():
(experiments) <= k:
experiments
clusters = .cluster_by_structure(experiments)
representatives = []
cluster clusters:
best_in_cluster = (cluster, key= x: x[])
representatives.append(best_in_cluster)
representatives[:k]
():
pruned_history = []
experiment .experiment_history:
recency_score = .compute_recency(experiment)
performance_score = .compute_performance(experiment)
relevance_score = .compute_problem_relevance(
experiment,
current_problem
)
overall_score = (
* recency_score +
* performance_score +
* relevance_score
)
overall_score > RETENTION_THRESHOLD:
pruned_history.append(experiment)
.experiment_history = pruned_history
pruned_history
():
age = (.experiment_history) - .experiment_history.index(experiment)
/ ( + age)
():
all_fitness = [e[] e .experiment_history]
min_f, max_f = (all_fitness), (all_fitness)
min_f == max_f:
(experiment[] - min_f) / (max_f - min_f)
():
experiment.get() == problem.get():
Escape local optima by reverting to diverse solutions.
# Momentum-based backtracking
class MomentumBacktracker:
def __init__(self, backtrack_window=5):
self.backtrack_window = backtrack_window
self.trajectory_history = []
self.fitness_trend = []
def detect_local_optimum(self):
"""Check if stuck in local optimum"""
# Analyze recent fitness trend
if len(self.fitness_trend) < self.backtrack_window:
return False
recent_trend = self.fitness_trend[-self.backtrack_window:]
# Stagnation: fitness plateau
improvement = max(recent_trend) - min(recent_trend)
stagnation = improvement < STAGNATION_THRESHOLD
# Diversity loss: all solutions similar
solution_similarity = self.compute_avg_similarity()
low_diversity = solution_similarity > SIMILARITY_THRESHOLD
is_stuck = stagnation and low_diversity
return {
"is_stuck": is_stuck,
"stagnation_score": improvement,
"diversity_score": 1.0 - solution_similarity
}
def backtrack_with_momentum(self, current_fitness):
"""Revert to promising past solution with momentum"""
# Find checkpoint with good fitness and different structure
checkpoint = self.select_backtrack_checkpoint()
if checkpoint is None:
return None
# Combine checkpoint with momentum from current trajectory
current_solution = self.trajectory_history[-1]["solution"]
checkpoint_solution = checkpoint["solution"]
# Blending: weighted combination
momentum = self.compute_momentum_vector(current_solution, checkpoint_solution)
# Backtrack solution = checkpoint + momentum adjustment
backtrack_solution = self.blend_solutions(
checkpoint_solution,
momentum,
alpha=0.7
)
return {
"solution": backtrack_solution,
"checkpoint_fitness": checkpoint["fitness"],
"momentum_direction": momentum
}
def select_backtrack_checkpoint(self):
"""Select good past solution with different structure"""
# Look back in history for high-fitness, diverse solutions
candidates = []
for i in range(max(0, len(self.trajectory_history) - 20), len(self.trajectory_history)):
solution = self.trajectory_history[i]
# Must have reasonable fitness
if solution["fitness"] > BACKTRACK_FITNESS_THRESHOLD:
# And be structurally different from recent solutions
diversity = self.compute_diversity_from_recent(solution)
if diversity > DIVERSITY_THRESHOLD:
candidates.append(solution)
if not candidates:
return None
# Select best candidate
return max(candidates, key=lambda x: x["fitness"])
def blend_solutions(self, base_solution, momentum, alpha=0.7):
"""Blend checkpoint with momentum direction"""
# Linear combination in solution space
blended = alpha * base_solution + (1 - alpha) * momentum
return blended
def compute_momentum_vector(self, current, checkpoint):
"""Direction of progress from checkpoint to current"""
return current - checkpoint
def compute_diversity_from_recent(self, solution):
"""How different from recent solutions"""
recent_solutions = [s["solution"] for s in self.trajectory_history[-5:]]
similarities = [
self.compute_solution_similarity(solution["solution"], recent)
for recent in recent_solutions
]
avg_similarity = np.mean(similarities)
return 1.0 - avg_similarity
Dynamically balance exploration and exploitation.
# Self-adaptive sampling
class AdaptiveSamplingPolicy:
def __init__(self):
self.exploration_rate = 0.5
self.sampling_history = []
def compute_adaptive_rate(self, recent_progress):
"""Adjust exploration based on progress"""
# High progress -> exploit (lower exploration)
# Stagnation -> explore (higher exploration)
improvement = np.mean(recent_progress)
if improvement > HIGH_PROGRESS_THRESHOLD:
# Good progress, shift to exploitation
self.exploration_rate = max(0.1, self.exploration_rate - 0.1)
elif improvement < LOW_PROGRESS_THRESHOLD:
# Poor progress, increase exploration
self.exploration_rate = min(0.9, self.exploration_rate + 0.1)
return self.exploration_rate
def sample_next_candidate(self, best_candidates, random_candidates, exploration_rate):
"""Choose between exploiting best or exploring random"""
if np.random.random() < exploration_rate:
# Exploration: sample from random pool
return np.random.choice(random_candidates)
else:
# Exploitation: sample from best pool
return np.random.choice(best_candidates)
def integrate_backtracking(self, backtrack_solution, exploration_rate):
"""Incorporate backtracking into sampling"""
# When backtracking, temporarily increase exploration
# to escape local basin
backtrack_exploration = min(
exploration_rate + 0.3,
0.9
)
return backtrack_exploration
def compute_sampling_efficiency(self):
"""Track whether sampling strategy is effective"""
# Ratio of improvements to samples
total_samples = len(self.sampling_history)
improvements = sum(
1 for i in range(1, len(self.sampling_history))
if self.sampling_history[i]["fitness"] > self.sampling_history[i-1]["fitness"]
)
efficiency = improvements / total_samples
return efficiency
Combine all components into complete search loop.
# Complete evolutionary search loop
class PACEevolveSearch:
def __init__(self, llm_generator):
self.generator = llm_generator
self.context_manager = ContextManager()
self.backtracker = MomentumBacktracker()
self.sampler = AdaptiveSamplingPolicy()
def search_iteration(self, problem, budget=100):
"""Single generation of evolutionary search"""
for step in range(budget):
# 1. Maintain context hierarchy, prune pollution
context = self.context_manager.maintain_context_hierarchy()
self.context_manager.prune_context(problem)
# 2. Generate candidates using LLM
candidates = self.generator.generate_candidates(
problem,
context,
num_candidates=10
)
# 3. Evaluate candidates
candidates = self.evaluate_candidates(candidates)
# 4. Check for local optimum
stuck = self.backtracker.detect_local_optimum()
if stuck["is_stuck"]:
# Apply momentum-based backtracking
backtrack = self.backtracker.backtrack_with_momentum(
max(e["fitness"] for e in candidates)
)
if backtrack:
candidates.append(backtrack["solution"])
# 5. Adaptive sampling for next generation
best_candidates = sorted(candidates, key=lambda x: x["fitness"], reverse=True)[:5]
self.sampler.compute_adaptive_rate(
[e["fitness"] for e in candidates]
)
# 6. Store best and continue
if best_candidates:
self.context_manager.experiment_history.append(best_candidates[0])
return self.context_manager.experiment_history