synth-ai 0.2.4.dev4__py3-none-any.whl → 0.2.4.dev5__py3-none-any.whl

synth_ai/environments/examples/crafter_custom/crafter/recorder.py

@@ -0,0 +1,187 @@
+import datetime
+import json
+import pathlib
+
+import imageio
+import numpy as np
+
+
+class Recorder:
+    def __init__(
+        self,
+        env,
+        directory,
+        save_stats=True,
+        save_video=True,
+        save_episode=True,
+        video_size=(512, 512),
+    ):
+        if directory and save_stats:
+            env = StatsRecorder(env, directory)
+        if directory and save_video:
+            env = VideoRecorder(env, directory, video_size)
+        if directory and save_episode:
+            env = EpisodeRecorder(env, directory)
+        self._env = env
+
+    def __getattr__(self, name):
+        if name.startswith("__"):
+            raise AttributeError(name)
+        return getattr(self._env, name)
+
+
+class StatsRecorder:
+    def __init__(self, env, directory):
+        self._env = env
+        self._directory = pathlib.Path(directory).expanduser()
+        self._directory.mkdir(exist_ok=True, parents=True)
+        self._file = (self._directory / "stats.jsonl").open("a")
+        self._length = None
+        self._reward = None
+        self._unlocked = None
+        self._stats = None
+
+    def __getattr__(self, name):
+        if name.startswith("__"):
+            raise AttributeError(name)
+        return getattr(self._env, name)
+
+    def reset(self):
+        obs = self._env.reset()
+        self._length = 0
+        self._reward = 0
+        self._unlocked = None
+        self._stats = None
+        return obs
+
+    def step(self, action):
+        obs, reward, done, info = self._env.step(action)
+        self._length += 1
+        self._reward += info["reward"]
+        if done:
+            self._stats = {"length": self._length, "reward": round(self._reward, 1)}
+            for key, value in info["achievements"].items():
+                self._stats[f"achievement_{key}"] = value
+            self._save()
+        return obs, reward, done, info
+
+    def _save(self):
+        self._file.write(json.dumps(self._stats) + "\n")
+        self._file.flush()
+
+
+class VideoRecorder:
+    def __init__(self, env, directory, size=(512, 512)):
+        if not hasattr(env, "episode_name"):
+            env = EpisodeName(env)
+        self._env = env
+        self._directory = pathlib.Path(directory).expanduser()
+        self._directory.mkdir(exist_ok=True, parents=True)
+        self._size = size
+        self._frames = None
+
+    def __getattr__(self, name):
+        if name.startswith("__"):
+            raise AttributeError(name)
+        return getattr(self._env, name)
+
+    def reset(self):
+        obs = self._env.reset()
+        self._frames = [self._env.render(self._size)]
+        return obs
+
+    def step(self, action):
+        obs, reward, done, info = self._env.step(action)
+        self._frames.append(self._env.render(self._size))
+        if done:
+            self._save()
+        return obs, reward, done, info
+
+    def _save(self):
+        filename = str(self._directory / (self._env.episode_name + ".mp4"))
+        imageio.mimsave(filename, self._frames)
+
+
+class EpisodeRecorder:
+    def __init__(self, env, directory):
+        if not hasattr(env, "episode_name"):
+            env = EpisodeName(env)
+        self._env = env
+        self._directory = pathlib.Path(directory).expanduser()
+        self._directory.mkdir(exist_ok=True, parents=True)
+        self._episode = None
+
+    def __getattr__(self, name):
+        if name.startswith("__"):
+            raise AttributeError(name)
+        return getattr(self._env, name)
+
+    def reset(self):
+        obs = self._env.reset()
+        self._episode = [{"image": obs}]
+        return obs
+
+    def step(self, action):
+        # Transitions are defined from the environment perspective, meaning that a
+        # transition contains the action and the resulting reward and next
+        # observation produced by the environment in response to said action.
+        obs, reward, done, info = self._env.step(action)
+        transition = {
+            "action": action,
+            "image": obs,
+            "reward": reward,
+            "done": done,
+        }
+        for key, value in info.items():
+            if key in ("inventory", "achievements"):
+                continue
+            transition[key] = value
+        for key, value in info["achievements"].items():
+            transition[f"achievement_{key}"] = value
+        for key, value in info["inventory"].items():
+            transition[f"ainventory_{key}"] = value
+        self._episode.append(transition)
+        if done:
+            self._save()
+        return obs, reward, done, info
+
+    def _save(self):
+        filename = str(self._directory / (self._env.episode_name + ".npz"))
+        # Fill in zeros for keys missing at the first time step.
+        for key, value in self._episode[1].items():
+            if key not in self._episode[0]:
+                self._episode[0][key] = np.zeros_like(value)
+        episode = {k: np.array([step[k] for step in self._episode]) for k in self._episode[0]}
+        np.savez_compressed(filename, **episode)
+
+
+class EpisodeName:
+    def __init__(self, env):
+        self._env = env
+        self._timestamp = None
+        self._unlocked = None
+        self._length = None
+
+    def __getattr__(self, name):
+        if name.startswith("__"):
+            raise AttributeError(name)
+        return getattr(self._env, name)
+
+    def reset(self):
+        obs = self._env.reset()
+        self._timestamp = None
+        self._unlocked = None
+        self._length = 0
+        return obs
+
+    def step(self, action):
+        obs, reward, done, info = self._env.step(action)
+        self._length += 1
+        if done:
+            self._timestamp = datetime.datetime.now().strftime("%Y%m%dT%H%M%S")
+            self._unlocked = sum(int(v >= 1) for v in info["achievements"].values())
+        return obs, reward, done, info
+
+    @property
+    def episode_name(self):
+        return f"{self._timestamp}-ach{self._unlocked}-len{self._length}"

synth_ai/environments/examples/crafter_custom/crafter/worldgen.py

@@ -0,0 +1,119 @@
+import functools
+
+import numpy as np
+import opensimplex
+
+from . import constants
+from . import objects
+from .config import WorldGenConfig
+
+
+def generate_world(world, player):
+    simplex = opensimplex.OpenSimplex(seed=world.random.randint(0, 2**31 - 1))
+    tunnels = np.zeros(world.area, bool)
+    for x in range(world.area[0]):
+        for y in range(world.area[1]):
+            _set_material(world, (x, y), player, tunnels, simplex)
+    for x in range(world.area[0]):
+        for y in range(world.area[1]):
+            _set_object(world, (x, y), player, tunnels)
+
+
+def _set_material(world, pos, player, tunnels, simplex):
+    x, y = pos
+    config = getattr(world, "_config", WorldGenConfig())
+    simplex = functools.partial(_simplex, simplex)
+    uniform = world.random.uniform
+
+    # Clear area around spawn
+    dist_from_spawn = np.sqrt((x - player.pos[0]) ** 2 + (y - player.pos[1]) ** 2)
+    start = config.spawn_clear_radius - dist_from_spawn
+    start += 2 * simplex(x, y, 8, 3)
+    start = 1 / (1 + np.exp(-start))
+
+    # Terrain generation
+    water = simplex(x, y, 3, {15: 1, 5: 0.15}, False) + 0.1
+    water -= 2 * start
+    mountain = simplex(x, y, 0, {15: 1, 5: 0.3})
+    mountain -= 4 * start + 0.3 * water
+
+    if start > 0.5:
+        world[x, y] = "grass"
+    elif mountain > config.mountain_threshold:
+        if (simplex(x, y, 6, 7) > 0.15 and mountain > 0.3) or simplex(
+            x, y, 6, 5
+        ) > config.cave_threshold:  # cave
+            world[x, y] = "path"
+        elif simplex(2 * x, y / 5, 7, 3) > 0.4:  # horizonal tunnel
+            world[x, y] = "path"
+            tunnels[x, y] = True
+        elif simplex(x / 5, 2 * y, 7, 3) > 0.4:  # vertical tunnel
+            world[x, y] = "path"
+            tunnels[x, y] = True
+        elif simplex(x, y, 1, 8) > config.coal_threshold and uniform() > (
+            1 - config.coal_probability
+        ):
+            world[x, y] = "coal"
+        elif simplex(x, y, 2, 6) > config.iron_threshold and uniform() > (
+            1 - config.iron_probability
+        ):
+            world[x, y] = "iron"
+        elif mountain > config.diamond_threshold and uniform() > (1 - config.diamond_probability):
+            world[x, y] = "diamond"
+        elif mountain > 0.3 and simplex(x, y, 6, 5) > config.lava_threshold:
+            world[x, y] = "lava"
+        else:
+            world[x, y] = "stone"
+    elif (config.sand_threshold - 0.1) < water <= config.sand_threshold and simplex(
+        x, y, 4, 9
+    ) > -0.2:
+        world[x, y] = "sand"
+    elif config.water_threshold < water:
+        world[x, y] = "water"
+    else:  # grassland
+        if simplex(x, y, 5, 7) > config.tree_threshold and uniform() > (
+            1 - config.tree_probability
+        ):
+            world[x, y] = "tree"
+        else:
+            world[x, y] = "grass"
+
+
+def _set_object(world, pos, player, tunnels):
+    x, y = pos
+    config = getattr(world, "_config", WorldGenConfig())
+    uniform = world.random.uniform
+    dist = np.sqrt((x - player.pos[0]) ** 2 + (y - player.pos[1]) ** 2)
+    material, _ = world[x, y]
+
+    if material not in constants.walkable:
+        pass
+    elif (
+        dist > config.cow_min_distance
+        and material == "grass"
+        and uniform() < config.cow_spawn_probability
+    ):
+        world.add(objects.Cow(world, (x, y)))
+    elif (
+        dist > config.zombie_min_distance
+        and material == "grass"
+        and uniform() < config.zombie_spawn_probability
+    ):
+        world.add(objects.Zombie(world, (x, y), player))
+    elif material == "path" and tunnels[x, y] and uniform() < config.skeleton_spawn_probability:
+        world.add(objects.Skeleton(world, (x, y), player))
+
+
+def _simplex(simplex, x, y, z, sizes, normalize=True):
+    if not isinstance(sizes, dict):
+        sizes = {sizes: 1}
+    value = 0
+    for size, weight in sizes.items():
+        if hasattr(simplex, "noise3d"):
+            noise = simplex.noise3d(x / size, y / size, z)
+        else:
+            noise = simplex.noise3(x / size, y / size, z)
+        value += weight * noise
+    if normalize:
+        value /= sum(sizes.values())
+    return value

synth_ai/environments/examples/crafter_custom/dataset_builder.py

@@ -0,0 +1,373 @@
+#!/usr/bin/env python3
+"""
+Dataset builder for Crafter Custom Environments
+"""
+
+import json
+import uuid
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Any, Dict, Optional, List, Set
+import random
+import gzip
+import pickle
+
+
+@dataclass
+class CrafterTask:
+    """Defines the global task parameters for Crafter"""
+
+    global_premises: str = "You are playing Crafter, a survival game where you collect resources, craft items, and survive."
+    global_constraints: str = "You can only perform actions available in the action space. You must manage health and hunger."
+    global_objectives: str = (
+        "Achieve as many unique achievements as possible to maximize your score."
+    )
+    shared_env_params: Dict[str, Any] = None
+
+    def __post_init__(self):
+        if self.shared_env_params is None:
+            self.shared_env_params = {"render_mode": None, "size": (64, 64)}
+
+
+@dataclass
+class CrafterImpetus:
+    """Instructions for a specific Crafter instance"""
+
+    instructions: str
+    achievement_focus: Optional[List[str]] = None  # Optional list of achievements to prioritize
+
+
+@dataclass
+class CrafterIntent:
+    """Success criteria and evaluation for Crafter"""
+
+    rubric: Dict[str, Any]
+    target_achievements: Optional[List[str]] = None
+    minimum_score: Optional[int] = None
+    gold_trajectories: Optional[List[Dict[str, Any]]] = None
+
+
+@dataclass
+class CrafterMetadata:
+    """Metadata for a Crafter instance"""
+
+    difficulty: str  # easy, normal, hard, peaceful, resource_rich
+    world_seed: int
+    spawn_position: Optional[tuple] = None
+    initial_resources_nearby: Optional[Dict[str, int]] = None
+    initial_entities: Optional[Dict[str, int]] = None
+    config_params: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class SplitInfo:
+    """Train/val/test split information"""
+
+    val_instance_ids: Set[str]
+    test_instance_ids: Set[str]
+    _is_split_defined: bool = True
+
+
+@dataclass
+class CrafterInstance:
+    """A single Crafter environment instance"""
+
+    id: uuid.UUID
+    impetus: CrafterImpetus
+    intent: CrafterIntent
+    metadata: CrafterMetadata
+    is_reproducible: bool = True
+    initial_engine_snapshot: Optional[bytes] = None  # Serialized engine state
+
+
+@dataclass
+class CrafterDataset:
+    """Collection of Crafter instances"""
+
+    name: str
+    description: str
+    instances: List[CrafterInstance]
+    split_info: SplitInfo
+    task: CrafterTask
+
+
+class CrafterDatasetBuilder:
+    """Builds datasets of Crafter instances with various difficulties"""
+
+    DIFFICULTIES = ["easy", "normal", "hard", "peaceful", "resource_rich"]
+
+    # Achievement categories for focused tasks
+    ACHIEVEMENT_CATEGORIES = {
+        "basic_survival": ["collect_coal", "collect_wood", "eat_cow", "collect_sapling"],
+        "tools": ["make_wood_pickaxe", "make_stone_pickaxe", "make_iron_pickaxe"],
+        "combat": ["defeat_zombie", "defeat_skeleton", "make_wood_sword", "make_stone_sword"],
+        "advanced": ["make_iron_sword", "collect_diamond", "place_table", "place_plant"],
+        "exploration": ["collect_stone", "collect_iron", "collect_coal", "drink_water"],
+    }
+
+    def __init__(self, output_dir: Path = None):
+        self.output_dir = output_dir or Path("dataset")
+        self.output_dir.mkdir(exist_ok=True)
+
+    def create_instance(
+        self,
+        difficulty: str,
+        seed: int,
+        impetus_type: str = "general",
+        achievement_focus: Optional[List[str]] = None,
+    ) -> CrafterInstance:
+        """Create a single Crafter instance"""
+
+        # Create impetus based on type
+        if impetus_type == "general":
+            impetus = CrafterImpetus(
+                instructions="Survive and thrive in the Crafter world. Collect resources, craft tools, and achieve as many accomplishments as possible.",
+                achievement_focus=None,
+            )
+            intent = CrafterIntent(
+                rubric={
+                    "description": "General survival and achievement",
+                    "criteria": {
+                        "achievements": "Number of unique achievements unlocked",
+                        "survival_time": "Number of steps survived",
+                        "resource_efficiency": "Efficient use of collected resources",
+                    },
+                },
+                minimum_score=1 if difficulty == "easy" else (3 if difficulty == "normal" else 5),
+            )
+        elif impetus_type == "focused":
+            focus_category = random.choice(list(self.ACHIEVEMENT_CATEGORIES.keys()))
+            achievements = self.ACHIEVEMENT_CATEGORIES[focus_category]
+            impetus = CrafterImpetus(
+                instructions=f"Focus on {focus_category.replace('_', ' ')} achievements. Try to complete: {', '.join(achievements[:3])}",
+                achievement_focus=achievements,
+            )
+            intent = CrafterIntent(
+                rubric={
+                    "description": f"Complete {focus_category} achievements",
+                    "criteria": {
+                        "target_achievements": f"Complete at least one of: {', '.join(achievements[:3])}",
+                        "efficiency": "Complete target achievements quickly",
+                    },
+                },
+                target_achievements=achievements[:3],
+                minimum_score=1,
+            )
+        elif impetus_type == "speedrun":
+            target = random.choice(["place_table", "make_iron_pickaxe", "collect_diamond"])
+            impetus = CrafterImpetus(
+                instructions=f"Speedrun challenge: {target} as quickly as possible!",
+                achievement_focus=[target],
+            )
+            intent = CrafterIntent(
+                rubric={
+                    "description": f"Complete {target} speedrun",
+                    "criteria": {
+                        "completion": f"Successfully {target}",
+                        "speed": "Complete in minimal steps",
+                    },
+                },
+                target_achievements=[target],
+                minimum_score=1,
+            )
+        else:
+            raise ValueError(f"Unknown impetus type: {impetus_type}")
+
+        # Create metadata
+        metadata = CrafterMetadata(
+            difficulty=difficulty,
+            world_seed=seed,
+            config_params=self._get_config_params(difficulty),
+        )
+
+        # Create instance
+        instance = CrafterInstance(
+            id=uuid.uuid4(),
+            impetus=impetus,
+            intent=intent,
+            metadata=metadata,
+            is_reproducible=True,
+            initial_engine_snapshot=None,
+        )
+
+        return instance
+
+    def _get_config_params(self, difficulty: str) -> Dict[str, Any]:
+        """Get key config parameters for a difficulty"""
+        # These are simplified summaries - actual configs are in JSON files
+        params = {
+            "easy": {
+                "resource_multiplier": "~2x",
+                "enemy_density": "low",
+                "coal_probability": 0.25,
+                "iron_probability": 0.35,
+                "diamond_probability": 0.02,
+            },
+            "normal": {
+                "resource_multiplier": "1x",
+                "enemy_density": "normal",
+                "coal_probability": 0.15,
+                "iron_probability": 0.25,
+                "diamond_probability": 0.006,
+            },
+            "hard": {
+                "resource_multiplier": "~0.5x",
+                "enemy_density": "high",
+                "coal_probability": 0.08,
+                "iron_probability": 0.15,
+                "diamond_probability": 0.002,
+            },
+            "peaceful": {
+                "resource_multiplier": "~3x",
+                "enemy_density": "none",
+                "coal_probability": 0.30,
+                "iron_probability": 0.40,
+                "diamond_probability": 0.03,
+            },
+            "resource_rich": {
+                "resource_multiplier": "~8x",
+                "enemy_density": "minimal",
+                "coal_probability": 0.60,
+                "iron_probability": 0.70,
+                "diamond_probability": 0.80,
+            },
+        }
+        return params.get(difficulty, {})
+
+    def build_dataset(
+        self,
+        name: str,
+        instances_per_difficulty: Dict[str, int],
+        impetus_distribution: Dict[str, float] = None,
+        val_split: float = 0.2,
+        test_split: float = 0.2,
+    ) -> CrafterDataset:
+        """Build a complete dataset"""
+
+        if impetus_distribution is None:
+            impetus_distribution = {"general": 0.6, "focused": 0.3, "speedrun": 0.1}
+
+        instances = []
+
+        # Create instances for each difficulty
+        for difficulty, count in instances_per_difficulty.items():
+            if difficulty not in self.DIFFICULTIES:
+                raise ValueError(f"Unknown difficulty: {difficulty}")
+
+            for i in range(count):
+                # Generate unique seed
+                seed = random.randint(0, 1000000)
+
+                # Choose impetus type based on distribution
+                impetus_type = random.choices(
+                    list(impetus_distribution.keys()), weights=list(impetus_distribution.values())
+                )[0]
+
+                instance = self.create_instance(
+                    difficulty=difficulty, seed=seed, impetus_type=impetus_type
+                )
+                instances.append(instance)
+
+        # Create splits
+        random.shuffle(instances)
+        n_val = int(len(instances) * val_split)
+        n_test = int(len(instances) * test_split)
+
+        val_ids = {str(inst.id) for inst in instances[:n_val]}
+        test_ids = {str(inst.id) for inst in instances[n_val : n_val + n_test]}
+
+        split_info = SplitInfo(
+            val_instance_ids=val_ids, test_instance_ids=test_ids, _is_split_defined=True
+        )
+
+        # Create dataset
+        dataset = CrafterDataset(
+            name=name,
+            description=f"Crafter dataset with {len(instances)} instances across {len(instances_per_difficulty)} difficulties",
+            instances=instances,
+            split_info=split_info,
+            task=CrafterTask(),
+        )
+
+        return dataset
+
+    def save_dataset(self, dataset: CrafterDataset, format: str = "json"):
+        """Save dataset to disk"""
+        dataset_dir = self.output_dir / dataset.name
+        dataset_dir.mkdir(exist_ok=True)
+
+        if format == "json":
+            # Save metadata
+            metadata = {
+                "name": dataset.name,
+                "description": dataset.description,
+                "num_instances": len(dataset.instances),
+                "task": asdict(dataset.task),
+                "split_info": {
+                    "val_instance_ids": list(dataset.split_info.val_instance_ids),
+                    "test_instance_ids": list(dataset.split_info.test_instance_ids),
+                },
+            }
+            with open(dataset_dir / "metadata.json", "w") as f:
+                json.dump(metadata, f, indent=2)
+
+            # Save instances
+            instances_data = []
+            for inst in dataset.instances:
+                inst_data = {
+                    "id": str(inst.id),
+                    "impetus": asdict(inst.impetus),
+                    "intent": asdict(inst.intent),
+                    "metadata": asdict(inst.metadata),
+                    "is_reproducible": inst.is_reproducible,
+                }
+                instances_data.append(inst_data)
+
+            with open(dataset_dir / "instances.json", "w") as f:
+                json.dump(instances_data, f, indent=2)
+
+        print(f"Dataset saved to {dataset_dir}")
+        print(f"Total instances: {len(dataset.instances)}")
+        print(f"Val instances: {len(dataset.split_info.val_instance_ids)}")
+        print(f"Test instances: {len(dataset.split_info.test_instance_ids)}")
+        print(
+            f"Train instances: {len(dataset.instances) - len(dataset.split_info.val_instance_ids) - len(dataset.split_info.test_instance_ids)}"
+        )
+
+
+def main():
+    """Example usage"""
+    builder = CrafterDatasetBuilder()
+
+    # Build a balanced dataset
+    dataset = builder.build_dataset(
+        name="crafter_balanced_v1",
+        instances_per_difficulty={
+            "easy": 20,
+            "normal": 20,
+            "hard": 20,
+            "peaceful": 10,
+            "resource_rich": 10,
+        },
+        impetus_distribution={"general": 0.6, "focused": 0.3, "speedrun": 0.1},
+    )
+
+    builder.save_dataset(dataset)
+
+    # Build a difficulty progression dataset
+    dataset2 = builder.build_dataset(
+        name="crafter_progression_v1",
+        instances_per_difficulty={
+            "easy": 30,
+            "normal": 25,
+            "hard": 15,
+            "peaceful": 5,
+            "resource_rich": 5,
+        },
+    )
+
+    builder.save_dataset(dataset2)
+
+
+if __name__ == "__main__":
+    main()