#!/usr/bin/env python3 """ ALFWorld 合成トラジェクトリ生成スクリプト v2 ============================================= v1からの改善: - go toの探索パターンを大幅に多様化 - 実際のALFWorld環境に近いレセプタクル構成（cabinet 1-15等） - 探索失敗パターンの多様化（closed→open、空、多数のアイテム等） - 探索長の現実的な分布（短い探索〜長い探索） - 部屋レイアウトのバリエーション強化 使い方: python generate_alfworld_synthetic_v2.py --output synthetic_alfworld_v2.jsonl --count 3000 --focus-weak """ import json import random import argparse from typing import List, Dict, Any, Tuple, Optional from dataclasses import dataclass, field from copy import deepcopy # ============================================================ # ALFWorld 実環境に近いレセプタクル構成テンプレート # ============================================================ # AgentBench/ALFWorld の実際の部屋は以下のような構成を持つ。 # 重要: cabinet は 1-15、countertop は 1-4 など番号範囲が広い。 ROOM_TEMPLATES = { "kitchen_large": { "cabinet": (8, 15), # 8〜15個 "countertop": (2, 4), "drawer": (2, 4), "fridge": (1, 1), "microwave": (1, 1), "sinkbasin": (1, 1), "stoveburner": (2, 4), "toaster": (1, 1), "coffeemachine": (1, 1), "garbagecan": (1, 1), "shelf": (0, 3), }, "kitchen_medium": { "cabinet": (5, 10), "countertop": (1, 3), "drawer": (1, 3), "fridge": (1, 1), "microwave": (1, 1), "sinkbasin": (1, 1), "stoveburner": (2, 4), "toaster": (0, 1), "coffeemachine": (0, 1), "garbagecan": (1, 1), }, "kitchen_small": { "cabinet": (3, 6), "countertop": (1, 2), "drawer": (1, 2), "fridge": (1, 1), "microwave": (1, 1), "sinkbasin": (1, 1), "stoveburner": (1, 2), "garbagecan": (1, 1), }, "bedroom_large": { "bed": (1, 1), "dresser": (1, 2), "drawer": (2, 6), "desk": (1, 1), "shelf": (1, 4), "sidetable": (1, 2), "garbagecan": (1, 1), "laundryhamper": (0, 1), "safe": (0, 1), }, "bedroom_small": { "bed": (1, 1), "dresser": (0, 1), "drawer": (1, 3), "desk": (0, 1), "shelf": (0, 2), "sidetable": (1, 2), "garbagecan": (1, 1), }, "livingroom": { "sofa": (1, 2), "coffeetable": (1, 1), "sidetable": (1, 3), "shelf": (1, 6), "drawer": (1, 4), "armchair": (1, 2), "ottoman": (0, 1), "tvstand": (0, 1), "garbagecan": (1, 1), "dresser": (0, 1), }, "bathroom": { "sinkbasin": (1, 2), "bathtub": (0, 1), "toilet": (1, 1), "shelf": (1, 3), "drawer": (0, 2), "cabinet": (1, 4), "towelholder": (0, 1), "garbagecan": (1, 1), }, } # オブジェクトプール OBJECTS = { "heatable": [ "apple", "bread", "cup", "egg", "mug", "plate", "potato", "bowl", "tomato", ], "coolable": [ "apple", "bowl", "bread", "cup", "egg", "lettuce", "mug", "plate", "potato", "tomato", "wine", ], "cleanable": [ "apple", "bowl", "cloth", "cup", "fork", "knife", "ladle", "lettuce", "mug", "pan", "plate", "pot", "soapbar", "spatula", "spoon", "tomato", ], "examinable": [ "alarmclock", "book", "bowl", "box", "candle", "cd", "cellphone", "cloth", "creditcard", "cup", "houseplant", "keychain", "laptop", "lettuce", "mug", "newspaper", "pen", "pencil", "pillow", "plate", "remotecontrol", "statue", "vase", "watch", ], "pickable": [ "apple", "book", "bowl", "box", "bread", "butterknife", "candle", "cd", "cellphone", "cloth", "creditcard", "cup", "dishsponge", "egg", "fork", "houseplant", "kettle", "keychain", "knife", "ladle", "lettuce", "mug", "newspaper", "pan", "pen", "pencil", "peppershaker", "pillow", "plate", "plunger", "pot", "potato", "remotecontrol", "saltshaker", "soapbar", "soapbottle", "spatula", "spoon", "statue", "teddybear", "tissuebox", "toiletpaper", "tomato", "towel", "vase", "watch", "wateringcan", ], "lamps": ["desklamp", "floorlamp"], } PLACEMENT_TARGETS = [ "countertop", "shelf", "cabinet", "drawer", "dresser", "desk", "sidetable", "coffeetable", "sofa", "armchair", "bed", "ottoman", "tvstand", "garbagecan", "fridge", "bathtub", "toilet", "safe", ] # 開閉可能なレセプタクル OPENABLE_RECEPTACLES = { "cabinet", "drawer", "fridge", "microwave", "safe", } # ============================================================ # Think テンプレート（多様性強化版） # ============================================================ THINK_FIND_OBJECT_INITIAL = [ "Think: I need to find a {obj} first. Let me look around the room. A {obj} is more likely to appear in {recep}. I'll go there first.", "Think: My task requires a {obj}. I should check {recep} - that seems like a reasonable place to look.", "Think: To accomplish this task, I first need to locate a {obj}. I'll start searching from {recep}.", "Think: I need to find a {obj}. {recep_type}s might have one. Let me check {recep}.", "Think: First, let me find a {obj}. I'll try {recep} since it's a common place for household items.", "Think: Let me start by finding a {obj}. I'll go to {recep} to look for one.", "Think: I need a {obj}. Let me search {recep} first - {obj}s are often found there.", "Think: The first step is to find a {obj}. I'll check {recep}.", "Think: I should look for a {obj}. Let me start with {recep}.", "Think: My goal requires a {obj}. I'll begin my search at {recep}.", ] THINK_NOT_FOUND_CONTINUE = [ "Think: The {obj} is not here. Let me try another location. I'll go to {next_recep}.", "Think: No {obj} in {recep}. I'll check {next_recep} next.", "Think: I don't see a {obj} here. Let me look in {next_recep}.", "Think: {recep} doesn't have a {obj}. Moving on to {next_recep}.", "Think: Not here. I should try {next_recep} to find the {obj}.", "Think: The {obj} isn't on {recep}. Let me search {next_recep}.", "Think: Still looking for a {obj}. Let me check {next_recep}.", "Think: I need to keep searching. I'll try {next_recep} for the {obj}.", "Think: No luck with {recep}. Let me try {next_recep}.", "Think: Didn't find a {obj} on {recep}. Next, I'll check {next_recep}.", ] THINK_FOUND_OBJECT = [ "Think: I found a {obj} {id} on {recep}. I should take it.", "Think: Great, there's a {obj} {id} here. Let me pick it up.", "Think: I can see a {obj} {id} on {recep}. I'll take it.", "Think: Found it! A {obj} {id} is on {recep}. I need to pick it up.", "Think: There's a {obj} {id} on the {recep}. Let me take it.", "Think: I see a {obj} {id}. Let me grab it to continue the task.", "Think: Good, {recep} has a {obj} {id}. I'll pick it up now.", "Think: Found a {obj} {id} here. I should take it for my task.", ] THINK_OPEN_CLOSED = [ "Think: The {recep} is closed. I need to open it first to see what's inside.", "Think: {recep} is closed. Let me open it.", "Think: I can't see inside because {recep} is closed. I'll open it.", "Think: It's closed. Let me open {recep} to check for items.", "Think: I need to open {recep} first before I can look inside.", ] THINK_GO_TO_TARGET = [ "Think: Now I need to put the {obj} in/on {recep}. Let me go there.", "Think: I have the {obj}. I need to go to {recep} and place it there.", "Think: Good, I picked up the {obj}. Time to bring it to {recep}.", "Think: With the {obj} in hand, I need to head to {recep}.", "Think: Now I should take this {obj} to {recep}.", "Think: The next step is to go to {recep} with the {obj}.", "Think: Let me bring the {obj} to {recep} to complete this step.", ] THINK_CLEAN = [ "Think: Now I need to clean the {obj}. I should go to sinkbasin and wash it.", "Think: The task requires a clean {obj}. Let me go to {recep} to wash it.", "Think: I have the {obj} and need to clean it. I'll use the sinkbasin.", "Think: Before placing the {obj}, I need to wash it at {recep}.", "Think: To clean the {obj}, I need to go to {recep} and use it.", "Think: I should clean the {obj} now. The sinkbasin is where I can do that.", ] THINK_HEAT = [ "Think: I need to heat the {obj}. I should use the microwave.", "Think: The task requires a hot {obj}. Let me heat it with {recep}.", "Think: I have the {obj} and need to heat it. The microwave will do.", "Think: Before placing the {obj}, I need to heat it using {recep}.", "Think: To heat the {obj}, I'll go to {recep}.", "Think: Now I need to heat the {obj} in the microwave.", ] THINK_COOL = [ "Think: I need to cool the {obj}. I should use the fridge.", "Think: The task requires a cool {obj}. Let me cool it with {recep}.", "Think: I have the {obj} and need to cool it. The fridge is the right place.", "Think: Before placing the {obj}, I need to cool it using {recep}.", "Think: To cool the {obj}, I'll put it in {recep}.", "Think: Now I need to cool the {obj} in the fridge.", ] THINK_EXAMINE = [ "Think: I need to examine the {obj} under a light source. Let me find a {lamp} and use it.", "Think: Now I need to look at the {obj} under a lamp. I should go to {lamp} and turn it on.", "Think: To examine the {obj}, I need a light. Let me go to {lamp}.", "Think: The task requires examining the {obj} under {lamp}. Let me go there.", "Think: I have the {obj}. Now I need to use {lamp} to examine it.", "Think: Now I should find {lamp} and use it to examine the {obj}.", ] THINK_PLACE = [ "Think: Now I need to put the {obj} in/on {recep}.", "Think: Time to place the {obj} in/on {recep}.", "Think: I should put the {obj} in/on {recep} now.", "Think: Almost done. Let me place the {obj} in/on {recep}.", "Think: Final step - putting the {obj} in/on {recep}.", "Think: Let me put the {obj} down on {recep}.", "Think: I'll place the {obj} in/on {recep} to complete the task.", ] THINK_PICK_SECOND = [ "Think: Good, I placed the first {obj}. Now I need to find another {obj} and put it in {recep} too.", "Think: One {obj} done. I need to find a second one for this task.", "Think: First {obj} placed successfully. Now let me look for another {obj}.", "Think: I've placed one {obj}. Time to find the second one. Let me search again.", ] # ============================================================ # ルーム生成（v2: 実環境に近い構成） # ============================================================ def generate_room_v2(rng: random.Random, room_template_key: str = None, ensure_objects: List[str] = None, ensure_receptacles: List[str] = None): """ 実際のALFWorld環境に近いレセプタクル構成で部屋を生成する。 cabinet 1-13 のような広い番号範囲を持つ部屋が生成される。 """ if room_template_key is None: room_template_key = rng.choice(list(ROOM_TEMPLATES.keys())) template = ROOM_TEMPLATES[room_template_key] # レセプタクル名リスト生成 recep_names = [] recep_type_counts = {} for recep_type, (lo, hi) in template.items(): count = rng.randint(lo, hi) if count > 0: recep_type_counts[recep_type] = count for i in range(1, count + 1): recep_names.append(f"{recep_type} {i}") # ensure_receptacles を追加 if ensure_receptacles: for r in ensure_receptacles: # r が既にあるか確認（型名だけの場合は番号1を追加） r_name = f"{r} 1" if " " not in r else r if r_name not in recep_names: recep_names.append(r_name) # 各レセプタクルにアイテムを配置 items_on = {} all_pickable = list(OBJECTS["pickable"]) for recep_name in recep_names: recep_type = recep_name.rsplit(" ", 1)[0] # 開閉可能なものは中身が少ない傾向 if recep_type in OPENABLE_RECEPTACLES: num_items = rng.choices([0, 1, 2], weights=[0.4, 0.4, 0.2])[0] else: num_items = rng.choices([0, 1, 2, 3, 4], weights=[0.25, 0.30, 0.25, 0.15, 0.05])[0] items = [] for _ in range(num_items): obj = rng.choice(all_pickable) obj_id = rng.randint(1, 3) items.append((obj, obj_id)) items_on[recep_name] = items # ensure_objects を配置（ランダムなレセプタクルに） if ensure_objects: for obj in ensure_objects: # 開閉不可なレセプタクルに優先配置（見つけやすいように） open_receps = [r for r in recep_names if r.rsplit(" ", 1)[0] not in OPENABLE_RECEPTACLES] target = rng.choice(open_receps if open_receps else recep_names) obj_id = rng.randint(1, 3) items_on.setdefault(target, []).append((obj, obj_id)) # 初期説明文（ランダム順序） desc_receps = list(recep_names) rng.shuffle(desc_receps) parts = [f"a {r}" for r in desc_receps] if len(parts) > 1: room_items = ", ".join(parts[:-1]) + ", and " + parts[-1] else: room_items = parts[0] room_desc = f"You are in the middle of a room. Looking quickly around you, you see {room_items}." return items_on, room_desc, recep_names # ============================================================ # Tool定義 & メッセージヘルパー # ============================================================ TOOLS_DEFINITION = [ { "type": "function", "function": { "name": "act", "description": "Execute an action in the household environment.", "parameters": { "type": "object", "properties": { "action": { "type": "string", "description": "The action to execute" } }, "required": ["action"] } } } ] SYSTEM_PROMPT = ( "Interact with a household to solve a task. Imagine you are an intelligent agent " "in a household environment and your target is to perform actions to complete the " "task goal. At the beginning of your interactions, you will be given the detailed " "description of the current environment and your goal to accomplish. For each of " "your turn, you will be given the observation of the last executed action. You are " "only allowed to output an action at each turn, and you should think about what to " "do before outputting an action. Your output must strictly follow this format: " "\"Think: your thoughts.\\nAct: your next action\".\n" "Your available actions are:\n" "1. go to {recep}\n2. take {obj} from {recep}\n3. put {obj} in/on {recep}\n" "4. open {recep}\n5. close {recep}\n6. toggle {obj} {recep}\n" "7. clean {obj} with {recep}\n8. heat {obj} with {recep}\n" "9. cool {obj} with {recep}\n10. use {recep}\n11. look" ) def _sys(): return {"role": "system", "content": SYSTEM_PROMPT} def _user(content): return {"role": "user", "content": content} def _assistant(think_act_text, action, call_id): return { "role": "assistant", "content": think_act_text, "tool_calls": [{ "id": call_id, "type": "function", "function": { "name": "act", "arguments": json.dumps({"action": action}) } }] } def _tool(call_id, observation): return {"role": "tool", "tool_call_id": call_id, "content": observation} def _call_id(step, rng): return f"call_{step}_{rng.randint(1000, 9999)}" # ============================================================ # 観察テンプレート生成（v2: 多様化） # ============================================================ def make_observation_for_recep(rng, recep_name, items_on, force_items=None): """ レセプタクルを訪問した際の観察テキストを生成する。 開閉可能なレセプタクルの場合は closed 状態を返すこともある。 """ recep_type = recep_name.rsplit(" ", 1)[0] items = force_items if force_items is not None else items_on.get(recep_name, []) if items: items_parts = [] for obj, oid in items: items_parts.append(f"a {obj} {oid}") items_str = ", ".join(items_parts[:-1]) + ", and " + items_parts[-1] if len(items_parts) > 1 else items_parts[0] return f"On the {recep_name}, you see {items_str}." else: return f"On the {recep_name}, you see nothing." def make_open_observation(rng, recep_name, items_on): """開閉可能レセプタクルを開けた際の観察""" items = items_on.get(recep_name, []) if items: items_parts = [f"a {obj} {oid}" for obj, oid in items] items_str = ", ".join(items_parts[:-1]) + ", and " + items_parts[-1] if len(items_parts) > 1 else items_parts[0] return f"You open the {recep_name}. The {recep_name} is open. In it, you see {items_str}." else: return f"You open the {recep_name}. The {recep_name} is open. In it, you see nothing." # ============================================================ # 探索トラジェクトリ生成（v2: go to パターンの多様化） # ============================================================ def generate_search_trajectory(rng, obj_name, items_on, recep_names, start_step, search_strategy=None): """ オブジェクトを探すトラジェクトリを生成する。 探索戦略（search_strategy）: - "sequential": 番号順に探す（cabinet 1, 2, 3...） - "random": ランダム順 - "type_first": 特定のレセプタクルタイプを優先 - "high_number_first": 大きい番号から探す - "mixed": 異なるタイプを交互に探す - None: ランダムに戦略を選択 """ msgs = [] step = start_step # 探索戦略の選択 if search_strategy is None: search_strategy = rng.choice([ "random", "random", "random", # ランダムが最も多い "type_first", "type_first", "high_number_first", "mixed", "sequential", ]) # ターゲットオブジェクトの位置を特定 target_locations = [] for recep_name, items in items_on.items(): for (o, oid) in items: if o == obj_name: target_locations.append((recep_name, oid)) if not target_locations: # 強制配置 non_openable = [r for r in recep_names if r.rsplit(" ", 1)[0] not in OPENABLE_RECEPTACLES] place_recep = rng.choice(non_openable if non_openable else recep_names) obj_id = rng.randint(1, 3) items_on.setdefault(place_recep, []).append((obj_name, obj_id)) target_locations = [(place_recep, obj_id)] found_recep, found_id = rng.choice(target_locations) # 探索順序を決定 search_pool = [r for r in recep_names if r != found_recep] if search_strategy == "sequential": # レセプタクルタイプでソートし、番号順 search_pool.sort(key=lambda r: (r.rsplit(" ", 1)[0], int(r.rsplit(" ", 1)[1]))) elif search_strategy == "high_number_first": search_pool.sort(key=lambda r: -int(r.rsplit(" ", 1)[1])) elif search_strategy == "type_first": # オブジェクトが見つかりやすそうなタイプを優先 preferred = rng.sample(["countertop", "shelf", "sidetable", "dresser", "desk", "coffeetable", "drawer", "cabinet", "stoveburner", "bed", "sofa", "armchair"], 3) def priority(r): rtype = r.rsplit(" ", 1)[0] return (0 if rtype in preferred else 1, rng.random()) search_pool.sort(key=priority) elif search_strategy == "mixed": # 異なるタイプを交互に by_type = {} for r in search_pool: rtype = r.rsplit(" ", 1)[0] by_type.setdefault(rtype, []).append(r) for v in by_type.values(): rng.shuffle(v) types = list(by_type.keys()) rng.shuffle(types) mixed = [] while any(by_type[t] for t in types if t in by_type): for t in types: if t in by_type and by_type[t]: mixed.append(by_type[t].pop(0)) search_pool = mixed else: # random rng.shuffle(search_pool) # 探索ステップ数を決定（1〜8、ターゲットが見つかるまで） max_search = rng.choices( [1, 2, 3, 4, 5, 6, 7, 8], weights=[0.15, 0.20, 0.25, 0.15, 0.10, 0.07, 0.05, 0.03], )[0] max_search = min(max_search, len(search_pool)) # 探索失敗ステップ for i in range(max_search): recep = search_pool[i] recep_type = recep.rsplit(" ", 1)[0] call_id = _call_id(step, rng) next_recep = search_pool[i + 1] if i + 1 < len(search_pool) else found_recep # Think テンプレート選択 if i == 0: think = rng.choice(THINK_FIND_OBJECT_INITIAL).format( obj=obj_name, recep=recep, recep_type=recep_type ) else: think = rng.choice(THINK_NOT_FOUND_CONTINUE).format( obj=obj_name, recep=search_pool[i-1] if i > 0 else recep, next_recep=recep ) action = f"go to {recep}" # 開閉可能レセプタクルの処理 is_openable = recep_type in OPENABLE_RECEPTACLES is_closed = is_openable and rng.random() < 0.4 # 40%の確率で閉じている if is_closed: obs = f"The {recep} is closed." msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 # 開ける call_id2 = _call_id(step, rng) think2 = rng.choice(THINK_OPEN_CLOSED).format(recep=recep) action2 = f"open {recep}" obs2 = make_open_observation(rng, recep, items_on) msgs.append(_assistant(think2 + f"\nAct: {action2}", action2, call_id2)) msgs.append(_tool(call_id2, obs2)) step += 1 else: obs = make_observation_for_recep(rng, recep, items_on) msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 # ターゲットレセプタクルへ移動 call_id = _call_id(step, rng) if max_search == 0: think = rng.choice(THINK_FIND_OBJECT_INITIAL).format( obj=obj_name, recep=found_recep, recep_type=found_recep.rsplit(" ", 1)[0] ) else: think = rng.choice(THINK_NOT_FOUND_CONTINUE).format( obj=obj_name, recep=search_pool[max_search - 1] if max_search > 0 else "nowhere", next_recep=found_recep ) action = f"go to {found_recep}" # found_recep が開閉可能で閉じている場合 found_type = found_recep.rsplit(" ", 1)[0] found_closed = found_type in OPENABLE_RECEPTACLES and rng.random() < 0.3 if found_closed: obs = f"The {found_recep} is closed." msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 call_id = _call_id(step, rng) think = rng.choice(THINK_OPEN_CLOSED).format(recep=found_recep) action = f"open {found_recep}" obs = make_open_observation(rng, found_recep, items_on) msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 else: obs = make_observation_for_recep(rng, found_recep, items_on) msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 # Take call_id = _call_id(step, rng) obj_full = f"{obj_name} {found_id}" think = rng.choice(THINK_FOUND_OBJECT).format( obj=obj_name, recep=found_recep, id=found_id ) action = f"take {obj_full} from {found_recep}" obs = f"You pick up the {obj_full} from the {found_recep}." msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 return msgs, found_recep, obj_full, found_id, step # ============================================================ # タスク別トラジェクトリ生成 # ============================================================ def _go_and_place(rng, msgs, step, obj_full, target_recep, items_on): """目的地に移動して置くステップを追加""" # Go to target call_id = _call_id(step, rng) think = rng.choice(THINK_GO_TO_TARGET).format(obj=obj_full, recep=target_recep) action = f"go to {target_recep}" obs = make_observation_for_recep(rng, target_recep, items_on) msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 # Put call_id = _call_id(step, rng) think = rng.choice(THINK_PLACE).format(obj=obj_full, recep=target_recep) action = f"put {obj_full} in/on {target_recep}" obs = f"You put the {obj_full} in/on the {target_recep}." msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 return msgs, step def generate_pick_and_place(rng, idx): obj = rng.choice(OBJECTS["pickable"]) target_type = rng.choice(PLACEMENT_TARGETS) room_key = rng.choice(["kitchen_large", "kitchen_medium", "kitchen_small", "bedroom_large", "bedroom_small", "livingroom"]) items_on, room_desc, recep_names = generate_room_v2( rng, room_key, ensure_objects=[obj], ensure_receptacles=[target_type] ) target_recep = f"{target_type} 1" if f"{target_type} 1" in recep_names else \ next((r for r in recep_names if r.startswith(target_type)), f"{target_type} 1") goal = f"Your task is to: put some {obj} on {target_type}." msgs = [_sys(), _user(f"{room_desc}\n{goal}")] search_msgs, _, obj_full, _, step = generate_search_trajectory( rng, obj, items_on, recep_names, start_step=1 ) msgs.extend(search_msgs) msgs, step = _go_and_place(rng, msgs, step, obj_full, target_recep, items_on) return {"messages": msgs, "tools": TOOLS_DEFINITION, "metadata": {"task_type": "pick_and_place", "trajectory_outcome": "success", "synthetic": True, "generator_version": "v2.0"}} def generate_clean_and_place(rng, idx): obj = rng.choice(OBJECTS["cleanable"]) target_type = rng.choice(PLACEMENT_TARGETS) items_on, room_desc, recep_names = generate_room_v2( rng, rng.choice(["kitchen_large", "kitchen_medium", "kitchen_small"]), ensure_objects=[obj], ensure_receptacles=[target_type, "sinkbasin"] ) target_recep = f"{target_type} 1" if f"{target_type} 1" in recep_names else \ next((r for r in recep_names if r.startswith(target_type)), f"{target_type} 1") goal = f"Your task is to: clean some {obj} and put it in {target_type}." msgs = [_sys(), _user(f"{room_desc}\n{goal}")] search_msgs, _, obj_full, _, step = generate_search_trajectory( rng, obj, items_on, recep_names, start_step=1 ) msgs.extend(search_msgs) # Go to sinkbasin and clean call_id = _call_id(step, rng) think = rng.choice(THINK_CLEAN).format(obj=obj_full.split()[0], recep="sinkbasin 1") action = "go to sinkbasin 1" obs = make_observation_for_recep(rng, "sinkbasin 1", items_on) msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 call_id = _call_id(step, rng) think = f"Think: Now I'll clean the {obj_full} with the sinkbasin.\nAct: clean {obj_full} with sinkbasin 1" action = f"clean {obj_full} with sinkbasin 1" obs = f"You clean the {obj_full} using the sinkbasin 1." msgs.append(_assistant(think, action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 msgs, step = _go_and_place(rng, msgs, step, obj_full, target_recep, items_on) return {"messages": msgs, "tools": TOOLS_DEFINITION, "metadata": {"task_type": "clean_and_place", "trajectory_outcome": "success", "synthetic": True, "generator_version": "v2.0"}} def generate_heat_and_place(rng, idx): obj = rng.choice(OBJECTS["heatable"]) target_type = rng.choice(PLACEMENT_TARGETS) items_on, room_desc, recep_names = generate_room_v2( rng, rng.choice(["kitchen_large", "kitchen_medium"]), ensure_objects=[obj], ensure_receptacles=[target_type, "microwave"] ) target_recep = f"{target_type} 1" if f"{target_type} 1" in recep_names else \ next((r for r in recep_names if r.startswith(target_type)), f"{target_type} 1") goal = f"Your task is to: heat some {obj} and put it in {target_type}." msgs = [_sys(), _user(f"{room_desc}\n{goal}")] search_msgs, _, obj_full, _, step = generate_search_trajectory( rng, obj, items_on, recep_names, start_step=1 ) msgs.extend(search_msgs) # Go to microwave and heat call_id = _call_id(step, rng) think = rng.choice(THINK_HEAT).format(obj=obj_full.split()[0], recep="microwave 1") action = "go to microwave 1" if rng.random() < 0.4: obs = "The microwave 1 is closed." msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 call_id = _call_id(step, rng) think = rng.choice(THINK_OPEN_CLOSED).format(recep="microwave 1") action = "open microwave 1" obs = make_open_observation(rng, "microwave 1", items_on) msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 else: obs = f"The microwave 1 is open. In it, you see nothing." msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 call_id = _call_id(step, rng) think = f"Think: I'll heat the {obj_full} with the microwave.\nAct: heat {obj_full} with microwave 1" action = f"heat {obj_full} with microwave 1" obs = f"You heat the {obj_full} using the microwave 1." msgs.append(_assistant(think, action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 msgs, step = _go_and_place(rng, msgs, step, obj_full, target_recep, items_on) return {"messages": msgs, "tools": TOOLS_DEFINITION, "metadata": {"task_type": "heat_and_place", "trajectory_outcome": "success", "synthetic": True, "generator_version": "v2.0"}} def generate_cool_and_place(rng, idx): obj = rng.choice(OBJECTS["coolable"]) target_type = rng.choice(PLACEMENT_TARGETS) items_on, room_desc, recep_names = generate_room_v2( rng, rng.choice(["kitchen_large", "kitchen_medium"]), ensure_objects=[obj], ensure_receptacles=[target_type, "fridge"] ) target_recep = f"{target_type} 1" if f"{target_type} 1" in recep_names else \ next((r for r in recep_names if r.startswith(target_type)), f"{target_type} 1") goal = f"Your task is to: cool some {obj} and put it in {target_type}." msgs = [_sys(), _user(f"{room_desc}\n{goal}")] search_msgs, _, obj_full, _, step = generate_search_trajectory( rng, obj, items_on, recep_names, start_step=1 ) msgs.extend(search_msgs) # Go to fridge and cool call_id = _call_id(step, rng) think = rng.choice(THINK_COOL).format(obj=obj_full.split()[0], recep="fridge 1") action = "go to fridge 1" if rng.random() < 0.4: obs = "The fridge 1 is closed." msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 call_id = _call_id(step, rng) think = rng.choice(THINK_OPEN_CLOSED).format(recep="fridge 1") action = "open fridge 1" obs = make_open_observation(rng, "fridge 1", items_on) msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 else: fridge_items = [(rng.choice(OBJECTS["coolable"]), rng.randint(1, 2)) for _ in range(rng.randint(1, 3))] obs_items = ", ".join(f"a {o} {i}" for o, i in fridge_items) obs = f"The fridge 1 is open. In it, you see {obs_items}." msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 call_id = _call_id(step, rng) think = f"Think: I'll cool the {obj_full} with the fridge.\nAct: cool {obj_full} with fridge 1" action = f"cool {obj_full} with fridge 1" obs = f"You cool the {obj_full} using the fridge 1." msgs.append(_assistant(think, action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 msgs, step = _go_and_place(rng, msgs, step, obj_full, target_recep, items_on) return {"messages": msgs, "tools": TOOLS_DEFINITION, "metadata": {"task_type": "cool_and_place", "trajectory_outcome": "success", "synthetic": True, "generator_version": "v2.0"}} def generate_examine(rng, idx): obj = rng.choice(OBJECTS["examinable"]) lamp = rng.choice(OBJECTS["lamps"]) room_key = rng.choice(["bedroom_large", "bedroom_small", "livingroom"]) items_on, room_desc, recep_names = generate_room_v2( rng, room_key, ensure_objects=[obj] ) goal = f"Your task is to: look at {obj} under the {lamp}." msgs = [_sys(), _user(f"{room_desc}\n{goal}")] search_msgs, _, obj_full, _, step = generate_search_trajectory( rng, obj, items_on, recep_names, start_step=1 ) msgs.extend(search_msgs) # Find and use lamp lamp_recep = f"{lamp} 1" call_id = _call_id(step, rng) think = rng.choice(THINK_EXAMINE).format(obj=obj_full, lamp=lamp_recep) action = f"go to {lamp_recep}" obs = make_observation_for_recep(rng, lamp_recep, items_on) msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 call_id = _call_id(step, rng) think = f"Think: I'll turn on the {lamp_recep} to examine the {obj_full}.\nAct: use {lamp_recep}" action = f"use {lamp_recep}" obs = f"You turn on the {lamp_recep}." msgs.append(_assistant(think, action, call_id)) msgs.append(_tool(call_id, obs)) return {"messages": msgs, "tools": TOOLS_DEFINITION, "metadata": {"task_type": "examine", "trajectory_outcome": "success", "synthetic": True, "generator_version": "v2.0"}} def generate_pick_two(rng, idx): obj = rng.choice(OBJECTS["pickable"]) target_type = rng.choice(PLACEMENT_TARGETS) room_key = rng.choice(["kitchen_large", "kitchen_medium", "bedroom_large", "livingroom"]) items_on, room_desc, recep_names = generate_room_v2( rng, room_key, ensure_objects=[obj, obj], ensure_receptacles=[target_type] ) target_recep = f"{target_type} 1" if f"{target_type} 1" in recep_names else \ next((r for r in recep_names if r.startswith(target_type)), f"{target_type} 1") goal = f"Your task is to: find two {obj}s and put them in {target_type}." msgs = [_sys(), _user(f"{room_desc}\n{goal}")] # First object search_msgs, found_recep, obj_full, obj_id, step = generate_search_trajectory( rng, obj, items_on, recep_names, start_step=1 ) msgs.extend(search_msgs) msgs, step = _go_and_place(rng, msgs, step, obj_full, target_recep, items_on) # Second object - different instance obj_id2 = obj_id + 1 if obj_id < 3 else 1 avail = [r for r in recep_names if r != found_recep and r != target_recep] if not avail: avail = [r for r in recep_names if r != found_recep] second_recep = rng.choice(avail[:8]) items_on.setdefault(second_recep, []).append((obj, obj_id2)) call_id = _call_id(step, rng) think = rng.choice(THINK_PICK_SECOND).format(obj=obj, recep=target_recep) action = f"go to {second_recep}" obs = make_observation_for_recep(rng, second_recep, items_on) msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 obj_full2 = f"{obj} {obj_id2}" call_id = _call_id(step, rng) think = rng.choice(THINK_FOUND_OBJECT).format(obj=obj, recep=second_recep, id=obj_id2) action = f"take {obj_full2} from {second_recep}" obs = f"You pick up the {obj_full2} from the {second_recep}." msgs.append(_assistant(think + f"\nAct: {action}", action, call_id)) msgs.append(_tool(call_id, obs)) step += 1 msgs, step = _go_and_place(rng, msgs, step, obj_full2, target_recep, items_on) return {"messages": msgs, "tools": TOOLS_DEFINITION, "metadata": {"task_type": "pick_two", "trajectory_outcome": "success", "synthetic": True, "generator_version": "v2.0"}} # ============================================================ # メイン # ============================================================ GENERATORS = { "pick_and_place": generate_pick_and_place, "examine": generate_examine, "clean_and_place": generate_clean_and_place, "heat_and_place": generate_heat_and_place, "cool_and_place": generate_cool_and_place, "pick_two": generate_pick_two, } def validate_sample(sample): msgs = sample.get("messages", []) if len(msgs) < 4: return False roles = {m.get("role") for m in msgs} if not {"system", "user", "assistant", "tool"}.issubset(roles): return False # Think/Act一致チェック for m in msgs: if m.get("role") == "assistant" and m.get("tool_calls"): content = m.get("content", "") if "Think:" not in content: return False tc_action = json.loads(m["tool_calls"][0]["function"]["arguments"])["action"] act_lines = [l.replace("Act:", "").strip() for l in content.split("\n") if l.strip().startswith("Act:")] if act_lines and act_lines[-1] != tc_action: return False return True def main(): parser = argparse.ArgumentParser(description="ALFWorld 合成トラジェクトリ生成 v2") parser.add_argument("--output", "-o", default="synthetic_alfworld_v2.jsonl") parser.add_argument("--count", "-n", type=int, default=3000) parser.add_argument("--seed", "-s", type=int, default=42) parser.add_argument("--pick_and_place", type=int, default=None) parser.add_argument("--examine", type=int, default=None) parser.add_argument("--clean_and_place", type=int, default=None) parser.add_argument("--heat_and_place", type=int, default=None) parser.add_argument("--cool_and_place", type=int, default=None) parser.add_argument("--pick_two", type=int, default=None) parser.add_argument("--focus-weak", action="store_true") args = parser.parse_args() task_specific = { "pick_and_place": args.pick_and_place, "examine": args.examine, "clean_and_place": args.clean_and_place, "heat_and_place": args.heat_and_place, "cool_and_place": args.cool_and_place, "pick_two": args.pick_two, } if any(v is not None for v in task_specific.values()): counts = {k: (v if v is not None else 0) for k, v in task_specific.items()} elif args.focus_weak: total = args.count weak_each = int(total * 0.2) strong_each = int(total * 0.1) counts = { "pick_and_place": strong_each, "examine": weak_each, "clean_and_place": weak_each, "heat_and_place": weak_each, "cool_and_place": weak_each, "pick_two": strong_each, } else: per_task = args.count // 6 counts = {t: per_task for t in GENERATORS} for i, t in enumerate(["clean_and_place", "heat_and_place", "cool_and_place", "examine"]): if i < args.count % 6: counts[t] += 1 total = sum(counts.values()) print(f"=== ALFWorld 合成データ生成 v2 ===") for t, c in counts.items(): print(f" {t}: {c} ({c/total*100:.1f}%)") print(f" 合計: {total}, seed: {args.seed}") print() rng = random.Random(args.seed) dataset = [] for task_type, count in counts.items(): gen = GENERATORS[task_type] print(f"Generating {count} {task_type}...") for i in range(count): try: dataset.append(gen(rng, i)) except Exception as e: print(f" WARN: {task_type} #{i}: {e}") rng.shuffle(dataset) valid = [s for s in dataset if validate_sample(s)] print(f"\n有効: {len(valid)}/{len(dataset)}") # 統計 from collections import Counter print("\nタスク分布:") for t, c in sorted(Counter(s["metadata"]["task_type"] for s in valid).items()): print(f" {t}: {c}") # go to の探索先レセプタクル分布 go_targets = Counter() go_target_types = Counter() for s in valid: for m in s["messages"]: if m.get("role") == "assistant" and m.get("tool_calls"): act = json.loads(m["tool_calls"][0]["function"]["arguments"])["action"] if act.startswith("go to "): target = act[6:] go_targets[target] += 1 go_target_types[target.rsplit(" ", 1)[0]] += 1 print(f"\ngo to ターゲット（タイプ別 top 15）:") for t, c in go_target_types.most_common(15): print(f" {t}: {c}") print(f"\ngo to ターゲット（具体名 top 20）:") for t, c in go_targets.most_common(20): print(f" {t}: {c}") # ユニークなgo toターゲット数 print(f"\nユニークな go to ターゲット数: {len(go_targets)}") msg_lens = [len(s["messages"]) for s in valid] print(f"メッセージ数: min={min(msg_lens)}, max={max(msg_lens)}, avg={sum(msg_lens)/len(msg_lens):.1f}") with open(args.output, "w", encoding="utf-8") as f: for s in valid: f.write(json.dumps(s, ensure_ascii=False) + "\n") print(f"\n{args.output} に {len(valid)} 件を書き出しました。") if __name__ == "__main__": main()