synth-ai 0.2.8.dev2__py3-none-any.whl → 0.4.3__py3-none-any.whl

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

@@ -1,187 +0,0 @@
-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

@@ -1,118 +0,0 @@
-import functools
-
-import numpy as np
-import opensimplex
-
-from . import constants, 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

@@ -1,373 +0,0 @@
-#!/usr/bin/env python3
-"""
-Dataset builder for Crafter Custom Environments
-"""
-
-import gzip
-import json
-import pickle
-import random
-import uuid
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Set
-
-
-@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()