菜单
Generates molecules meeting precise numeric property constraints across multiple dimensions through two-stage multi-agent framework with fragment-level edits and Group Relative Policy Optimization, improving validity and property satisfaction.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/ADu2021/skillXiv --skill m4olgen-molecular-generation命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
正在显示 SKILL.md
基于 SOC 职业分类
| name | m4olgen-molecular-generation |
| title | M4olGen: Multi-Agent, Multi-Stage Molecular Generation under Precise Multi-Property Constraints |
| version | 0.0.2 |
| engine | skillxiv-v0.0.2-claude-opus-4.6 |
| license | MIT |
| url | https://arxiv.org/abs/2601.10131 |
| keywords | ["molecular-generation","multi-agent","property-constraints","fragment-based","GRPO"] |
| description | Generates molecules meeting precise numeric property constraints across multiple dimensions through two-stage multi-agent framework with fragment-level edits and Group Relative Policy Optimization, improving validity and property satisfaction. |
Design a multi-agent molecular generation system that creates valid molecules satisfying precise numeric constraints on multiple physicochemical properties (QED, LogP, Molecular Weight, HOMO, LUMO). Use a two-stage approach with fragment-level reasoning to enable controlled, property-aware generation.
Generate candidate molecules through multi-agent collaboration using fragment-level operations.
# Multi-agent prototype generation
class PrototypeGenerator:
def __init__(self):
self.fragment_retriever = FragmentRetriever()
self.editor_agent = FragmentEditorAgent()
self.validator_agent = StructuralValidatorAgent()
def generate_prototype(self, property_constraints, num_candidates=10):
"""Generate candidate molecules near feasible region"""
candidates = []
for _ in range(num_candidates):
# Start with seed molecule
molecule = self.select_seed_molecule(property_constraints)
# Multi-agent editing
current_molecule = molecule
for edit_step in range(MAX_EDITS):
edit_proposal = .editor_agent.propose_edit(
current_molecule,
property_constraints
)
fragments = .fragment_retriever.retrieve(
edit_proposal[],
k=
)
candidate_fragment fragments:
edited = .apply_fragment_edit(
current_molecule,
edit_proposal[],
candidate_fragment
)
.validator_agent.is_valid(edited):
current_molecule = edited
.is_near_feasible(current_molecule, property_constraints):
candidates.append(current_molecule)
candidates
():
():
mol = Chem.MolFromSmiles(molecule)
frag = Chem.MolFromSmiles(fragment)
edited = .perform_substitution(mol, position, frag)
edited :
Chem.MolToSmiles(edited)
():
props = .compute_properties(molecule)
distance =
prop_name, (min_val, max_val) constraints.items():
current = props[prop_name]
current < min_val:
distance += (min_val - current) **
current > max_val:
distance += (current - max_val) **
distance < FEASIBILITY_TOLERANCE
Use molecular fragments as semantic units for reasoning.
# Fragment-based molecule representation
class FragmentBasis:
def __init__(self):
self.fragment_library = {}
self.fragment_properties = {}
def decompose_molecule(self, smiles):
"""Break molecule into fragments"""
mol = Chem.MolFromSmiles(smiles)
# Use BRICS fragmentation (Breaking of Retrosynthetically Interesting Chemical Substructures)
frags = BRICS.BRICSDecompose(mol)
return list(frags)
def create_property_chains(self, molecule):
"""Create reasoning chains of fragment edits and property deltas"""
chain = {
"initial_molecule": molecule,
"edits": [],
"property_trajectory": []
}
current = molecule
for step in range(REASONING_DEPTH):
# Propose edit
edit = self.propose_edit(current)
# Record property change
old_props = self.compute_properties(current)
new_props = self.compute_properties(edit["result"])
delta = {k: new_props[k] - old_props[k] for k in old_props}
chain["edits"].append({
"operation": edit["operation"],
"fragment": edit["fragment"],
"property_delta": delta
})
chain["property_trajectory"].append(new_props)
current = edit["result"]
return chain
def compute_properties(self, smiles):
"""Compute physicochemical properties"""
mol = Chem.MolFromSmiles(smiles)
if mol is None:
return None
return {
"QED": Crippen.MolLogP(mol), # Quantitative Estimate of Druglikeness
"LogP": Descriptors.MolLogP(mol),
"MW": Descriptors.MolWt(mol),
"HOMO": self.estimate_homo(mol),
"LUMO": self.estimate_lumo(mol)
}
def estimate_homo(self, mol):
"""Estimate HOMO using empirical model"""
# In practice, would use ML model trained on QM9 dataset
# Simple approximation for now
n_atoms = mol.GetNumAtoms()
n_heavy = Descriptors.HeavyAtomCount(mol)
return -0.3 * n_heavy + 0.5 # Placeholder
def estimate_lumo(self, mol):
"""Estimate LUMO"""
# Empirical approximation
return self.estimate_homo(mol) + 3.5 # Gap approx 3.5 eV for organic molecules
Optimize fragment edits using GRPO to minimize property errors.
# Fragment-level optimization with GRPO
class GRPO_Optimizer:
def __init__(self, policy_model):
self.policy = policy_model
self.fragment_basis = FragmentBasis()
def optimize_fragment_sequence(self, molecule, target_properties, num_edits=5):
"""Use GRPO to optimize fragment editing sequence"""
current_molecule = molecule
edit_sequence = []
for step in range(num_edits):
# Compute current error
current_props = self.fragment_basis.compute_properties(current_molecule)
current_error = self.compute_property_error(current_props, target_properties)
# Policy: propose fragment edit
edit_proposal = self.policy.propose_edit(
current_molecule,
target_properties,
current_error
)
# Apply edit
edited_molecule = self.apply_edit(current_molecule, edit_proposal)
# Compute new error and reward
new_props = self.fragment_basis.compute_properties(edited_molecule)
new_error = self.compute_property_error(new_props, target_properties)
reward = current_error - new_error # Reward for error reduction
edit_sequence.append({
"edit": edit_proposal,
"molecule": edited_molecule,
"error_reduction": reward
})
current_molecule = edited_molecule
# Stop if properties satisfied
if new_error < ERROR_TOLERANCE:
break
return {
"final_molecule": current_molecule,
"edit_sequence": edit_sequence,
"final_error": new_error
}
def compute_property_error(self, actual_props, target_props):
"""Compute error across all properties"""
errors = {}
total_error = 0.0
for prop_name, (min_val, max_val) in target_props.items():
current = actual_props[prop_name]
if current < min_val:
error = (min_val - current) ** 2
elif current > max_val:
error = (current - max_val) ** 2
else:
error = 0.0
errors[prop_name] = error
total_error += error
return np.sqrt(total_error / len(target_props))
def apply_edit(self, molecule, edit_proposal):
"""Apply fragment edit to molecule"""
# Implementation of fragment substitution
edited = self.fragment_basis.apply_fragment_edit(
molecule,
edit_proposal["position"],
edit_proposal["fragment"]
)
return edited
def train_policy(self, training_pairs, learning_rate=1e-3):
"""Train policy using GRPO"""
# Group Relative Policy Optimization
# Improve policy based on successful edits
for molecule, target_props in training_pairs:
# Generate diverse edit proposals
proposals = self.policy.generate_proposals(molecule, target_props, num=5)
# Evaluate each proposal
rewards = []
for proposal in proposals:
edited = self.apply_edit(molecule, proposal)
props = self.fragment_basis.compute_properties(edited)
error = self.compute_property_error(props, target_props)
rewards.append(-error) # Negative error as reward
# GRPO: rank proposals and update
ranked_proposals = sorted(zip(proposals, rewards), key=lambda x: x[1], reverse=True)
for proposal, reward in ranked_proposals:
# Policy gradient update
log_prob = self.policy.get_log_prob(proposal)
loss = -log_prob * reward
self.policy.backward(loss, learning_rate)
Track and report multi-property goal achievement.
# Multi-property validation
class MultiPropertyValidator:
def __init__(self, property_definitions):
self.properties = property_definitions
def validate_molecule(self, smiles, constraints):
"""Check if molecule satisfies all constraints"""
mol = Chem.MolFromSmiles(smiles)
if mol is None:
return {"valid": False, "reason": "Invalid SMILES"}
props = self.compute_properties(mol)
satisfied = {}
all_satisfied = True
for prop_name, (min_val, max_val) in constraints.items():
value = props[prop_name]
is_satisfied = min_val <= value <= max_val
satisfied[prop_name] = {
"value": value,
"min": min_val,
"max": max_val,
"satisfied": is_satisfied
}
if not is_satisfied:
all_satisfied = False
return {
"valid": True,
"all_constraints_satisfied": all_satisfied,
"properties": satisfied,
"compliance_rate": sum(s["satisfied"] for s in satisfied.values()) / len(satisfied)
}
def compute_properties(self, mol):
"""Compute all relevant properties"""
return {
"QED": Crippen.MolLogP(mol),
"LogP": Descriptors.MolLogP(mol),
"MW": Descriptors.MolWt(mol),
"HOMO": self.estimate_homo(mol),
"LUMO": self.estimate_lumo(mol),
"RotBonds": Descriptors.NumRotatableBonds(mol),
"HBD": Descriptors.NumHDonors(mol),
"HBA": Descriptors.NumHAcceptors(mol)
}