{"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain","uri":"program://TinyRecursiveModels/module/pretrain#L1-L654","kind":"module","name":"pretrain","path":"pretrain.py","language":"python","start_line":1,"end_line":654,"context_start_line":1,"context_end_line":654,"code":"from typing import Optional, Any, Sequence, List\nfrom dataclasses import dataclass\nimport os\nimport math\nimport yaml\nimport shutil\nimport copy\n\nimport torch\nimport torch.distributed as dist\nfrom torch import nn\nfrom torch.utils.data import DataLoader\n\nimport tqdm\nimport wandb\nimport coolname\nimport hydra\nimport pydantic\nfrom omegaconf import DictConfig\nfrom adam_atan2 import AdamATan2\n\nfrom puzzle_dataset import PuzzleDataset, PuzzleDatasetConfig, PuzzleDatasetMetadata\nfrom utils.functions import load_model_class, get_model_source_path\nfrom models.sparse_embedding import CastedSparseEmbeddingSignSGD_Distributed\nfrom models.ema import EMAHelper\n\n\nclass LossConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n\n\nclass ArchConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n loss: LossConfig\n\n\nclass EvaluatorConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra=\"allow\")\n name: str\n\n\nclass PretrainConfig(pydantic.BaseModel):\n # Config\n arch: ArchConfig\n # Data\n data_paths: List[str]\n data_paths_test: List[str] = []\n # Evaluators\n evaluators: List[EvaluatorConfig] = []\n\n # Hyperparams\n global_batch_size: int\n epochs: int\n\n lr: float\n lr_min_ratio: float\n lr_warmup_steps: int\n\n weight_decay: float\n beta1: float\n beta2: float\n\n # Puzzle embedding\n puzzle_emb_lr: float\n puzzle_emb_weight_decay: float\n\n # Names\n project_name: Optional[str] = None\n run_name: Optional[str] = None\n load_checkpoint: Optional[str] = None\n checkpoint_path: Optional[str] = None\n\n # Extras\n seed: int = 0\n checkpoint_every_eval: bool = False\n eval_interval: Optional[int] = None\n min_eval_interval: Optional[int] = 0 # when to start eval\n eval_save_outputs: List[str] = []\n\n ema: bool = False # use Exponential-Moving-Average\n ema_rate: float = 0.999 # EMA-rate\n freeze_weights: bool = False # If True, freeze weights and only learn the embeddings\n\n@dataclass\nclass TrainState:\n model: nn.Module\n optimizers: Sequence[torch.optim.Optimizer]\n optimizer_lrs: Sequence[float]\n carry: Any\n\n step: int\n total_steps: int\n\n\ndef create_dataloader(config: PretrainConfig, split: str, rank: int, world_size: int, **kwargs):\n dataset = PuzzleDataset(PuzzleDatasetConfig(\n seed=config.seed,\n dataset_paths=config.data_paths_test if len(config.data_paths_test)>0 and split==\"test\" else config.data_paths,\n rank=rank,\n num_replicas=world_size,\n **kwargs\n ), split=split)\n dataloader = DataLoader(\n dataset,\n batch_size=None,\n num_workers=1,\n prefetch_factor=8,\n pin_memory=True,\n persistent_workers=True\n )\n return dataloader, dataset.metadata\n\n\ndef create_model(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, rank: int, world_size: int):\n model_cfg = dict(\n **config.arch.__pydantic_extra__, # type: ignore\n batch_size=config.global_batch_size // world_size,\n vocab_size=train_metadata.vocab_size,\n seq_len=train_metadata.seq_len,\n num_puzzle_identifiers=train_metadata.num_puzzle_identifiers,\n causal=False # Non-autoregressive\n )\n\n # Instantiate model with loss head\n model_cls = load_model_class(config.arch.name)\n loss_head_cls = load_model_class(config.arch.loss.name)\n\n with torch.device(\"cuda\"):\n model: nn.Module = model_cls(model_cfg)\n print(model)\n model = loss_head_cls(model, **config.arch.loss.__pydantic_extra__) # type: ignore\n if \"DISABLE_COMPILE\" not in os.environ:\n model = torch.compile(model) # type: ignore\n\n # Load checkpoint\n if rank == 0:\n load_checkpoint(model, config)\n\n # Broadcast parameters from rank 0\n if world_size > 1:\n with torch.no_grad():\n for param in list(model.parameters()) + list(model.buffers()):\n dist.broadcast(param, src=0)\n\n # Optimizers and lr\n if config.arch.puzzle_emb_ndim == 0:\n optimizers = [\n AdamATan2(\n model.parameters(),\n lr=0, # Needs to be set by scheduler\n weight_decay=config.weight_decay,\n betas=(config.beta1, config.beta2)\n )\n ]\n optimizer_lrs = [\n config.lr\n ]\n elif config.freeze_weights:\n optimizers = [\n CastedSparseEmbeddingSignSGD_Distributed(\n model.model.puzzle_emb.buffers(), # type: ignore\n lr=0, # Needs to be set by scheduler\n weight_decay=config.puzzle_emb_weight_decay,\n world_size=world_size\n )\n ]\n optimizer_lrs = [\n config.puzzle_emb_lr\n ]\n else:\n optimizers = [\n CastedSparseEmbeddingSignSGD_Distributed(\n model.model.puzzle_emb.buffers(), # type: ignore\n lr=0, # Needs to be set by scheduler\n weight_decay=config.puzzle_emb_weight_decay,\n world_size=world_size\n ),\n AdamATan2(\n model.parameters(),\n lr=0, # Needs to be set by scheduler\n weight_decay=config.weight_decay,\n betas=(config.beta1, config.beta2)\n )\n ]\n optimizer_lrs = [\n config.puzzle_emb_lr,\n config.lr\n ]\n\n return model, optimizers, optimizer_lrs\n\ndef mix_weights_direct(device, alpha, net, nets):\n sd = []\n for i in range(len(nets)):\n sd += [nets[i].state_dict()]\n sd_alpha = {}\n for k in sd[0].keys():\n comb_net = alpha[0]*sd[0][k].to(device)\n for i in range(1,len(nets)):\n comb_net += alpha[i]*sd[i][k].to(device)\n sd_alpha[k] = comb_net\n net.load_state_dict(sd_alpha)\n return net\n\ndef cosine_schedule_with_warmup_lr_lambda(\n current_step: int, *, base_lr: float, num_warmup_steps: int, num_training_steps: int, min_ratio: float = 0.0, num_cycles: float = 0.5\n):\n if current_step < num_warmup_steps:\n return base_lr * float(current_step) / float(max(1, num_warmup_steps))\n\n progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))\n return base_lr * (min_ratio + max(0.0, (1 - min_ratio) * 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress))))\n\n\ndef init_train_state(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, rank: int, world_size: int):\n # Estimated total training steps\n total_steps = int(config.epochs * train_metadata.total_groups * train_metadata.mean_puzzle_examples / config.global_batch_size)\n\n # Model\n model, optimizers, optimizer_lrs = create_model(config, train_metadata, rank=rank, world_size=world_size)\n\n return TrainState(\n step=0,\n total_steps=total_steps,\n\n model=model,\n optimizers=optimizers,\n optimizer_lrs=optimizer_lrs,\n carry=None\n )\n\n\ndef save_train_state(config: PretrainConfig, train_state: TrainState):\n # FIXME: Only saved model.\n if config.checkpoint_path is None:\n return\n\n os.makedirs(config.checkpoint_path, exist_ok=True)\n torch.save(train_state.model.state_dict(), os.path.join(config.checkpoint_path, f\"step_{train_state.step}\"))\n\n\ndef load_checkpoint(model: nn.Module, config: PretrainConfig):\n if config.load_checkpoint is not None:\n print(f\"Loading checkpoint {config.load_checkpoint}\")\n\n # Load state dict\n state_dict = torch.load(config.load_checkpoint, map_location=\"cuda\")\n\n # Resize and reset puzzle emb if needed\n puzzle_emb_name = \"_orig_mod.model.inner.puzzle_emb.weights\"\n expected_shape: torch.Size = model.model.puzzle_emb.weights.shape # type: ignore\n if puzzle_emb_name in state_dict:\n puzzle_emb = state_dict[puzzle_emb_name]\n if puzzle_emb.shape != expected_shape:\n print(f\"Resetting puzzle embedding as shape is different. Found {puzzle_emb.shape}, Expected {expected_shape}\")\n # Re-initialize using mean\n state_dict[puzzle_emb_name] = (\n torch.mean(puzzle_emb, dim=0, keepdim=True).expand(expected_shape).contiguous()\n )\n model.load_state_dict(state_dict, assign=True)\n\n\ndef compute_lr(base_lr: float, config: PretrainConfig, train_state: TrainState):\n return cosine_schedule_with_warmup_lr_lambda(\n current_step=train_state.step,\n base_lr=base_lr,\n num_warmup_steps=round(config.lr_warmup_steps),\n num_training_steps=train_state.total_steps,\n min_ratio=config.lr_min_ratio\n )\n\n\n\ndef create_evaluators(config: PretrainConfig, eval_metadata: PuzzleDatasetMetadata) -> List[Any]:\n data_paths =config.data_paths_test if len(config.data_paths_test)>0 else config.data_paths\n # Initialize evaluators\n evaluators = []\n for cfg in config.evaluators:\n for data_path in data_paths:\n cls = load_model_class(cfg.name, \"evaluators.\")(\n data_path=data_path, eval_metadata=eval_metadata, **cfg.__pydantic_extra__\n ) # type: ignore\n evaluators.append(cls)\n\n return evaluators\n\ndef train_batch(config: PretrainConfig, train_state: TrainState, batch: Any, global_batch_size: int, rank: int, world_size: int):\n train_state.step += 1\n if train_state.step > train_state.total_steps: # At most train_total_steps\n return\n\n # To device\n batch = {k: v.cuda() for k, v in batch.items()}\n\n # Init carry if it is None\n if train_state.carry is None:\n with torch.device(\"cuda\"):\n train_state.carry = train_state.model.initial_carry(batch) # type: ignore\n\n # Forward\n train_state.carry, loss, metrics, _, _ = train_state.model(carry=train_state.carry, batch=batch, return_keys=[])\n\n ((1 / global_batch_size) * loss).backward()\n\n # Allreduce\n if world_size > 1:\n for param in train_state.model.parameters():\n if param.grad is not None:\n dist.all_reduce(param.grad)\n \n # Apply optimizer\n lr_this_step = None \n for optim, base_lr in zip(train_state.optimizers, train_state.optimizer_lrs):\n lr_this_step = compute_lr(base_lr, config, train_state)\n\n for param_group in optim.param_groups:\n param_group['lr'] = lr_this_step\n \n optim.step()\n optim.zero_grad()\n\n # Reduce metrics\n if len(metrics):\n assert not any(v.requires_grad for v in metrics.values())\n\n metric_keys = list(sorted(metrics.keys())) # Sort keys to guarantee all processes use the same order.\n # Reduce and reconstruct\n metric_values = torch.stack([metrics[k] for k in metric_keys])\n if world_size > 1:\n dist.reduce(metric_values, dst=0)\n\n if rank == 0:\n metric_values = metric_values.cpu().numpy()\n reduced_metrics = {k: metric_values[i] for i, k in enumerate(metric_keys)}\n \n # Postprocess\n count = max(reduced_metrics[\"count\"], 1) # Avoid NaNs\n reduced_metrics = {f\"train/{k}\": v / (global_batch_size if k.endswith(\"loss\") else count) for k, v in reduced_metrics.items()}\n\n reduced_metrics[\"train/lr\"] = lr_this_step\n return reduced_metrics\n\ndef evaluate(\n config: PretrainConfig,\n train_state: TrainState,\n eval_loader: torch.utils.data.DataLoader,\n eval_metadata: PuzzleDatasetMetadata,\n evaluators: List[Any],\n rank: int,\n world_size: int,\n cpu_group: Optional[dist.ProcessGroup],\n):\n reduced_metrics = None\n\n with torch.inference_mode():\n return_keys = set(config.eval_save_outputs)\n for evaluator in evaluators:\n evaluator.begin_eval()\n return_keys.update(evaluator.required_outputs)\n\n # Run evaluation\n set_ids = {k: idx for idx, k in enumerate(eval_metadata.sets)}\n\n save_preds = {}\n\n metric_keys = []\n metric_values = None\n\n carry = None\n processed_batches = 0\n \n for set_name, batch, global_batch_size in eval_loader:\n processed_batches += 1\n if rank == 0:\n print(f\"Processing batch {processed_batches}: {set_name}\")\n \n # To device\n batch = {k: v.cuda() for k, v in batch.items()}\n with torch.device(\"cuda\"):\n carry = train_state.model.initial_carry(batch) # type: ignore\n\n # Forward\n inference_steps = 0\n while True:\n carry, loss, metrics, preds, all_finish = train_state.model(\n carry=carry, batch=batch, return_keys=return_keys\n )\n inference_steps += 1\n\n if all_finish:\n break\n\n if rank == 0:\n print(f\" Completed inference in {inference_steps} steps\")\n\n for collection in (batch, preds):\n for k, v in collection.items():\n if k in config.eval_save_outputs:\n save_preds.setdefault(k, [])\n save_preds[k].append(v.cpu()) # Move to CPU for saving GPU memory\n\n for evaluator in evaluators:\n evaluator.update_batch(batch, preds)\n\n del carry, loss, preds, batch, all_finish\n\n # Aggregate metrics\n set_id = set_ids[set_name]\n\n if metric_values is None:\n metric_keys = list(\n sorted(metrics.keys())\n ) # Sort keys to guarantee all processes use the same order.\n metric_values = torch.zeros(\n (len(set_ids), len(metrics.values())), dtype=torch.float32, device=\"cuda\"\n )\n\n metric_values[set_id] += torch.stack([metrics[k] for k in metric_keys])\n\n del metrics\n\n # concatenate save preds\n save_preds = {k: torch.cat(v, dim=0) for k, v in save_preds.items()}\n\n # Save preds\n if config.checkpoint_path is not None and len(save_preds):\n # Each rank save predictions independently\n os.makedirs(os.path.dirname(config.checkpoint_path), exist_ok=True)\n torch.save(\n save_preds, os.path.join(config.checkpoint_path, f\"step_{train_state.step}_all_preds.{rank}\")\n )\n\n del save_preds\n\n # Reduce to rank 0\n if metric_values is not None:\n if world_size > 1:\n dist.reduce(metric_values, dst=0)\n\n if rank == 0:\n reduced_metrics = metric_values.cpu().numpy()\n reduced_metrics = {\n set_name: {\n metric_name: reduced_metrics[set_id, metric_id]\n for metric_id, metric_name in enumerate(metric_keys)\n }\n for set_id, set_name in enumerate(set_ids)\n }\n\n # Postprocess\n for set_name, m in reduced_metrics.items():\n count = m.pop(\"count\")\n reduced_metrics[set_name] = {k: v / count for k, v in m.items()}\n\n # Run evaluators\n if rank == 0:\n print(f\"\\nRunning {len(evaluators)} evaluator(s)...\")\n \n for i, evaluator in enumerate(evaluators):\n if rank == 0:\n print(f\"Running evaluator {i+1}/{len(evaluators)}: {evaluator.__class__.__name__}\")\n \n # Path for saving\n evaluator_save_path = None\n if config.checkpoint_path is not None:\n evaluator_save_path = os.path.join(\n config.checkpoint_path,\n f\"evaluator_{evaluator.__class__.__name__}_step_{train_state.step}\",\n )\n os.makedirs(evaluator_save_path, exist_ok=True)\n\n # Run and log\n metrics = evaluator.result(evaluator_save_path, rank=rank, world_size=world_size, group=cpu_group)\n if rank == 0 and metrics is not None:\n if reduced_metrics is None:\n reduced_metrics = {}\n\n reduced_metrics.update(metrics)\n print(f\" Completed {evaluator.__class__.__name__}\")\n \n if rank == 0:\n print(\"All evaluators completed!\")\n\n return reduced_metrics\n\ndef save_code_and_config(config: PretrainConfig):\n if config.checkpoint_path is None or wandb.run is None:\n return\n\n os.makedirs(config.checkpoint_path, exist_ok=True)\n\n # Copy code\n code_list = [\n get_model_source_path(config.arch.name),\n get_model_source_path(config.arch.loss.name)\n ]\n for code_file in code_list:\n if code_file is not None:\n code_name = os.path.basename(code_file)\n\n shutil.copy(code_file, os.path.join(config.checkpoint_path, code_name))\n\n # Dump config as yaml\n config_file = os.path.join(config.checkpoint_path, \"all_config.yaml\")\n with open(config_file, \"wt\") as f:\n yaml.dump(config.model_dump(), f)\n\n # Log code\n wandb.run.log_code(config.checkpoint_path)\n\n\ndef load_synced_config(hydra_config: DictConfig, rank: int, world_size: int) -> PretrainConfig:\n objects = [None]\n if rank == 0:\n config = PretrainConfig(**hydra_config) # type: ignore\n\n # Naming\n if config.project_name is None:\n config.project_name = f\"{os.path.basename(config.data_paths[0]).capitalize()}-ACT-torch\"\n if config.run_name is None:\n config.run_name = f\"{config.arch.name.split('@')[-1]} {coolname.generate_slug(2)}\"\n if config.checkpoint_path is None:\n config.checkpoint_path = os.path.join(\"checkpoints\", config.project_name, config.run_name)\n\n objects = [config]\n\n if world_size > 1:\n dist.broadcast_object_list(objects, src=0)\n\n return objects[0] # type: ignore\n\n\n@hydra.main(config_path=\"config\", config_name=\"cfg_pretrain\", version_base=None)\ndef launch(hydra_config: DictConfig):\n RANK = 0\n WORLD_SIZE = 1\n CPU_PROCESS_GROUP = None\n\n # Initialize distributed training if in distributed environment (e.g. torchrun)\n if \"LOCAL_RANK\" in os.environ:\n # Initialize distributed, default device and dtype\n dist.init_process_group(backend=\"nccl\")\n\n RANK = dist.get_rank()\n WORLD_SIZE = dist.get_world_size()\n\n torch.cuda.set_device(int(os.environ[\"LOCAL_RANK\"]))\n \n # CPU GLOO process group\n CPU_PROCESS_GROUP = dist.new_group(backend=\"gloo\")\n assert (\n dist.get_rank(CPU_PROCESS_GROUP) == RANK and dist.get_world_size(CPU_PROCESS_GROUP) == WORLD_SIZE\n )\n\n # Load sync'ed config\n config = load_synced_config(hydra_config, rank=RANK, world_size=WORLD_SIZE)\n\n # Seed RNGs to ensure consistency\n torch.random.manual_seed(config.seed + RANK)\n\n # Dataset\n train_epochs_per_iter = config.eval_interval if config.eval_interval is not None else config.epochs\n total_iters = config.epochs // train_epochs_per_iter\n\n assert config.epochs % train_epochs_per_iter == 0, \"Eval interval must be a divisor of total epochs.\"\n\n train_loader, train_metadata = create_dataloader(config, \"train\", test_set_mode=False, epochs_per_iter=train_epochs_per_iter, global_batch_size=config.global_batch_size, rank=RANK, world_size=WORLD_SIZE)\n try:\n eval_loader, eval_metadata = create_dataloader(config, \"test\", test_set_mode=True, epochs_per_iter=1, global_batch_size=config.global_batch_size, rank=RANK, world_size=WORLD_SIZE)\n except:\n print(\"NO EVAL DATA FOUND\")\n eval_loader = eval_metadata = None\n\n try:\n evaluators = create_evaluators(config, eval_metadata)\n except:\n print(\"No evaluator found\")\n# ... truncated ...","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":true} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.LossConfig","uri":"program://TinyRecursiveModels/class/pretrain.LossConfig#L28-L30","kind":"class","name":"LossConfig","path":"pretrain.py","language":"python","start_line":28,"end_line":30,"context_start_line":8,"context_end_line":50,"code":"\nimport torch\nimport torch.distributed as dist\nfrom torch import nn\nfrom torch.utils.data import DataLoader\n\nimport tqdm\nimport wandb\nimport coolname\nimport hydra\nimport pydantic\nfrom omegaconf import DictConfig\nfrom adam_atan2 import AdamATan2\n\nfrom puzzle_dataset import PuzzleDataset, PuzzleDatasetConfig, PuzzleDatasetMetadata\nfrom utils.functions import load_model_class, get_model_source_path\nfrom models.sparse_embedding import CastedSparseEmbeddingSignSGD_Distributed\nfrom models.ema import EMAHelper\n\n\nclass LossConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n\n\nclass ArchConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n loss: LossConfig\n\n\nclass EvaluatorConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra=\"allow\")\n name: str\n\n\nclass PretrainConfig(pydantic.BaseModel):\n # Config\n arch: ArchConfig\n # Data\n data_paths: List[str]\n data_paths_test: List[str] = []\n # Evaluators","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.ArchConfig","uri":"program://TinyRecursiveModels/class/pretrain.ArchConfig#L33-L36","kind":"class","name":"ArchConfig","path":"pretrain.py","language":"python","start_line":33,"end_line":36,"context_start_line":13,"context_end_line":56,"code":"\nimport tqdm\nimport wandb\nimport coolname\nimport hydra\nimport pydantic\nfrom omegaconf import DictConfig\nfrom adam_atan2 import AdamATan2\n\nfrom puzzle_dataset import PuzzleDataset, PuzzleDatasetConfig, PuzzleDatasetMetadata\nfrom utils.functions import load_model_class, get_model_source_path\nfrom models.sparse_embedding import CastedSparseEmbeddingSignSGD_Distributed\nfrom models.ema import EMAHelper\n\n\nclass LossConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n\n\nclass ArchConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n loss: LossConfig\n\n\nclass EvaluatorConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra=\"allow\")\n name: str\n\n\nclass PretrainConfig(pydantic.BaseModel):\n # Config\n arch: ArchConfig\n # Data\n data_paths: List[str]\n data_paths_test: List[str] = []\n # Evaluators\n evaluators: List[EvaluatorConfig] = []\n\n # Hyperparams\n global_batch_size: int\n epochs: int\n","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.EvaluatorConfig","uri":"program://TinyRecursiveModels/class/pretrain.EvaluatorConfig#L39-L41","kind":"class","name":"EvaluatorConfig","path":"pretrain.py","language":"python","start_line":39,"end_line":41,"context_start_line":19,"context_end_line":61,"code":"from omegaconf import DictConfig\nfrom adam_atan2 import AdamATan2\n\nfrom puzzle_dataset import PuzzleDataset, PuzzleDatasetConfig, PuzzleDatasetMetadata\nfrom utils.functions import load_model_class, get_model_source_path\nfrom models.sparse_embedding import CastedSparseEmbeddingSignSGD_Distributed\nfrom models.ema import EMAHelper\n\n\nclass LossConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n\n\nclass ArchConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n loss: LossConfig\n\n\nclass EvaluatorConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra=\"allow\")\n name: str\n\n\nclass PretrainConfig(pydantic.BaseModel):\n # Config\n arch: ArchConfig\n # Data\n data_paths: List[str]\n data_paths_test: List[str] = []\n # Evaluators\n evaluators: List[EvaluatorConfig] = []\n\n # Hyperparams\n global_batch_size: int\n epochs: int\n\n lr: float\n lr_min_ratio: float\n lr_warmup_steps: int\n\n weight_decay: float","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.PretrainConfig","uri":"program://TinyRecursiveModels/class/pretrain.PretrainConfig#L44-L84","kind":"class","name":"PretrainConfig","path":"pretrain.py","language":"python","start_line":44,"end_line":84,"context_start_line":24,"context_end_line":104,"code":"from models.sparse_embedding import CastedSparseEmbeddingSignSGD_Distributed\nfrom models.ema import EMAHelper\n\n\nclass LossConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n\n\nclass ArchConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra='allow')\n name: str\n loss: LossConfig\n\n\nclass EvaluatorConfig(pydantic.BaseModel):\n model_config = pydantic.ConfigDict(extra=\"allow\")\n name: str\n\n\nclass PretrainConfig(pydantic.BaseModel):\n # Config\n arch: ArchConfig\n # Data\n data_paths: List[str]\n data_paths_test: List[str] = []\n # Evaluators\n evaluators: List[EvaluatorConfig] = []\n\n # Hyperparams\n global_batch_size: int\n epochs: int\n\n lr: float\n lr_min_ratio: float\n lr_warmup_steps: int\n\n weight_decay: float\n beta1: float\n beta2: float\n\n # Puzzle embedding\n puzzle_emb_lr: float\n puzzle_emb_weight_decay: float\n\n # Names\n project_name: Optional[str] = None\n run_name: Optional[str] = None\n load_checkpoint: Optional[str] = None\n checkpoint_path: Optional[str] = None\n\n # Extras\n seed: int = 0\n checkpoint_every_eval: bool = False\n eval_interval: Optional[int] = None\n min_eval_interval: Optional[int] = 0 # when to start eval\n eval_save_outputs: List[str] = []\n\n ema: bool = False # use Exponential-Moving-Average\n ema_rate: float = 0.999 # EMA-rate\n freeze_weights: bool = False # If True, freeze weights and only learn the embeddings\n\n@dataclass\nclass TrainState:\n model: nn.Module\n optimizers: Sequence[torch.optim.Optimizer]\n optimizer_lrs: Sequence[float]\n carry: Any\n\n step: int\n total_steps: int\n\n\ndef create_dataloader(config: PretrainConfig, split: str, rank: int, world_size: int, **kwargs):\n dataset = PuzzleDataset(PuzzleDatasetConfig(\n seed=config.seed,\n dataset_paths=config.data_paths_test if len(config.data_paths_test)>0 and split==\"test\" else config.data_paths,\n rank=rank,\n num_replicas=world_size,\n **kwargs\n ), split=split)","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.TrainState","uri":"program://TinyRecursiveModels/class/pretrain.TrainState#L87-L94","kind":"class","name":"TrainState","path":"pretrain.py","language":"python","start_line":87,"end_line":94,"context_start_line":67,"context_end_line":114,"code":" puzzle_emb_weight_decay: float\n\n # Names\n project_name: Optional[str] = None\n run_name: Optional[str] = None\n load_checkpoint: Optional[str] = None\n checkpoint_path: Optional[str] = None\n\n # Extras\n seed: int = 0\n checkpoint_every_eval: bool = False\n eval_interval: Optional[int] = None\n min_eval_interval: Optional[int] = 0 # when to start eval\n eval_save_outputs: List[str] = []\n\n ema: bool = False # use Exponential-Moving-Average\n ema_rate: float = 0.999 # EMA-rate\n freeze_weights: bool = False # If True, freeze weights and only learn the embeddings\n\n@dataclass\nclass TrainState:\n model: nn.Module\n optimizers: Sequence[torch.optim.Optimizer]\n optimizer_lrs: Sequence[float]\n carry: Any\n\n step: int\n total_steps: int\n\n\ndef create_dataloader(config: PretrainConfig, split: str, rank: int, world_size: int, **kwargs):\n dataset = PuzzleDataset(PuzzleDatasetConfig(\n seed=config.seed,\n dataset_paths=config.data_paths_test if len(config.data_paths_test)>0 and split==\"test\" else config.data_paths,\n rank=rank,\n num_replicas=world_size,\n **kwargs\n ), split=split)\n dataloader = DataLoader(\n dataset,\n batch_size=None,\n num_workers=1,\n prefetch_factor=8,\n pin_memory=True,\n persistent_workers=True\n )\n return dataloader, dataset.metadata\n","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.create_dataloader","uri":"program://TinyRecursiveModels/function/pretrain.create_dataloader#L97-L113","kind":"function","name":"create_dataloader","path":"pretrain.py","language":"python","start_line":97,"end_line":113,"context_start_line":77,"context_end_line":133,"code":" checkpoint_every_eval: bool = False\n eval_interval: Optional[int] = None\n min_eval_interval: Optional[int] = 0 # when to start eval\n eval_save_outputs: List[str] = []\n\n ema: bool = False # use Exponential-Moving-Average\n ema_rate: float = 0.999 # EMA-rate\n freeze_weights: bool = False # If True, freeze weights and only learn the embeddings\n\n@dataclass\nclass TrainState:\n model: nn.Module\n optimizers: Sequence[torch.optim.Optimizer]\n optimizer_lrs: Sequence[float]\n carry: Any\n\n step: int\n total_steps: int\n\n\ndef create_dataloader(config: PretrainConfig, split: str, rank: int, world_size: int, **kwargs):\n dataset = PuzzleDataset(PuzzleDatasetConfig(\n seed=config.seed,\n dataset_paths=config.data_paths_test if len(config.data_paths_test)>0 and split==\"test\" else config.data_paths,\n rank=rank,\n num_replicas=world_size,\n **kwargs\n ), split=split)\n dataloader = DataLoader(\n dataset,\n batch_size=None,\n num_workers=1,\n prefetch_factor=8,\n pin_memory=True,\n persistent_workers=True\n )\n return dataloader, dataset.metadata\n\n\ndef create_model(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, rank: int, world_size: int):\n model_cfg = dict(\n **config.arch.__pydantic_extra__, # type: ignore\n batch_size=config.global_batch_size // world_size,\n vocab_size=train_metadata.vocab_size,\n seq_len=train_metadata.seq_len,\n num_puzzle_identifiers=train_metadata.num_puzzle_identifiers,\n causal=False # Non-autoregressive\n )\n\n # Instantiate model with loss head\n model_cls = load_model_class(config.arch.name)\n loss_head_cls = load_model_class(config.arch.loss.name)\n\n with torch.device(\"cuda\"):\n model: nn.Module = model_cls(model_cfg)\n print(model)\n model = loss_head_cls(model, **config.arch.loss.__pydantic_extra__) # type: ignore","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.create_model","uri":"program://TinyRecursiveModels/function/pretrain.create_model#L116-L192","kind":"function","name":"create_model","path":"pretrain.py","language":"python","start_line":116,"end_line":192,"context_start_line":96,"context_end_line":212,"code":"\ndef create_dataloader(config: PretrainConfig, split: str, rank: int, world_size: int, **kwargs):\n dataset = PuzzleDataset(PuzzleDatasetConfig(\n seed=config.seed,\n dataset_paths=config.data_paths_test if len(config.data_paths_test)>0 and split==\"test\" else config.data_paths,\n rank=rank,\n num_replicas=world_size,\n **kwargs\n ), split=split)\n dataloader = DataLoader(\n dataset,\n batch_size=None,\n num_workers=1,\n prefetch_factor=8,\n pin_memory=True,\n persistent_workers=True\n )\n return dataloader, dataset.metadata\n\n\ndef create_model(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, rank: int, world_size: int):\n model_cfg = dict(\n **config.arch.__pydantic_extra__, # type: ignore\n batch_size=config.global_batch_size // world_size,\n vocab_size=train_metadata.vocab_size,\n seq_len=train_metadata.seq_len,\n num_puzzle_identifiers=train_metadata.num_puzzle_identifiers,\n causal=False # Non-autoregressive\n )\n\n # Instantiate model with loss head\n model_cls = load_model_class(config.arch.name)\n loss_head_cls = load_model_class(config.arch.loss.name)\n\n with torch.device(\"cuda\"):\n model: nn.Module = model_cls(model_cfg)\n print(model)\n model = loss_head_cls(model, **config.arch.loss.__pydantic_extra__) # type: ignore\n if \"DISABLE_COMPILE\" not in os.environ:\n model = torch.compile(model) # type: ignore\n\n # Load checkpoint\n if rank == 0:\n load_checkpoint(model, config)\n\n # Broadcast parameters from rank 0\n if world_size > 1:\n with torch.no_grad():\n for param in list(model.parameters()) + list(model.buffers()):\n dist.broadcast(param, src=0)\n\n # Optimizers and lr\n if config.arch.puzzle_emb_ndim == 0:\n optimizers = [\n AdamATan2(\n model.parameters(),\n lr=0, # Needs to be set by scheduler\n weight_decay=config.weight_decay,\n betas=(config.beta1, config.beta2)\n )\n ]\n optimizer_lrs = [\n config.lr\n ]\n elif config.freeze_weights:\n optimizers = [\n CastedSparseEmbeddingSignSGD_Distributed(\n model.model.puzzle_emb.buffers(), # type: ignore\n lr=0, # Needs to be set by scheduler\n weight_decay=config.puzzle_emb_weight_decay,\n world_size=world_size\n )\n ]\n optimizer_lrs = [\n config.puzzle_emb_lr\n ]\n else:\n optimizers = [\n CastedSparseEmbeddingSignSGD_Distributed(\n model.model.puzzle_emb.buffers(), # type: ignore\n lr=0, # Needs to be set by scheduler\n weight_decay=config.puzzle_emb_weight_decay,\n world_size=world_size\n ),\n AdamATan2(\n model.parameters(),\n lr=0, # Needs to be set by scheduler\n weight_decay=config.weight_decay,\n betas=(config.beta1, config.beta2)\n )\n ]\n optimizer_lrs = [\n config.puzzle_emb_lr,\n config.lr\n ]\n\n return model, optimizers, optimizer_lrs\n\ndef mix_weights_direct(device, alpha, net, nets):\n sd = []\n for i in range(len(nets)):\n sd += [nets[i].state_dict()]\n sd_alpha = {}\n for k in sd[0].keys():\n comb_net = alpha[0]*sd[0][k].to(device)\n for i in range(1,len(nets)):\n comb_net += alpha[i]*sd[i][k].to(device)\n sd_alpha[k] = comb_net\n net.load_state_dict(sd_alpha)\n return net\n\ndef cosine_schedule_with_warmup_lr_lambda(\n current_step: int, *, base_lr: float, num_warmup_steps: int, num_training_steps: int, min_ratio: float = 0.0, num_cycles: float = 0.5\n):\n if current_step < num_warmup_steps:\n return base_lr * float(current_step) / float(max(1, num_warmup_steps))\n","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.mix_weights_direct","uri":"program://TinyRecursiveModels/function/pretrain.mix_weights_direct#L194-L205","kind":"function","name":"mix_weights_direct","path":"pretrain.py","language":"python","start_line":194,"end_line":205,"context_start_line":174,"context_end_line":225,"code":" CastedSparseEmbeddingSignSGD_Distributed(\n model.model.puzzle_emb.buffers(), # type: ignore\n lr=0, # Needs to be set by scheduler\n weight_decay=config.puzzle_emb_weight_decay,\n world_size=world_size\n ),\n AdamATan2(\n model.parameters(),\n lr=0, # Needs to be set by scheduler\n weight_decay=config.weight_decay,\n betas=(config.beta1, config.beta2)\n )\n ]\n optimizer_lrs = [\n config.puzzle_emb_lr,\n config.lr\n ]\n\n return model, optimizers, optimizer_lrs\n\ndef mix_weights_direct(device, alpha, net, nets):\n sd = []\n for i in range(len(nets)):\n sd += [nets[i].state_dict()]\n sd_alpha = {}\n for k in sd[0].keys():\n comb_net = alpha[0]*sd[0][k].to(device)\n for i in range(1,len(nets)):\n comb_net += alpha[i]*sd[i][k].to(device)\n sd_alpha[k] = comb_net\n net.load_state_dict(sd_alpha)\n return net\n\ndef cosine_schedule_with_warmup_lr_lambda(\n current_step: int, *, base_lr: float, num_warmup_steps: int, num_training_steps: int, min_ratio: float = 0.0, num_cycles: float = 0.5\n):\n if current_step < num_warmup_steps:\n return base_lr * float(current_step) / float(max(1, num_warmup_steps))\n\n progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))\n return base_lr * (min_ratio + max(0.0, (1 - min_ratio) * 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress))))\n\n\ndef init_train_state(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, rank: int, world_size: int):\n # Estimated total training steps\n total_steps = int(config.epochs * train_metadata.total_groups * train_metadata.mean_puzzle_examples / config.global_batch_size)\n\n # Model\n model, optimizers, optimizer_lrs = create_model(config, train_metadata, rank=rank, world_size=world_size)\n\n return TrainState(\n step=0,","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.cosine_schedule_with_warmup_lr_lambda","uri":"program://TinyRecursiveModels/function/pretrain.cosine_schedule_with_warmup_lr_lambda#L207-L214","kind":"function","name":"cosine_schedule_with_warmup_lr_lambda","path":"pretrain.py","language":"python","start_line":207,"end_line":214,"context_start_line":187,"context_end_line":234,"code":" optimizer_lrs = [\n config.puzzle_emb_lr,\n config.lr\n ]\n\n return model, optimizers, optimizer_lrs\n\ndef mix_weights_direct(device, alpha, net, nets):\n sd = []\n for i in range(len(nets)):\n sd += [nets[i].state_dict()]\n sd_alpha = {}\n for k in sd[0].keys():\n comb_net = alpha[0]*sd[0][k].to(device)\n for i in range(1,len(nets)):\n comb_net += alpha[i]*sd[i][k].to(device)\n sd_alpha[k] = comb_net\n net.load_state_dict(sd_alpha)\n return net\n\ndef cosine_schedule_with_warmup_lr_lambda(\n current_step: int, *, base_lr: float, num_warmup_steps: int, num_training_steps: int, min_ratio: float = 0.0, num_cycles: float = 0.5\n):\n if current_step < num_warmup_steps:\n return base_lr * float(current_step) / float(max(1, num_warmup_steps))\n\n progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))\n return base_lr * (min_ratio + max(0.0, (1 - min_ratio) * 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress))))\n\n\ndef init_train_state(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, rank: int, world_size: int):\n # Estimated total training steps\n total_steps = int(config.epochs * train_metadata.total_groups * train_metadata.mean_puzzle_examples / config.global_batch_size)\n\n # Model\n model, optimizers, optimizer_lrs = create_model(config, train_metadata, rank=rank, world_size=world_size)\n\n return TrainState(\n step=0,\n total_steps=total_steps,\n\n model=model,\n optimizers=optimizers,\n optimizer_lrs=optimizer_lrs,\n carry=None\n )\n\n","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.init_train_state","uri":"program://TinyRecursiveModels/function/pretrain.init_train_state#L217-L232","kind":"function","name":"init_train_state","path":"pretrain.py","language":"python","start_line":217,"end_line":232,"context_start_line":197,"context_end_line":252,"code":" sd += [nets[i].state_dict()]\n sd_alpha = {}\n for k in sd[0].keys():\n comb_net = alpha[0]*sd[0][k].to(device)\n for i in range(1,len(nets)):\n comb_net += alpha[i]*sd[i][k].to(device)\n sd_alpha[k] = comb_net\n net.load_state_dict(sd_alpha)\n return net\n\ndef cosine_schedule_with_warmup_lr_lambda(\n current_step: int, *, base_lr: float, num_warmup_steps: int, num_training_steps: int, min_ratio: float = 0.0, num_cycles: float = 0.5\n):\n if current_step < num_warmup_steps:\n return base_lr * float(current_step) / float(max(1, num_warmup_steps))\n\n progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))\n return base_lr * (min_ratio + max(0.0, (1 - min_ratio) * 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress))))\n\n\ndef init_train_state(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, rank: int, world_size: int):\n # Estimated total training steps\n total_steps = int(config.epochs * train_metadata.total_groups * train_metadata.mean_puzzle_examples / config.global_batch_size)\n\n # Model\n model, optimizers, optimizer_lrs = create_model(config, train_metadata, rank=rank, world_size=world_size)\n\n return TrainState(\n step=0,\n total_steps=total_steps,\n\n model=model,\n optimizers=optimizers,\n optimizer_lrs=optimizer_lrs,\n carry=None\n )\n\n\ndef save_train_state(config: PretrainConfig, train_state: TrainState):\n # FIXME: Only saved model.\n if config.checkpoint_path is None:\n return\n\n os.makedirs(config.checkpoint_path, exist_ok=True)\n torch.save(train_state.model.state_dict(), os.path.join(config.checkpoint_path, f\"step_{train_state.step}\"))\n\n\ndef load_checkpoint(model: nn.Module, config: PretrainConfig):\n if config.load_checkpoint is not None:\n print(f\"Loading checkpoint {config.load_checkpoint}\")\n\n # Load state dict\n state_dict = torch.load(config.load_checkpoint, map_location=\"cuda\")\n\n # Resize and reset puzzle emb if needed\n puzzle_emb_name = \"_orig_mod.model.inner.puzzle_emb.weights\"","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.save_train_state","uri":"program://TinyRecursiveModels/function/pretrain.save_train_state#L235-L241","kind":"function","name":"save_train_state","path":"pretrain.py","language":"python","start_line":235,"end_line":241,"context_start_line":215,"context_end_line":261,"code":"\n\ndef init_train_state(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, rank: int, world_size: int):\n # Estimated total training steps\n total_steps = int(config.epochs * train_metadata.total_groups * train_metadata.mean_puzzle_examples / config.global_batch_size)\n\n # Model\n model, optimizers, optimizer_lrs = create_model(config, train_metadata, rank=rank, world_size=world_size)\n\n return TrainState(\n step=0,\n total_steps=total_steps,\n\n model=model,\n optimizers=optimizers,\n optimizer_lrs=optimizer_lrs,\n carry=None\n )\n\n\ndef save_train_state(config: PretrainConfig, train_state: TrainState):\n # FIXME: Only saved model.\n if config.checkpoint_path is None:\n return\n\n os.makedirs(config.checkpoint_path, exist_ok=True)\n torch.save(train_state.model.state_dict(), os.path.join(config.checkpoint_path, f\"step_{train_state.step}\"))\n\n\ndef load_checkpoint(model: nn.Module, config: PretrainConfig):\n if config.load_checkpoint is not None:\n print(f\"Loading checkpoint {config.load_checkpoint}\")\n\n # Load state dict\n state_dict = torch.load(config.load_checkpoint, map_location=\"cuda\")\n\n # Resize and reset puzzle emb if needed\n puzzle_emb_name = \"_orig_mod.model.inner.puzzle_emb.weights\"\n expected_shape: torch.Size = model.model.puzzle_emb.weights.shape # type: ignore\n if puzzle_emb_name in state_dict:\n puzzle_emb = state_dict[puzzle_emb_name]\n if puzzle_emb.shape != expected_shape:\n print(f\"Resetting puzzle embedding as shape is different. Found {puzzle_emb.shape}, Expected {expected_shape}\")\n # Re-initialize using mean\n state_dict[puzzle_emb_name] = (\n torch.mean(puzzle_emb, dim=0, keepdim=True).expand(expected_shape).contiguous()\n )","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.load_checkpoint","uri":"program://TinyRecursiveModels/function/pretrain.load_checkpoint#L244-L262","kind":"function","name":"load_checkpoint","path":"pretrain.py","language":"python","start_line":244,"end_line":262,"context_start_line":224,"context_end_line":282,"code":" return TrainState(\n step=0,\n total_steps=total_steps,\n\n model=model,\n optimizers=optimizers,\n optimizer_lrs=optimizer_lrs,\n carry=None\n )\n\n\ndef save_train_state(config: PretrainConfig, train_state: TrainState):\n # FIXME: Only saved model.\n if config.checkpoint_path is None:\n return\n\n os.makedirs(config.checkpoint_path, exist_ok=True)\n torch.save(train_state.model.state_dict(), os.path.join(config.checkpoint_path, f\"step_{train_state.step}\"))\n\n\ndef load_checkpoint(model: nn.Module, config: PretrainConfig):\n if config.load_checkpoint is not None:\n print(f\"Loading checkpoint {config.load_checkpoint}\")\n\n # Load state dict\n state_dict = torch.load(config.load_checkpoint, map_location=\"cuda\")\n\n # Resize and reset puzzle emb if needed\n puzzle_emb_name = \"_orig_mod.model.inner.puzzle_emb.weights\"\n expected_shape: torch.Size = model.model.puzzle_emb.weights.shape # type: ignore\n if puzzle_emb_name in state_dict:\n puzzle_emb = state_dict[puzzle_emb_name]\n if puzzle_emb.shape != expected_shape:\n print(f\"Resetting puzzle embedding as shape is different. Found {puzzle_emb.shape}, Expected {expected_shape}\")\n # Re-initialize using mean\n state_dict[puzzle_emb_name] = (\n torch.mean(puzzle_emb, dim=0, keepdim=True).expand(expected_shape).contiguous()\n )\n model.load_state_dict(state_dict, assign=True)\n\n\ndef compute_lr(base_lr: float, config: PretrainConfig, train_state: TrainState):\n return cosine_schedule_with_warmup_lr_lambda(\n current_step=train_state.step,\n base_lr=base_lr,\n num_warmup_steps=round(config.lr_warmup_steps),\n num_training_steps=train_state.total_steps,\n min_ratio=config.lr_min_ratio\n )\n\n\n\ndef create_evaluators(config: PretrainConfig, eval_metadata: PuzzleDatasetMetadata) -> List[Any]:\n data_paths =config.data_paths_test if len(config.data_paths_test)>0 else config.data_paths\n # Initialize evaluators\n evaluators = []\n for cfg in config.evaluators:\n for data_path in data_paths:\n cls = load_model_class(cfg.name, \"evaluators.\")(","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.compute_lr","uri":"program://TinyRecursiveModels/function/pretrain.compute_lr#L265-L272","kind":"function","name":"compute_lr","path":"pretrain.py","language":"python","start_line":265,"end_line":272,"context_start_line":245,"context_end_line":292,"code":" if config.load_checkpoint is not None:\n print(f\"Loading checkpoint {config.load_checkpoint}\")\n\n # Load state dict\n state_dict = torch.load(config.load_checkpoint, map_location=\"cuda\")\n\n # Resize and reset puzzle emb if needed\n puzzle_emb_name = \"_orig_mod.model.inner.puzzle_emb.weights\"\n expected_shape: torch.Size = model.model.puzzle_emb.weights.shape # type: ignore\n if puzzle_emb_name in state_dict:\n puzzle_emb = state_dict[puzzle_emb_name]\n if puzzle_emb.shape != expected_shape:\n print(f\"Resetting puzzle embedding as shape is different. Found {puzzle_emb.shape}, Expected {expected_shape}\")\n # Re-initialize using mean\n state_dict[puzzle_emb_name] = (\n torch.mean(puzzle_emb, dim=0, keepdim=True).expand(expected_shape).contiguous()\n )\n model.load_state_dict(state_dict, assign=True)\n\n\ndef compute_lr(base_lr: float, config: PretrainConfig, train_state: TrainState):\n return cosine_schedule_with_warmup_lr_lambda(\n current_step=train_state.step,\n base_lr=base_lr,\n num_warmup_steps=round(config.lr_warmup_steps),\n num_training_steps=train_state.total_steps,\n min_ratio=config.lr_min_ratio\n )\n\n\n\ndef create_evaluators(config: PretrainConfig, eval_metadata: PuzzleDatasetMetadata) -> List[Any]:\n data_paths =config.data_paths_test if len(config.data_paths_test)>0 else config.data_paths\n # Initialize evaluators\n evaluators = []\n for cfg in config.evaluators:\n for data_path in data_paths:\n cls = load_model_class(cfg.name, \"evaluators.\")(\n data_path=data_path, eval_metadata=eval_metadata, **cfg.__pydantic_extra__\n ) # type: ignore\n evaluators.append(cls)\n\n return evaluators\n\ndef train_batch(config: PretrainConfig, train_state: TrainState, batch: Any, global_batch_size: int, rank: int, world_size: int):\n train_state.step += 1\n if train_state.step > train_state.total_steps: # At most train_total_steps\n return","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.create_evaluators","uri":"program://TinyRecursiveModels/function/pretrain.create_evaluators#L276-L287","kind":"function","name":"create_evaluators","path":"pretrain.py","language":"python","start_line":276,"end_line":287,"context_start_line":256,"context_end_line":307,"code":" if puzzle_emb.shape != expected_shape:\n print(f\"Resetting puzzle embedding as shape is different. Found {puzzle_emb.shape}, Expected {expected_shape}\")\n # Re-initialize using mean\n state_dict[puzzle_emb_name] = (\n torch.mean(puzzle_emb, dim=0, keepdim=True).expand(expected_shape).contiguous()\n )\n model.load_state_dict(state_dict, assign=True)\n\n\ndef compute_lr(base_lr: float, config: PretrainConfig, train_state: TrainState):\n return cosine_schedule_with_warmup_lr_lambda(\n current_step=train_state.step,\n base_lr=base_lr,\n num_warmup_steps=round(config.lr_warmup_steps),\n num_training_steps=train_state.total_steps,\n min_ratio=config.lr_min_ratio\n )\n\n\n\ndef create_evaluators(config: PretrainConfig, eval_metadata: PuzzleDatasetMetadata) -> List[Any]:\n data_paths =config.data_paths_test if len(config.data_paths_test)>0 else config.data_paths\n # Initialize evaluators\n evaluators = []\n for cfg in config.evaluators:\n for data_path in data_paths:\n cls = load_model_class(cfg.name, \"evaluators.\")(\n data_path=data_path, eval_metadata=eval_metadata, **cfg.__pydantic_extra__\n ) # type: ignore\n evaluators.append(cls)\n\n return evaluators\n\ndef train_batch(config: PretrainConfig, train_state: TrainState, batch: Any, global_batch_size: int, rank: int, world_size: int):\n train_state.step += 1\n if train_state.step > train_state.total_steps: # At most train_total_steps\n return\n\n # To device\n batch = {k: v.cuda() for k, v in batch.items()}\n\n # Init carry if it is None\n if train_state.carry is None:\n with torch.device(\"cuda\"):\n train_state.carry = train_state.model.initial_carry(batch) # type: ignore\n\n # Forward\n train_state.carry, loss, metrics, _, _ = train_state.model(carry=train_state.carry, batch=batch, return_keys=[])\n\n ((1 / global_batch_size) * loss).backward()\n\n # Allreduce","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.train_batch","uri":"program://TinyRecursiveModels/function/pretrain.train_batch#L289-L343","kind":"function","name":"train_batch","path":"pretrain.py","language":"python","start_line":289,"end_line":343,"context_start_line":269,"context_end_line":363,"code":" num_warmup_steps=round(config.lr_warmup_steps),\n num_training_steps=train_state.total_steps,\n min_ratio=config.lr_min_ratio\n )\n\n\n\ndef create_evaluators(config: PretrainConfig, eval_metadata: PuzzleDatasetMetadata) -> List[Any]:\n data_paths =config.data_paths_test if len(config.data_paths_test)>0 else config.data_paths\n # Initialize evaluators\n evaluators = []\n for cfg in config.evaluators:\n for data_path in data_paths:\n cls = load_model_class(cfg.name, \"evaluators.\")(\n data_path=data_path, eval_metadata=eval_metadata, **cfg.__pydantic_extra__\n ) # type: ignore\n evaluators.append(cls)\n\n return evaluators\n\ndef train_batch(config: PretrainConfig, train_state: TrainState, batch: Any, global_batch_size: int, rank: int, world_size: int):\n train_state.step += 1\n if train_state.step > train_state.total_steps: # At most train_total_steps\n return\n\n # To device\n batch = {k: v.cuda() for k, v in batch.items()}\n\n # Init carry if it is None\n if train_state.carry is None:\n with torch.device(\"cuda\"):\n train_state.carry = train_state.model.initial_carry(batch) # type: ignore\n\n # Forward\n train_state.carry, loss, metrics, _, _ = train_state.model(carry=train_state.carry, batch=batch, return_keys=[])\n\n ((1 / global_batch_size) * loss).backward()\n\n # Allreduce\n if world_size > 1:\n for param in train_state.model.parameters():\n if param.grad is not None:\n dist.all_reduce(param.grad)\n \n # Apply optimizer\n lr_this_step = None \n for optim, base_lr in zip(train_state.optimizers, train_state.optimizer_lrs):\n lr_this_step = compute_lr(base_lr, config, train_state)\n\n for param_group in optim.param_groups:\n param_group['lr'] = lr_this_step\n \n optim.step()\n optim.zero_grad()\n\n # Reduce metrics\n if len(metrics):\n assert not any(v.requires_grad for v in metrics.values())\n\n metric_keys = list(sorted(metrics.keys())) # Sort keys to guarantee all processes use the same order.\n # Reduce and reconstruct\n metric_values = torch.stack([metrics[k] for k in metric_keys])\n if world_size > 1:\n dist.reduce(metric_values, dst=0)\n\n if rank == 0:\n metric_values = metric_values.cpu().numpy()\n reduced_metrics = {k: metric_values[i] for i, k in enumerate(metric_keys)}\n \n # Postprocess\n count = max(reduced_metrics[\"count\"], 1) # Avoid NaNs\n reduced_metrics = {f\"train/{k}\": v / (global_batch_size if k.endswith(\"loss\") else count) for k, v in reduced_metrics.items()}\n\n reduced_metrics[\"train/lr\"] = lr_this_step\n return reduced_metrics\n\ndef evaluate(\n config: PretrainConfig,\n train_state: TrainState,\n eval_loader: torch.utils.data.DataLoader,\n eval_metadata: PuzzleDatasetMetadata,\n evaluators: List[Any],\n rank: int,\n world_size: int,\n cpu_group: Optional[dist.ProcessGroup],\n):\n reduced_metrics = None\n\n with torch.inference_mode():\n return_keys = set(config.eval_save_outputs)\n for evaluator in evaluators:\n evaluator.begin_eval()\n return_keys.update(evaluator.required_outputs)\n\n # Run evaluation","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.evaluate","uri":"program://TinyRecursiveModels/function/pretrain.evaluate#L345-L486","kind":"function","name":"evaluate","path":"pretrain.py","language":"python","start_line":345,"end_line":486,"context_start_line":325,"context_end_line":506,"code":" if len(metrics):\n assert not any(v.requires_grad for v in metrics.values())\n\n metric_keys = list(sorted(metrics.keys())) # Sort keys to guarantee all processes use the same order.\n # Reduce and reconstruct\n metric_values = torch.stack([metrics[k] for k in metric_keys])\n if world_size > 1:\n dist.reduce(metric_values, dst=0)\n\n if rank == 0:\n metric_values = metric_values.cpu().numpy()\n reduced_metrics = {k: metric_values[i] for i, k in enumerate(metric_keys)}\n \n # Postprocess\n count = max(reduced_metrics[\"count\"], 1) # Avoid NaNs\n reduced_metrics = {f\"train/{k}\": v / (global_batch_size if k.endswith(\"loss\") else count) for k, v in reduced_metrics.items()}\n\n reduced_metrics[\"train/lr\"] = lr_this_step\n return reduced_metrics\n\ndef evaluate(\n config: PretrainConfig,\n train_state: TrainState,\n eval_loader: torch.utils.data.DataLoader,\n eval_metadata: PuzzleDatasetMetadata,\n evaluators: List[Any],\n rank: int,\n world_size: int,\n cpu_group: Optional[dist.ProcessGroup],\n):\n reduced_metrics = None\n\n with torch.inference_mode():\n return_keys = set(config.eval_save_outputs)\n for evaluator in evaluators:\n evaluator.begin_eval()\n return_keys.update(evaluator.required_outputs)\n\n # Run evaluation\n set_ids = {k: idx for idx, k in enumerate(eval_metadata.sets)}\n\n save_preds = {}\n\n metric_keys = []\n metric_values = None\n\n carry = None\n processed_batches = 0\n \n for set_name, batch, global_batch_size in eval_loader:\n processed_batches += 1\n if rank == 0:\n print(f\"Processing batch {processed_batches}: {set_name}\")\n \n # To device\n batch = {k: v.cuda() for k, v in batch.items()}\n with torch.device(\"cuda\"):\n carry = train_state.model.initial_carry(batch) # type: ignore\n\n # Forward\n inference_steps = 0\n while True:\n carry, loss, metrics, preds, all_finish = train_state.model(\n carry=carry, batch=batch, return_keys=return_keys\n )\n inference_steps += 1\n\n if all_finish:\n break\n\n if rank == 0:\n print(f\" Completed inference in {inference_steps} steps\")\n\n for collection in (batch, preds):\n for k, v in collection.items():\n if k in config.eval_save_outputs:\n save_preds.setdefault(k, [])\n save_preds[k].append(v.cpu()) # Move to CPU for saving GPU memory\n\n for evaluator in evaluators:\n evaluator.update_batch(batch, preds)\n\n del carry, loss, preds, batch, all_finish\n\n # Aggregate metrics\n set_id = set_ids[set_name]\n\n if metric_values is None:\n metric_keys = list(\n sorted(metrics.keys())\n ) # Sort keys to guarantee all processes use the same order.\n metric_values = torch.zeros(\n (len(set_ids), len(metrics.values())), dtype=torch.float32, device=\"cuda\"\n )\n\n metric_values[set_id] += torch.stack([metrics[k] for k in metric_keys])\n\n del metrics\n\n # concatenate save preds\n save_preds = {k: torch.cat(v, dim=0) for k, v in save_preds.items()}\n\n # Save preds\n if config.checkpoint_path is not None and len(save_preds):\n # Each rank save predictions independently\n os.makedirs(os.path.dirname(config.checkpoint_path), exist_ok=True)\n torch.save(\n save_preds, os.path.join(config.checkpoint_path, f\"step_{train_state.step}_all_preds.{rank}\")\n )\n\n del save_preds\n\n # Reduce to rank 0\n if metric_values is not None:\n if world_size > 1:\n dist.reduce(metric_values, dst=0)\n\n if rank == 0:\n reduced_metrics = metric_values.cpu().numpy()\n reduced_metrics = {\n set_name: {\n metric_name: reduced_metrics[set_id, metric_id]\n for metric_id, metric_name in enumerate(metric_keys)\n }\n for set_id, set_name in enumerate(set_ids)\n }\n\n # Postprocess\n for set_name, m in reduced_metrics.items():\n count = m.pop(\"count\")\n reduced_metrics[set_name] = {k: v / count for k, v in m.items()}\n\n # Run evaluators\n if rank == 0:\n print(f\"\\nRunning {len(evaluators)} evaluator(s)...\")\n \n for i, evaluator in enumerate(evaluators):\n if rank == 0:\n print(f\"Running evaluator {i+1}/{len(evaluators)}: {evaluator.__class__.__name__}\")\n \n # Path for saving\n evaluator_save_path = None\n if config.checkpoint_path is not None:\n evaluator_save_path = os.path.join(\n config.checkpoint_path,\n f\"evaluator_{evaluator.__class__.__name__}_step_{train_state.step}\",\n )\n os.makedirs(evaluator_save_path, exist_ok=True)\n\n # Run and log\n metrics = evaluator.result(evaluator_save_path, rank=rank, world_size=world_size, group=cpu_group)\n if rank == 0 and metrics is not None:\n if reduced_metrics is None:\n reduced_metrics = {}\n\n reduced_metrics.update(metrics)\n print(f\" Completed {evaluator.__class__.__name__}\")\n \n if rank == 0:\n print(\"All evaluators completed!\")\n\n return reduced_metrics\n\ndef save_code_and_config(config: PretrainConfig):\n if config.checkpoint_path is None or wandb.run is None:\n return\n\n os.makedirs(config.checkpoint_path, exist_ok=True)\n\n # Copy code\n code_list = [\n get_model_source_path(config.arch.name),\n get_model_source_path(config.arch.loss.name)\n ]\n for code_file in code_list:\n if code_file is not None:\n code_name = os.path.basename(code_file)\n\n shutil.copy(code_file, os.path.join(config.checkpoint_path, code_name))\n\n # Dump config as yaml\n config_file = os.path.join(config.checkpoint_path, \"all_config.yaml\")","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.save_code_and_config","uri":"program://TinyRecursiveModels/function/pretrain.save_code_and_config#L488-L511","kind":"function","name":"save_code_and_config","path":"pretrain.py","language":"python","start_line":488,"end_line":511,"context_start_line":468,"context_end_line":531,"code":" evaluator_save_path = os.path.join(\n config.checkpoint_path,\n f\"evaluator_{evaluator.__class__.__name__}_step_{train_state.step}\",\n )\n os.makedirs(evaluator_save_path, exist_ok=True)\n\n # Run and log\n metrics = evaluator.result(evaluator_save_path, rank=rank, world_size=world_size, group=cpu_group)\n if rank == 0 and metrics is not None:\n if reduced_metrics is None:\n reduced_metrics = {}\n\n reduced_metrics.update(metrics)\n print(f\" Completed {evaluator.__class__.__name__}\")\n \n if rank == 0:\n print(\"All evaluators completed!\")\n\n return reduced_metrics\n\ndef save_code_and_config(config: PretrainConfig):\n if config.checkpoint_path is None or wandb.run is None:\n return\n\n os.makedirs(config.checkpoint_path, exist_ok=True)\n\n # Copy code\n code_list = [\n get_model_source_path(config.arch.name),\n get_model_source_path(config.arch.loss.name)\n ]\n for code_file in code_list:\n if code_file is not None:\n code_name = os.path.basename(code_file)\n\n shutil.copy(code_file, os.path.join(config.checkpoint_path, code_name))\n\n # Dump config as yaml\n config_file = os.path.join(config.checkpoint_path, \"all_config.yaml\")\n with open(config_file, \"wt\") as f:\n yaml.dump(config.model_dump(), f)\n\n # Log code\n wandb.run.log_code(config.checkpoint_path)\n\n\ndef load_synced_config(hydra_config: DictConfig, rank: int, world_size: int) -> PretrainConfig:\n objects = [None]\n if rank == 0:\n config = PretrainConfig(**hydra_config) # type: ignore\n\n # Naming\n if config.project_name is None:\n config.project_name = f\"{os.path.basename(config.data_paths[0]).capitalize()}-ACT-torch\"\n if config.run_name is None:\n config.run_name = f\"{config.arch.name.split('@')[-1]} {coolname.generate_slug(2)}\"\n if config.checkpoint_path is None:\n config.checkpoint_path = os.path.join(\"checkpoints\", config.project_name, config.run_name)\n\n objects = [config]\n\n if world_size > 1:\n dist.broadcast_object_list(objects, src=0)\n","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.load_synced_config","uri":"program://TinyRecursiveModels/function/pretrain.load_synced_config#L514-L532","kind":"function","name":"load_synced_config","path":"pretrain.py","language":"python","start_line":514,"end_line":532,"context_start_line":494,"context_end_line":552,"code":" # Copy code\n code_list = [\n get_model_source_path(config.arch.name),\n get_model_source_path(config.arch.loss.name)\n ]\n for code_file in code_list:\n if code_file is not None:\n code_name = os.path.basename(code_file)\n\n shutil.copy(code_file, os.path.join(config.checkpoint_path, code_name))\n\n # Dump config as yaml\n config_file = os.path.join(config.checkpoint_path, \"all_config.yaml\")\n with open(config_file, \"wt\") as f:\n yaml.dump(config.model_dump(), f)\n\n # Log code\n wandb.run.log_code(config.checkpoint_path)\n\n\ndef load_synced_config(hydra_config: DictConfig, rank: int, world_size: int) -> PretrainConfig:\n objects = [None]\n if rank == 0:\n config = PretrainConfig(**hydra_config) # type: ignore\n\n # Naming\n if config.project_name is None:\n config.project_name = f\"{os.path.basename(config.data_paths[0]).capitalize()}-ACT-torch\"\n if config.run_name is None:\n config.run_name = f\"{config.arch.name.split('@')[-1]} {coolname.generate_slug(2)}\"\n if config.checkpoint_path is None:\n config.checkpoint_path = os.path.join(\"checkpoints\", config.project_name, config.run_name)\n\n objects = [config]\n\n if world_size > 1:\n dist.broadcast_object_list(objects, src=0)\n\n return objects[0] # type: ignore\n\n\n@hydra.main(config_path=\"config\", config_name=\"cfg_pretrain\", version_base=None)\ndef launch(hydra_config: DictConfig):\n RANK = 0\n WORLD_SIZE = 1\n CPU_PROCESS_GROUP = None\n\n # Initialize distributed training if in distributed environment (e.g. torchrun)\n if \"LOCAL_RANK\" in os.environ:\n # Initialize distributed, default device and dtype\n dist.init_process_group(backend=\"nccl\")\n\n RANK = dist.get_rank()\n WORLD_SIZE = dist.get_world_size()\n\n torch.cuda.set_device(int(os.environ[\"LOCAL_RANK\"]))\n \n # CPU GLOO process group\n CPU_PROCESS_GROUP = dist.new_group(backend=\"gloo\")","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:pretrain.launch","uri":"program://TinyRecursiveModels/function/pretrain.launch#L536-L650","kind":"function","name":"launch","path":"pretrain.py","language":"python","start_line":536,"end_line":650,"context_start_line":516,"context_end_line":654,"code":" if rank == 0:\n config = PretrainConfig(**hydra_config) # type: ignore\n\n # Naming\n if config.project_name is None:\n config.project_name = f\"{os.path.basename(config.data_paths[0]).capitalize()}-ACT-torch\"\n if config.run_name is None:\n config.run_name = f\"{config.arch.name.split('@')[-1]} {coolname.generate_slug(2)}\"\n if config.checkpoint_path is None:\n config.checkpoint_path = os.path.join(\"checkpoints\", config.project_name, config.run_name)\n\n objects = [config]\n\n if world_size > 1:\n dist.broadcast_object_list(objects, src=0)\n\n return objects[0] # type: ignore\n\n\n@hydra.main(config_path=\"config\", config_name=\"cfg_pretrain\", version_base=None)\ndef launch(hydra_config: DictConfig):\n RANK = 0\n WORLD_SIZE = 1\n CPU_PROCESS_GROUP = None\n\n # Initialize distributed training if in distributed environment (e.g. torchrun)\n if \"LOCAL_RANK\" in os.environ:\n # Initialize distributed, default device and dtype\n dist.init_process_group(backend=\"nccl\")\n\n RANK = dist.get_rank()\n WORLD_SIZE = dist.get_world_size()\n\n torch.cuda.set_device(int(os.environ[\"LOCAL_RANK\"]))\n \n # CPU GLOO process group\n CPU_PROCESS_GROUP = dist.new_group(backend=\"gloo\")\n assert (\n dist.get_rank(CPU_PROCESS_GROUP) == RANK and dist.get_world_size(CPU_PROCESS_GROUP) == WORLD_SIZE\n )\n\n # Load sync'ed config\n config = load_synced_config(hydra_config, rank=RANK, world_size=WORLD_SIZE)\n\n # Seed RNGs to ensure consistency\n torch.random.manual_seed(config.seed + RANK)\n\n # Dataset\n train_epochs_per_iter = config.eval_interval if config.eval_interval is not None else config.epochs\n total_iters = config.epochs // train_epochs_per_iter\n\n assert config.epochs % train_epochs_per_iter == 0, \"Eval interval must be a divisor of total epochs.\"\n\n train_loader, train_metadata = create_dataloader(config, \"train\", test_set_mode=False, epochs_per_iter=train_epochs_per_iter, global_batch_size=config.global_batch_size, rank=RANK, world_size=WORLD_SIZE)\n try:\n eval_loader, eval_metadata = create_dataloader(config, \"test\", test_set_mode=True, epochs_per_iter=1, global_batch_size=config.global_batch_size, rank=RANK, world_size=WORLD_SIZE)\n except:\n print(\"NO EVAL DATA FOUND\")\n eval_loader = eval_metadata = None\n\n try:\n evaluators = create_evaluators(config, eval_metadata)\n except:\n print(\"No evaluator found\")\n evaluators = []\n\n # Train state\n train_state = init_train_state(config, train_metadata, rank=RANK, world_size=WORLD_SIZE)\n\n # Progress bar and logger\n progress_bar = None\n ema_helper = None\n if RANK == 0:\n progress_bar = tqdm.tqdm(total=train_state.total_steps)\n wandb.init(project=config.project_name, name=config.run_name, config=config.model_dump(), settings=wandb.Settings(_disable_stats=True)) # type: ignore\n wandb.log({\"num_params\": sum(x.numel() for x in train_state.model.parameters())}, step=0)\n save_code_and_config(config)\n if config.ema:\n print('Setup EMA')\n ema_helper = EMAHelper(mu=config.ema_rate)\n ema_helper.register(train_state.model)\n\n # Training Loop\n for _iter_id in range(total_iters):\n print (f\"[Rank {RANK}, World Size {WORLD_SIZE}]: Epoch {_iter_id * train_epochs_per_iter}\")\n\n ############ Train Iter\n if RANK == 0:\n print(\"TRAIN\")\n train_state.model.train()\n for set_name, batch, global_batch_size in train_loader:\n metrics = train_batch(config, train_state, batch, global_batch_size, rank=RANK, world_size=WORLD_SIZE)\n\n if RANK == 0 and metrics is not None:\n wandb.log(metrics, step=train_state.step)\n progress_bar.update(train_state.step - progress_bar.n) # type: ignore\n if config.ema:\n ema_helper.update(train_state.model)\n\n if _iter_id >= config.min_eval_interval:\n ############ Evaluation\n if RANK == 0:\n print(\"EVALUATE\")\n if config.ema:\n print(\"SWITCH TO EMA\")\n train_state_eval = copy.deepcopy(train_state)\n train_state_eval.model = ema_helper.ema_copy(train_state_eval.model)\n else:\n train_state_eval = train_state\n train_state_eval.model.eval()\n metrics = evaluate(config, \n train_state_eval, \n eval_loader, \n eval_metadata, \n evaluators,\n rank=RANK, \n world_size=WORLD_SIZE,\n cpu_group=CPU_PROCESS_GROUP)\n\n if RANK == 0 and metrics is not None:\n wandb.log(metrics, step=train_state.step)\n \n ############ Checkpointing\n if RANK == 0:\n print(\"SAVE CHECKPOINT\")\n if RANK == 0 and (config.checkpoint_every_eval or (_iter_id == total_iters - 1)):\n save_train_state(config, train_state_eval)\n\n if config.ema:\n del train_state_eval\n\n # finalize\n if dist.is_initialized():\n dist.destroy_process_group()\n wandb.finish()\n\n\nif __name__ == \"__main__\":\n launch()","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset","uri":"program://TinyRecursiveModels/module/puzzle_dataset#L1-L250","kind":"module","name":"puzzle_dataset","path":"puzzle_dataset.py","language":"python","start_line":1,"end_line":250,"context_start_line":1,"context_end_line":250,"code":"import os\nimport json\nfrom typing import Tuple, List, Dict, Optional\nimport numpy as np\nimport pydantic\n\nimport torch\nfrom torch.utils.data import IterableDataset, get_worker_info\n\nfrom models.losses import IGNORE_LABEL_ID\nfrom dataset.common import PuzzleDatasetMetadata\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\n\ndef _sample_batch(rng: np.random.Generator, group_order: np.ndarray, puzzle_indices: np.ndarray, group_indices: np.ndarray, start_index: int, global_batch_size: int):\n # Pack examples into a full batch\n batch = []\n batch_puzzle_indices = []\n current_size = 0\n\n while (start_index < group_order.size) and (current_size < global_batch_size):\n # Pick a group and a puzzle from that group\n group_id = group_order[start_index]\n puzzle_id = rng.integers(group_indices[group_id], group_indices[group_id + 1])\n start_index += 1\n\n # Get range of the puzzle\n puzzle_start = puzzle_indices[puzzle_id]\n puzzle_size = int(puzzle_indices[puzzle_id + 1] - puzzle_start)\n\n append_size = min(puzzle_size, global_batch_size - current_size)\n\n # Put into batch\n batch_puzzle_indices.append(np.full(append_size, puzzle_id, dtype=np.int32))\n batch.append(puzzle_start + np.random.choice(puzzle_size, append_size, replace=False))\n\n current_size += append_size\n\n return start_index, np.concatenate(batch), np.concatenate(batch_puzzle_indices)\n\n\nclass PuzzleDatasetConfig(pydantic.BaseModel):\n seed: int\n dataset_paths: List[str]\n global_batch_size: int\n test_set_mode: bool\n epochs_per_iter: int # Batch X epochs in an iteration to reduce overhead.\n rank: int\n num_replicas: int\n\nclass PuzzleDataset(IterableDataset):\n def __init__(self, config: PuzzleDatasetConfig, split: str = \"train\"):\n super().__init__()\n self.config = config\n self.split = split\n\n # Merge multiple metadata\n prev_seq_len = None\n prev_vocab_size = None\n prev_pad_id = None\n prev_ignore_label_id = None\n prev_blank_identifier_id = None\n prev_sets = None\n prev_num_identifiers = None\n mean_puzzle_examples = 0\n total_puzzles = 0\n total_groups = 0\n num_identifiers = 0\n for dataset_path in config.dataset_paths:\n current_metadata = self._load_metadata(dataset_path)\n if prev_seq_len is None:\n prev_seq_len = current_metadata.seq_len\n prev_vocab_size = current_metadata.vocab_size\n prev_pad_id = current_metadata.pad_id\n prev_ignore_label_id = current_metadata.ignore_label_id\n prev_blank_identifier_id = current_metadata.blank_identifier_id\n prev_sets = current_metadata.sets\n prev_num_identifiers = current_metadata.num_puzzle_identifiers\n else:\n assert prev_seq_len == current_metadata.seq_len\n assert prev_vocab_size == current_metadata.vocab_size\n assert prev_pad_id == current_metadata.pad_id\n assert prev_ignore_label_id == current_metadata.ignore_label_id\n assert prev_blank_identifier_id == current_metadata.blank_identifier_id\n assert prev_sets == current_metadata.sets\n assert prev_num_identifiers == current_metadata.num_puzzle_identifiers\n mean_puzzle_examples += current_metadata.mean_puzzle_examples*current_metadata.total_puzzles\n total_puzzles += current_metadata.total_puzzles\n total_groups += current_metadata.total_groups\n num_identifiers += current_metadata.num_puzzle_identifiers\n mean_puzzle_examples = mean_puzzle_examples / total_puzzles\n\n self.metadata = PuzzleDatasetMetadata(\n seq_len=prev_seq_len,\n vocab_size=prev_vocab_size,\n pad_id=prev_pad_id,\n ignore_label_id=prev_ignore_label_id,\n blank_identifier_id=prev_blank_identifier_id,\n num_puzzle_identifiers=num_identifiers,\n total_groups=total_groups,\n mean_puzzle_examples=mean_puzzle_examples,\n total_puzzles=total_puzzles,\n sets=prev_sets\n )\n\n # Checks\n assert self.config.global_batch_size % self.config.num_replicas == 0, f\"Global batch size {self.config.global_batch_size} must be multiples of nodes {self.config.num_replicas}.\"\n self.local_batch_size = self.config.global_batch_size // self.config.num_replicas\n\n # State\n self._data = None\n self._iters = 0\n\n def _load_metadata(self, dataset_path) -> PuzzleDatasetMetadata:\n with open(os.path.join(dataset_path, self.split, \"dataset.json\"), \"r\") as f:\n return PuzzleDatasetMetadata(**json.load(f))\n\n def _lazy_load_dataset(self):\n if self._data is not None:\n return\n\n field_mmap_modes = {\n \"inputs\": \"r\",\n \"labels\": \"r\",\n\n # Keep indices in memory\n \"puzzle_identifiers\": None,\n \"puzzle_indices\": None,\n \"group_indices\": None\n }\n\n # Load data\n self._data = {}\n for set_name in self.metadata.sets: # Load subset\n for i, dataset_path in enumerate(self.config.dataset_paths):\n if i > 0:\n set_name_ = set_name + str(i)\n else:\n set_name_ = set_name\n self._data[set_name_] = {\n field_name: np.load(os.path.join(dataset_path, self.split, f\"{set_name}__{field_name}.npy\"), mmap_mode=mmap_mode)\n for field_name, mmap_mode in field_mmap_modes.items()\n }\n\n\n def _collate_batch(self, batch):\n # Convert dtype\n batch = {k: v.astype(np.int32) for k, v in batch.items()}\n\n # Convert ignore label IDs\n if self.metadata.ignore_label_id is not None:\n batch[\"labels\"][batch[\"labels\"] == self.metadata.ignore_label_id] = IGNORE_LABEL_ID\n\n # Pad\n if batch[\"puzzle_identifiers\"].size < self.local_batch_size:\n pad_size = self.local_batch_size - batch[\"puzzle_identifiers\"].size\n pad_values = {\n \"inputs\": self.metadata.pad_id,\n \"labels\": IGNORE_LABEL_ID,\n \"puzzle_identifiers\": self.metadata.blank_identifier_id\n }\n batch = {k: np.pad(v, ((0, pad_size), ) + ((0, 0), ) * (v.ndim - 1), constant_values=pad_values[k]) for k, v in batch.items()}\n\n # To tensor\n return {k: torch.from_numpy(v) for k, v in batch.items()}\n \n def _iter_test(self):\n for set_i, (set_name, dataset) in enumerate(self._data.items()): # type: ignore\n total_examples = len(dataset[\"inputs\"])\n\n # Load examples one by one\n start_index = 0\n while start_index < total_examples:\n # Compute indices\n end_index = min(total_examples, start_index + self.config.global_batch_size)\n \n local_start = start_index + self.config.rank * self.local_batch_size\n local_end = min(start_index + (self.config.rank + 1) * self.local_batch_size, end_index)\n \n # Get batch of examples, and also puzzle IDs\n puzzle_indices = []\n puzzle_index = np.searchsorted(dataset[\"puzzle_indices\"], local_start, side=\"right\") - 1\n for i in range(local_start, local_end):\n while puzzle_index + 1 < len(dataset[\"puzzle_indices\"]) and i >= dataset[\"puzzle_indices\"][puzzle_index + 1]:\n puzzle_index += 1\n\n puzzle_indices.append(puzzle_index)\n \n batch = self._collate_batch({\n \"inputs\": dataset[\"inputs\"][local_start: local_end],\n \"labels\": dataset[\"labels\"][local_start: local_end],\n \"puzzle_identifiers\": dataset[\"puzzle_identifiers\"][puzzle_indices]\n })\n\n yield set_name, batch, end_index - start_index\n \n # Advance to next batch\n start_index += self.config.global_batch_size\n\n def _iter_train(self):\n for set_name, dataset in self._data.items(): # type: ignore\n # Increase epoch count\n self._iters += 1\n\n # Randomly shuffle groups\n rng = np.random.Generator(np.random.Philox(seed=self.config.seed + self._iters))\n\n group_order = np.concatenate([rng.permutation(dataset[\"group_indices\"].size - 1) for _i in range(self.config.epochs_per_iter)])\n start_index = 0\n \n while start_index < group_order.size:\n start_index, batch_indices, batch_puzzle_indices = _sample_batch(\n rng,\n group_order=group_order,\n puzzle_indices=dataset[\"puzzle_indices\"],\n group_indices=dataset[\"group_indices\"],\n start_index=start_index,\n global_batch_size=self.config.global_batch_size,\n )\n\n # Select current rank and collate\n global_effective_batch_size = batch_puzzle_indices.size # Global effective batch size, excluding pads\n\n # Drop last batch\n if global_effective_batch_size < self.config.global_batch_size:\n break\n\n batch_indices = batch_indices [self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size]\n batch_puzzle_indices = batch_puzzle_indices[self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size]\n batch = self._collate_batch({\n \"inputs\": dataset[\"inputs\"][batch_indices],\n \"labels\": dataset[\"labels\"][batch_indices],\n \"puzzle_identifiers\": dataset[\"puzzle_identifiers\"][batch_puzzle_indices]\n })\n\n yield set_name, batch, global_effective_batch_size\n \n def __iter__(self):\n worker_info = get_worker_info()\n assert worker_info is None or worker_info.num_workers == 1, \"Multithreaded data loading is not currently supported.\"\n \n self._lazy_load_dataset()\n \n # Iterate using specified mode\n if self.config.test_set_mode:\n yield from self._iter_test()\n else:\n yield from self._iter_train()\n","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset._sample_batch","uri":"program://TinyRecursiveModels/function/puzzle_dataset._sample_batch#L16-L40","kind":"function","name":"_sample_batch","path":"puzzle_dataset.py","language":"python","start_line":16,"end_line":40,"context_start_line":1,"context_end_line":60,"code":"import os\nimport json\nfrom typing import Tuple, List, Dict, Optional\nimport numpy as np\nimport pydantic\n\nimport torch\nfrom torch.utils.data import IterableDataset, get_worker_info\n\nfrom models.losses import IGNORE_LABEL_ID\nfrom dataset.common import PuzzleDatasetMetadata\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\n\ndef _sample_batch(rng: np.random.Generator, group_order: np.ndarray, puzzle_indices: np.ndarray, group_indices: np.ndarray, start_index: int, global_batch_size: int):\n # Pack examples into a full batch\n batch = []\n batch_puzzle_indices = []\n current_size = 0\n\n while (start_index < group_order.size) and (current_size < global_batch_size):\n # Pick a group and a puzzle from that group\n group_id = group_order[start_index]\n puzzle_id = rng.integers(group_indices[group_id], group_indices[group_id + 1])\n start_index += 1\n\n # Get range of the puzzle\n puzzle_start = puzzle_indices[puzzle_id]\n puzzle_size = int(puzzle_indices[puzzle_id + 1] - puzzle_start)\n\n append_size = min(puzzle_size, global_batch_size - current_size)\n\n # Put into batch\n batch_puzzle_indices.append(np.full(append_size, puzzle_id, dtype=np.int32))\n batch.append(puzzle_start + np.random.choice(puzzle_size, append_size, replace=False))\n\n current_size += append_size\n\n return start_index, np.concatenate(batch), np.concatenate(batch_puzzle_indices)\n\n\nclass PuzzleDatasetConfig(pydantic.BaseModel):\n seed: int\n dataset_paths: List[str]\n global_batch_size: int\n test_set_mode: bool\n epochs_per_iter: int # Batch X epochs in an iteration to reduce overhead.\n rank: int\n num_replicas: int\n\nclass PuzzleDataset(IterableDataset):\n def __init__(self, config: PuzzleDatasetConfig, split: str = \"train\"):\n super().__init__()\n self.config = config\n self.split = split\n\n # Merge multiple metadata\n prev_seq_len = None\n prev_vocab_size = None","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset.PuzzleDatasetConfig","uri":"program://TinyRecursiveModels/class/puzzle_dataset.PuzzleDatasetConfig#L43-L50","kind":"class","name":"PuzzleDatasetConfig","path":"puzzle_dataset.py","language":"python","start_line":43,"end_line":50,"context_start_line":23,"context_end_line":70,"code":" # Pick a group and a puzzle from that group\n group_id = group_order[start_index]\n puzzle_id = rng.integers(group_indices[group_id], group_indices[group_id + 1])\n start_index += 1\n\n # Get range of the puzzle\n puzzle_start = puzzle_indices[puzzle_id]\n puzzle_size = int(puzzle_indices[puzzle_id + 1] - puzzle_start)\n\n append_size = min(puzzle_size, global_batch_size - current_size)\n\n # Put into batch\n batch_puzzle_indices.append(np.full(append_size, puzzle_id, dtype=np.int32))\n batch.append(puzzle_start + np.random.choice(puzzle_size, append_size, replace=False))\n\n current_size += append_size\n\n return start_index, np.concatenate(batch), np.concatenate(batch_puzzle_indices)\n\n\nclass PuzzleDatasetConfig(pydantic.BaseModel):\n seed: int\n dataset_paths: List[str]\n global_batch_size: int\n test_set_mode: bool\n epochs_per_iter: int # Batch X epochs in an iteration to reduce overhead.\n rank: int\n num_replicas: int\n\nclass PuzzleDataset(IterableDataset):\n def __init__(self, config: PuzzleDatasetConfig, split: str = \"train\"):\n super().__init__()\n self.config = config\n self.split = split\n\n # Merge multiple metadata\n prev_seq_len = None\n prev_vocab_size = None\n prev_pad_id = None\n prev_ignore_label_id = None\n prev_blank_identifier_id = None\n prev_sets = None\n prev_num_identifiers = None\n mean_puzzle_examples = 0\n total_puzzles = 0\n total_groups = 0\n num_identifiers = 0\n for dataset_path in config.dataset_paths:","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset.PuzzleDataset","uri":"program://TinyRecursiveModels/class/puzzle_dataset.PuzzleDataset#L52-L249","kind":"class","name":"PuzzleDataset","path":"puzzle_dataset.py","language":"python","start_line":52,"end_line":249,"context_start_line":32,"context_end_line":250,"code":" append_size = min(puzzle_size, global_batch_size - current_size)\n\n # Put into batch\n batch_puzzle_indices.append(np.full(append_size, puzzle_id, dtype=np.int32))\n batch.append(puzzle_start + np.random.choice(puzzle_size, append_size, replace=False))\n\n current_size += append_size\n\n return start_index, np.concatenate(batch), np.concatenate(batch_puzzle_indices)\n\n\nclass PuzzleDatasetConfig(pydantic.BaseModel):\n seed: int\n dataset_paths: List[str]\n global_batch_size: int\n test_set_mode: bool\n epochs_per_iter: int # Batch X epochs in an iteration to reduce overhead.\n rank: int\n num_replicas: int\n\nclass PuzzleDataset(IterableDataset):\n def __init__(self, config: PuzzleDatasetConfig, split: str = \"train\"):\n super().__init__()\n self.config = config\n self.split = split\n\n # Merge multiple metadata\n prev_seq_len = None\n prev_vocab_size = None\n prev_pad_id = None\n prev_ignore_label_id = None\n prev_blank_identifier_id = None\n prev_sets = None\n prev_num_identifiers = None\n mean_puzzle_examples = 0\n total_puzzles = 0\n total_groups = 0\n num_identifiers = 0\n for dataset_path in config.dataset_paths:\n current_metadata = self._load_metadata(dataset_path)\n if prev_seq_len is None:\n prev_seq_len = current_metadata.seq_len\n prev_vocab_size = current_metadata.vocab_size\n prev_pad_id = current_metadata.pad_id\n prev_ignore_label_id = current_metadata.ignore_label_id\n prev_blank_identifier_id = current_metadata.blank_identifier_id\n prev_sets = current_metadata.sets\n prev_num_identifiers = current_metadata.num_puzzle_identifiers\n else:\n assert prev_seq_len == current_metadata.seq_len\n assert prev_vocab_size == current_metadata.vocab_size\n assert prev_pad_id == current_metadata.pad_id\n assert prev_ignore_label_id == current_metadata.ignore_label_id\n assert prev_blank_identifier_id == current_metadata.blank_identifier_id\n assert prev_sets == current_metadata.sets\n assert prev_num_identifiers == current_metadata.num_puzzle_identifiers\n mean_puzzle_examples += current_metadata.mean_puzzle_examples*current_metadata.total_puzzles\n total_puzzles += current_metadata.total_puzzles\n total_groups += current_metadata.total_groups\n num_identifiers += current_metadata.num_puzzle_identifiers\n mean_puzzle_examples = mean_puzzle_examples / total_puzzles\n\n self.metadata = PuzzleDatasetMetadata(\n seq_len=prev_seq_len,\n vocab_size=prev_vocab_size,\n pad_id=prev_pad_id,\n ignore_label_id=prev_ignore_label_id,\n blank_identifier_id=prev_blank_identifier_id,\n num_puzzle_identifiers=num_identifiers,\n total_groups=total_groups,\n mean_puzzle_examples=mean_puzzle_examples,\n total_puzzles=total_puzzles,\n sets=prev_sets\n )\n\n # Checks\n assert self.config.global_batch_size % self.config.num_replicas == 0, f\"Global batch size {self.config.global_batch_size} must be multiples of nodes {self.config.num_replicas}.\"\n self.local_batch_size = self.config.global_batch_size // self.config.num_replicas\n\n # State\n self._data = None\n self._iters = 0\n\n def _load_metadata(self, dataset_path) -> PuzzleDatasetMetadata:\n with open(os.path.join(dataset_path, self.split, \"dataset.json\"), \"r\") as f:\n return PuzzleDatasetMetadata(**json.load(f))\n\n def _lazy_load_dataset(self):\n if self._data is not None:\n return\n\n field_mmap_modes = {\n \"inputs\": \"r\",\n \"labels\": \"r\",\n\n # Keep indices in memory\n \"puzzle_identifiers\": None,\n \"puzzle_indices\": None,\n \"group_indices\": None\n }\n\n # Load data\n self._data = {}\n for set_name in self.metadata.sets: # Load subset\n for i, dataset_path in enumerate(self.config.dataset_paths):\n if i > 0:\n set_name_ = set_name + str(i)\n else:\n set_name_ = set_name\n self._data[set_name_] = {\n field_name: np.load(os.path.join(dataset_path, self.split, f\"{set_name}__{field_name}.npy\"), mmap_mode=mmap_mode)\n for field_name, mmap_mode in field_mmap_modes.items()\n }\n\n\n def _collate_batch(self, batch):\n # Convert dtype\n batch = {k: v.astype(np.int32) for k, v in batch.items()}\n\n # Convert ignore label IDs\n if self.metadata.ignore_label_id is not None:\n batch[\"labels\"][batch[\"labels\"] == self.metadata.ignore_label_id] = IGNORE_LABEL_ID\n\n # Pad\n if batch[\"puzzle_identifiers\"].size < self.local_batch_size:\n pad_size = self.local_batch_size - batch[\"puzzle_identifiers\"].size\n pad_values = {\n \"inputs\": self.metadata.pad_id,\n \"labels\": IGNORE_LABEL_ID,\n \"puzzle_identifiers\": self.metadata.blank_identifier_id\n }\n batch = {k: np.pad(v, ((0, pad_size), ) + ((0, 0), ) * (v.ndim - 1), constant_values=pad_values[k]) for k, v in batch.items()}\n\n # To tensor\n return {k: torch.from_numpy(v) for k, v in batch.items()}\n \n def _iter_test(self):\n for set_i, (set_name, dataset) in enumerate(self._data.items()): # type: ignore\n total_examples = len(dataset[\"inputs\"])\n\n # Load examples one by one\n start_index = 0\n while start_index < total_examples:\n # Compute indices\n end_index = min(total_examples, start_index + self.config.global_batch_size)\n \n local_start = start_index + self.config.rank * self.local_batch_size\n local_end = min(start_index + (self.config.rank + 1) * self.local_batch_size, end_index)\n \n # Get batch of examples, and also puzzle IDs\n puzzle_indices = []\n puzzle_index = np.searchsorted(dataset[\"puzzle_indices\"], local_start, side=\"right\") - 1\n for i in range(local_start, local_end):\n while puzzle_index + 1 < len(dataset[\"puzzle_indices\"]) and i >= dataset[\"puzzle_indices\"][puzzle_index + 1]:\n puzzle_index += 1\n\n puzzle_indices.append(puzzle_index)\n \n batch = self._collate_batch({\n \"inputs\": dataset[\"inputs\"][local_start: local_end],\n \"labels\": dataset[\"labels\"][local_start: local_end],\n \"puzzle_identifiers\": dataset[\"puzzle_identifiers\"][puzzle_indices]\n })\n\n yield set_name, batch, end_index - start_index\n \n # Advance to next batch\n start_index += self.config.global_batch_size\n\n def _iter_train(self):\n for set_name, dataset in self._data.items(): # type: ignore\n # Increase epoch count\n self._iters += 1\n\n # Randomly shuffle groups\n rng = np.random.Generator(np.random.Philox(seed=self.config.seed + self._iters))\n\n group_order = np.concatenate([rng.permutation(dataset[\"group_indices\"].size - 1) for _i in range(self.config.epochs_per_iter)])\n start_index = 0\n \n while start_index < group_order.size:\n start_index, batch_indices, batch_puzzle_indices = _sample_batch(\n rng,\n group_order=group_order,\n puzzle_indices=dataset[\"puzzle_indices\"],\n group_indices=dataset[\"group_indices\"],\n start_index=start_index,\n global_batch_size=self.config.global_batch_size,\n )\n\n # Select current rank and collate\n global_effective_batch_size = batch_puzzle_indices.size # Global effective batch size, excluding pads\n\n # Drop last batch\n if global_effective_batch_size < self.config.global_batch_size:\n break\n\n batch_indices = batch_indices [self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size]\n batch_puzzle_indices = batch_puzzle_indices[self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size]\n batch = self._collate_batch({\n \"inputs\": dataset[\"inputs\"][batch_indices],\n \"labels\": dataset[\"labels\"][batch_indices],\n \"puzzle_identifiers\": dataset[\"puzzle_identifiers\"][batch_puzzle_indices]\n })\n\n yield set_name, batch, global_effective_batch_size\n \n def __iter__(self):\n worker_info = get_worker_info()\n assert worker_info is None or worker_info.num_workers == 1, \"Multithreaded data loading is not currently supported.\"\n \n self._lazy_load_dataset()\n \n # Iterate using specified mode\n if self.config.test_set_mode:\n yield from self._iter_test()\n else:\n yield from self._iter_train()\n","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset.__init__","uri":"program://TinyRecursiveModels/function/puzzle_dataset.__init__#L53-L113","kind":"function","name":"__init__","path":"puzzle_dataset.py","language":"python","start_line":53,"end_line":113,"context_start_line":33,"context_end_line":133,"code":"\n # Put into batch\n batch_puzzle_indices.append(np.full(append_size, puzzle_id, dtype=np.int32))\n batch.append(puzzle_start + np.random.choice(puzzle_size, append_size, replace=False))\n\n current_size += append_size\n\n return start_index, np.concatenate(batch), np.concatenate(batch_puzzle_indices)\n\n\nclass PuzzleDatasetConfig(pydantic.BaseModel):\n seed: int\n dataset_paths: List[str]\n global_batch_size: int\n test_set_mode: bool\n epochs_per_iter: int # Batch X epochs in an iteration to reduce overhead.\n rank: int\n num_replicas: int\n\nclass PuzzleDataset(IterableDataset):\n def __init__(self, config: PuzzleDatasetConfig, split: str = \"train\"):\n super().__init__()\n self.config = config\n self.split = split\n\n # Merge multiple metadata\n prev_seq_len = None\n prev_vocab_size = None\n prev_pad_id = None\n prev_ignore_label_id = None\n prev_blank_identifier_id = None\n prev_sets = None\n prev_num_identifiers = None\n mean_puzzle_examples = 0\n total_puzzles = 0\n total_groups = 0\n num_identifiers = 0\n for dataset_path in config.dataset_paths:\n current_metadata = self._load_metadata(dataset_path)\n if prev_seq_len is None:\n prev_seq_len = current_metadata.seq_len\n prev_vocab_size = current_metadata.vocab_size\n prev_pad_id = current_metadata.pad_id\n prev_ignore_label_id = current_metadata.ignore_label_id\n prev_blank_identifier_id = current_metadata.blank_identifier_id\n prev_sets = current_metadata.sets\n prev_num_identifiers = current_metadata.num_puzzle_identifiers\n else:\n assert prev_seq_len == current_metadata.seq_len\n assert prev_vocab_size == current_metadata.vocab_size\n assert prev_pad_id == current_metadata.pad_id\n assert prev_ignore_label_id == current_metadata.ignore_label_id\n assert prev_blank_identifier_id == current_metadata.blank_identifier_id\n assert prev_sets == current_metadata.sets\n assert prev_num_identifiers == current_metadata.num_puzzle_identifiers\n mean_puzzle_examples += current_metadata.mean_puzzle_examples*current_metadata.total_puzzles\n total_puzzles += current_metadata.total_puzzles\n total_groups += current_metadata.total_groups\n num_identifiers += current_metadata.num_puzzle_identifiers\n mean_puzzle_examples = mean_puzzle_examples / total_puzzles\n\n self.metadata = PuzzleDatasetMetadata(\n seq_len=prev_seq_len,\n vocab_size=prev_vocab_size,\n pad_id=prev_pad_id,\n ignore_label_id=prev_ignore_label_id,\n blank_identifier_id=prev_blank_identifier_id,\n num_puzzle_identifiers=num_identifiers,\n total_groups=total_groups,\n mean_puzzle_examples=mean_puzzle_examples,\n total_puzzles=total_puzzles,\n sets=prev_sets\n )\n\n # Checks\n assert self.config.global_batch_size % self.config.num_replicas == 0, f\"Global batch size {self.config.global_batch_size} must be multiples of nodes {self.config.num_replicas}.\"\n self.local_batch_size = self.config.global_batch_size // self.config.num_replicas\n\n # State\n self._data = None\n self._iters = 0\n\n def _load_metadata(self, dataset_path) -> PuzzleDatasetMetadata:\n with open(os.path.join(dataset_path, self.split, \"dataset.json\"), \"r\") as f:\n return PuzzleDatasetMetadata(**json.load(f))\n\n def _lazy_load_dataset(self):\n if self._data is not None:\n return\n\n field_mmap_modes = {\n \"inputs\": \"r\",\n \"labels\": \"r\",\n\n # Keep indices in memory\n \"puzzle_identifiers\": None,\n \"puzzle_indices\": None,\n \"group_indices\": None\n }\n\n # Load data","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset._load_metadata","uri":"program://TinyRecursiveModels/function/puzzle_dataset._load_metadata#L115-L117","kind":"function","name":"_load_metadata","path":"puzzle_dataset.py","language":"python","start_line":115,"end_line":117,"context_start_line":95,"context_end_line":137,"code":" seq_len=prev_seq_len,\n vocab_size=prev_vocab_size,\n pad_id=prev_pad_id,\n ignore_label_id=prev_ignore_label_id,\n blank_identifier_id=prev_blank_identifier_id,\n num_puzzle_identifiers=num_identifiers,\n total_groups=total_groups,\n mean_puzzle_examples=mean_puzzle_examples,\n total_puzzles=total_puzzles,\n sets=prev_sets\n )\n\n # Checks\n assert self.config.global_batch_size % self.config.num_replicas == 0, f\"Global batch size {self.config.global_batch_size} must be multiples of nodes {self.config.num_replicas}.\"\n self.local_batch_size = self.config.global_batch_size // self.config.num_replicas\n\n # State\n self._data = None\n self._iters = 0\n\n def _load_metadata(self, dataset_path) -> PuzzleDatasetMetadata:\n with open(os.path.join(dataset_path, self.split, \"dataset.json\"), \"r\") as f:\n return PuzzleDatasetMetadata(**json.load(f))\n\n def _lazy_load_dataset(self):\n if self._data is not None:\n return\n\n field_mmap_modes = {\n \"inputs\": \"r\",\n \"labels\": \"r\",\n\n # Keep indices in memory\n \"puzzle_identifiers\": None,\n \"puzzle_indices\": None,\n \"group_indices\": None\n }\n\n # Load data\n self._data = {}\n for set_name in self.metadata.sets: # Load subset\n for i, dataset_path in enumerate(self.config.dataset_paths):\n if i > 0:","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset._lazy_load_dataset","uri":"program://TinyRecursiveModels/function/puzzle_dataset._lazy_load_dataset#L119-L144","kind":"function","name":"_lazy_load_dataset","path":"puzzle_dataset.py","language":"python","start_line":119,"end_line":144,"context_start_line":99,"context_end_line":164,"code":" blank_identifier_id=prev_blank_identifier_id,\n num_puzzle_identifiers=num_identifiers,\n total_groups=total_groups,\n mean_puzzle_examples=mean_puzzle_examples,\n total_puzzles=total_puzzles,\n sets=prev_sets\n )\n\n # Checks\n assert self.config.global_batch_size % self.config.num_replicas == 0, f\"Global batch size {self.config.global_batch_size} must be multiples of nodes {self.config.num_replicas}.\"\n self.local_batch_size = self.config.global_batch_size // self.config.num_replicas\n\n # State\n self._data = None\n self._iters = 0\n\n def _load_metadata(self, dataset_path) -> PuzzleDatasetMetadata:\n with open(os.path.join(dataset_path, self.split, \"dataset.json\"), \"r\") as f:\n return PuzzleDatasetMetadata(**json.load(f))\n\n def _lazy_load_dataset(self):\n if self._data is not None:\n return\n\n field_mmap_modes = {\n \"inputs\": \"r\",\n \"labels\": \"r\",\n\n # Keep indices in memory\n \"puzzle_identifiers\": None,\n \"puzzle_indices\": None,\n \"group_indices\": None\n }\n\n # Load data\n self._data = {}\n for set_name in self.metadata.sets: # Load subset\n for i, dataset_path in enumerate(self.config.dataset_paths):\n if i > 0:\n set_name_ = set_name + str(i)\n else:\n set_name_ = set_name\n self._data[set_name_] = {\n field_name: np.load(os.path.join(dataset_path, self.split, f\"{set_name}__{field_name}.npy\"), mmap_mode=mmap_mode)\n for field_name, mmap_mode in field_mmap_modes.items()\n }\n\n\n def _collate_batch(self, batch):\n # Convert dtype\n batch = {k: v.astype(np.int32) for k, v in batch.items()}\n\n # Convert ignore label IDs\n if self.metadata.ignore_label_id is not None:\n batch[\"labels\"][batch[\"labels\"] == self.metadata.ignore_label_id] = IGNORE_LABEL_ID\n\n # Pad\n if batch[\"puzzle_identifiers\"].size < self.local_batch_size:\n pad_size = self.local_batch_size - batch[\"puzzle_identifiers\"].size\n pad_values = {\n \"inputs\": self.metadata.pad_id,\n \"labels\": IGNORE_LABEL_ID,\n \"puzzle_identifiers\": self.metadata.blank_identifier_id\n }\n batch = {k: np.pad(v, ((0, pad_size), ) + ((0, 0), ) * (v.ndim - 1), constant_values=pad_values[k]) for k, v in batch.items()}\n","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset._collate_batch","uri":"program://TinyRecursiveModels/function/puzzle_dataset._collate_batch#L147-L166","kind":"function","name":"_collate_batch","path":"puzzle_dataset.py","language":"python","start_line":147,"end_line":166,"context_start_line":127,"context_end_line":186,"code":" # Keep indices in memory\n \"puzzle_identifiers\": None,\n \"puzzle_indices\": None,\n \"group_indices\": None\n }\n\n # Load data\n self._data = {}\n for set_name in self.metadata.sets: # Load subset\n for i, dataset_path in enumerate(self.config.dataset_paths):\n if i > 0:\n set_name_ = set_name + str(i)\n else:\n set_name_ = set_name\n self._data[set_name_] = {\n field_name: np.load(os.path.join(dataset_path, self.split, f\"{set_name}__{field_name}.npy\"), mmap_mode=mmap_mode)\n for field_name, mmap_mode in field_mmap_modes.items()\n }\n\n\n def _collate_batch(self, batch):\n # Convert dtype\n batch = {k: v.astype(np.int32) for k, v in batch.items()}\n\n # Convert ignore label IDs\n if self.metadata.ignore_label_id is not None:\n batch[\"labels\"][batch[\"labels\"] == self.metadata.ignore_label_id] = IGNORE_LABEL_ID\n\n # Pad\n if batch[\"puzzle_identifiers\"].size < self.local_batch_size:\n pad_size = self.local_batch_size - batch[\"puzzle_identifiers\"].size\n pad_values = {\n \"inputs\": self.metadata.pad_id,\n \"labels\": IGNORE_LABEL_ID,\n \"puzzle_identifiers\": self.metadata.blank_identifier_id\n }\n batch = {k: np.pad(v, ((0, pad_size), ) + ((0, 0), ) * (v.ndim - 1), constant_values=pad_values[k]) for k, v in batch.items()}\n\n # To tensor\n return {k: torch.from_numpy(v) for k, v in batch.items()}\n \n def _iter_test(self):\n for set_i, (set_name, dataset) in enumerate(self._data.items()): # type: ignore\n total_examples = len(dataset[\"inputs\"])\n\n # Load examples one by one\n start_index = 0\n while start_index < total_examples:\n # Compute indices\n end_index = min(total_examples, start_index + self.config.global_batch_size)\n \n local_start = start_index + self.config.rank * self.local_batch_size\n local_end = min(start_index + (self.config.rank + 1) * self.local_batch_size, end_index)\n \n # Get batch of examples, and also puzzle IDs\n puzzle_indices = []\n puzzle_index = np.searchsorted(dataset[\"puzzle_indices\"], local_start, side=\"right\") - 1\n for i in range(local_start, local_end):\n while puzzle_index + 1 < len(dataset[\"puzzle_indices\"]) and i >= dataset[\"puzzle_indices\"][puzzle_index + 1]:\n puzzle_index += 1","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset._iter_test","uri":"program://TinyRecursiveModels/function/puzzle_dataset._iter_test#L168-L199","kind":"function","name":"_iter_test","path":"puzzle_dataset.py","language":"python","start_line":168,"end_line":199,"context_start_line":148,"context_end_line":219,"code":" # Convert dtype\n batch = {k: v.astype(np.int32) for k, v in batch.items()}\n\n # Convert ignore label IDs\n if self.metadata.ignore_label_id is not None:\n batch[\"labels\"][batch[\"labels\"] == self.metadata.ignore_label_id] = IGNORE_LABEL_ID\n\n # Pad\n if batch[\"puzzle_identifiers\"].size < self.local_batch_size:\n pad_size = self.local_batch_size - batch[\"puzzle_identifiers\"].size\n pad_values = {\n \"inputs\": self.metadata.pad_id,\n \"labels\": IGNORE_LABEL_ID,\n \"puzzle_identifiers\": self.metadata.blank_identifier_id\n }\n batch = {k: np.pad(v, ((0, pad_size), ) + ((0, 0), ) * (v.ndim - 1), constant_values=pad_values[k]) for k, v in batch.items()}\n\n # To tensor\n return {k: torch.from_numpy(v) for k, v in batch.items()}\n \n def _iter_test(self):\n for set_i, (set_name, dataset) in enumerate(self._data.items()): # type: ignore\n total_examples = len(dataset[\"inputs\"])\n\n # Load examples one by one\n start_index = 0\n while start_index < total_examples:\n # Compute indices\n end_index = min(total_examples, start_index + self.config.global_batch_size)\n \n local_start = start_index + self.config.rank * self.local_batch_size\n local_end = min(start_index + (self.config.rank + 1) * self.local_batch_size, end_index)\n \n # Get batch of examples, and also puzzle IDs\n puzzle_indices = []\n puzzle_index = np.searchsorted(dataset[\"puzzle_indices\"], local_start, side=\"right\") - 1\n for i in range(local_start, local_end):\n while puzzle_index + 1 < len(dataset[\"puzzle_indices\"]) and i >= dataset[\"puzzle_indices\"][puzzle_index + 1]:\n puzzle_index += 1\n\n puzzle_indices.append(puzzle_index)\n \n batch = self._collate_batch({\n \"inputs\": dataset[\"inputs\"][local_start: local_end],\n \"labels\": dataset[\"labels\"][local_start: local_end],\n \"puzzle_identifiers\": dataset[\"puzzle_identifiers\"][puzzle_indices]\n })\n\n yield set_name, batch, end_index - start_index\n \n # Advance to next batch\n start_index += self.config.global_batch_size\n\n def _iter_train(self):\n for set_name, dataset in self._data.items(): # type: ignore\n # Increase epoch count\n self._iters += 1\n\n # Randomly shuffle groups\n rng = np.random.Generator(np.random.Philox(seed=self.config.seed + self._iters))\n\n group_order = np.concatenate([rng.permutation(dataset[\"group_indices\"].size - 1) for _i in range(self.config.epochs_per_iter)])\n start_index = 0\n \n while start_index < group_order.size:\n start_index, batch_indices, batch_puzzle_indices = _sample_batch(\n rng,\n group_order=group_order,\n puzzle_indices=dataset[\"puzzle_indices\"],\n group_indices=dataset[\"group_indices\"],\n start_index=start_index,\n global_batch_size=self.config.global_batch_size,","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset._iter_train","uri":"program://TinyRecursiveModels/function/puzzle_dataset._iter_train#L201-L237","kind":"function","name":"_iter_train","path":"puzzle_dataset.py","language":"python","start_line":201,"end_line":237,"context_start_line":181,"context_end_line":250,"code":" # Get batch of examples, and also puzzle IDs\n puzzle_indices = []\n puzzle_index = np.searchsorted(dataset[\"puzzle_indices\"], local_start, side=\"right\") - 1\n for i in range(local_start, local_end):\n while puzzle_index + 1 < len(dataset[\"puzzle_indices\"]) and i >= dataset[\"puzzle_indices\"][puzzle_index + 1]:\n puzzle_index += 1\n\n puzzle_indices.append(puzzle_index)\n \n batch = self._collate_batch({\n \"inputs\": dataset[\"inputs\"][local_start: local_end],\n \"labels\": dataset[\"labels\"][local_start: local_end],\n \"puzzle_identifiers\": dataset[\"puzzle_identifiers\"][puzzle_indices]\n })\n\n yield set_name, batch, end_index - start_index\n \n # Advance to next batch\n start_index += self.config.global_batch_size\n\n def _iter_train(self):\n for set_name, dataset in self._data.items(): # type: ignore\n # Increase epoch count\n self._iters += 1\n\n # Randomly shuffle groups\n rng = np.random.Generator(np.random.Philox(seed=self.config.seed + self._iters))\n\n group_order = np.concatenate([rng.permutation(dataset[\"group_indices\"].size - 1) for _i in range(self.config.epochs_per_iter)])\n start_index = 0\n \n while start_index < group_order.size:\n start_index, batch_indices, batch_puzzle_indices = _sample_batch(\n rng,\n group_order=group_order,\n puzzle_indices=dataset[\"puzzle_indices\"],\n group_indices=dataset[\"group_indices\"],\n start_index=start_index,\n global_batch_size=self.config.global_batch_size,\n )\n\n # Select current rank and collate\n global_effective_batch_size = batch_puzzle_indices.size # Global effective batch size, excluding pads\n\n # Drop last batch\n if global_effective_batch_size < self.config.global_batch_size:\n break\n\n batch_indices = batch_indices [self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size]\n batch_puzzle_indices = batch_puzzle_indices[self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size]\n batch = self._collate_batch({\n \"inputs\": dataset[\"inputs\"][batch_indices],\n \"labels\": dataset[\"labels\"][batch_indices],\n \"puzzle_identifiers\": dataset[\"puzzle_identifiers\"][batch_puzzle_indices]\n })\n\n yield set_name, batch, global_effective_batch_size\n \n def __iter__(self):\n worker_info = get_worker_info()\n assert worker_info is None or worker_info.num_workers == 1, \"Multithreaded data loading is not currently supported.\"\n \n self._lazy_load_dataset()\n \n # Iterate using specified mode\n if self.config.test_set_mode:\n yield from self._iter_test()\n else:\n yield from self._iter_train()\n","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:puzzle_dataset.__iter__","uri":"program://TinyRecursiveModels/function/puzzle_dataset.__iter__#L239-L249","kind":"function","name":"__iter__","path":"puzzle_dataset.py","language":"python","start_line":239,"end_line":249,"context_start_line":219,"context_end_line":250,"code":" global_batch_size=self.config.global_batch_size,\n )\n\n # Select current rank and collate\n global_effective_batch_size = batch_puzzle_indices.size # Global effective batch size, excluding pads\n\n # Drop last batch\n if global_effective_batch_size < self.config.global_batch_size:\n break\n\n batch_indices = batch_indices [self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size]\n batch_puzzle_indices = batch_puzzle_indices[self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size]\n batch = self._collate_batch({\n \"inputs\": dataset[\"inputs\"][batch_indices],\n \"labels\": dataset[\"labels\"][batch_indices],\n \"puzzle_identifiers\": dataset[\"puzzle_identifiers\"][batch_puzzle_indices]\n })\n\n yield set_name, batch, global_effective_batch_size\n \n def __iter__(self):\n worker_info = get_worker_info()\n assert worker_info is None or worker_info.num_workers == 1, \"Multithreaded data loading is not currently supported.\"\n \n self._lazy_load_dataset()\n \n # Iterate using specified mode\n if self.config.test_set_mode:\n yield from self._iter_test()\n else:\n yield from self._iter_train()\n","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.common","uri":"program://TinyRecursiveModels/module/models.common#L1-L32","kind":"module","name":"models.common","path":"models/common.py","language":"python","start_line":1,"end_line":32,"context_start_line":1,"context_end_line":32,"code":"import math\n\nimport torch\nfrom torch import nn\n\n\ndef trunc_normal_init_(tensor: torch.Tensor, std: float = 1.0, lower: float = -2.0, upper: float = 2.0):\n # NOTE: PyTorch nn.init.trunc_normal_ is not mathematically correct, the std dev is not actually the std dev of initialized tensor\n # This function is a PyTorch version of jax truncated normal init (default init method in flax)\n # https://github.com/jax-ml/jax/blob/main/jax/_src/random.py#L807-L848\n # https://github.com/jax-ml/jax/blob/main/jax/_src/nn/initializers.py#L162-L199\n\n with torch.no_grad():\n if std == 0:\n tensor.zero_()\n else:\n sqrt2 = math.sqrt(2)\n a = math.erf(lower / sqrt2)\n b = math.erf(upper / sqrt2)\n z = (b - a) / 2\n\n c = (2 * math.pi) ** -0.5\n pdf_u = c * math.exp(-0.5 * lower ** 2)\n pdf_l = c * math.exp(-0.5 * upper ** 2)\n comp_std = std / math.sqrt(1 - (upper * pdf_u - lower * pdf_l) / z - ((pdf_u - pdf_l) / z) ** 2)\n\n tensor.uniform_(a, b)\n tensor.erfinv_()\n tensor.mul_(sqrt2 * comp_std)\n tensor.clip_(lower * comp_std, upper * comp_std)\n\n return tensor","source_hash":"fa749ad9b68ac0852f9cda157baa3a9c2ff8abaee973751b32b7cd010a4cf859","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.common.trunc_normal_init_","uri":"program://TinyRecursiveModels/function/models.common.trunc_normal_init_#L7-L32","kind":"function","name":"trunc_normal_init_","path":"models/common.py","language":"python","start_line":7,"end_line":32,"context_start_line":1,"context_end_line":32,"code":"import math\n\nimport torch\nfrom torch import nn\n\n\ndef trunc_normal_init_(tensor: torch.Tensor, std: float = 1.0, lower: float = -2.0, upper: float = 2.0):\n # NOTE: PyTorch nn.init.trunc_normal_ is not mathematically correct, the std dev is not actually the std dev of initialized tensor\n # This function is a PyTorch version of jax truncated normal init (default init method in flax)\n # https://github.com/jax-ml/jax/blob/main/jax/_src/random.py#L807-L848\n # https://github.com/jax-ml/jax/blob/main/jax/_src/nn/initializers.py#L162-L199\n\n with torch.no_grad():\n if std == 0:\n tensor.zero_()\n else:\n sqrt2 = math.sqrt(2)\n a = math.erf(lower / sqrt2)\n b = math.erf(upper / sqrt2)\n z = (b - a) / 2\n\n c = (2 * math.pi) ** -0.5\n pdf_u = c * math.exp(-0.5 * lower ** 2)\n pdf_l = c * math.exp(-0.5 * upper ** 2)\n comp_std = std / math.sqrt(1 - (upper * pdf_u - lower * pdf_l) / z - ((pdf_u - pdf_l) / z) ** 2)\n\n tensor.uniform_(a, b)\n tensor.erfinv_()\n tensor.mul_(sqrt2 * comp_std)\n tensor.clip_(lower * comp_std, upper * comp_std)\n\n return tensor","source_hash":"fa749ad9b68ac0852f9cda157baa3a9c2ff8abaee973751b32b7cd010a4cf859","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.losses","uri":"program://TinyRecursiveModels/module/models.losses#L1-L103","kind":"module","name":"models.losses","path":"models/losses.py","language":"python","start_line":1,"end_line":103,"context_start_line":1,"context_end_line":103,"code":"from typing import Any, Tuple, Dict, Sequence, Optional\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nimport math\n\nIGNORE_LABEL_ID = -100\n\n\ndef s(x, epsilon=1e-30):\n return torch.where(\n x<0,\n 1/(1-x+ epsilon),\n x + 1\n )\n\n\ndef log_stablemax(x, dim=-1):\n s_x = s(x)\n return torch.log(s_x/torch.sum(s_x, dim=dim, keepdim=True))\n\n\ndef stablemax_cross_entropy(logits, labels, ignore_index: int = -100, valid_mask=None):\n logprobs = log_stablemax(logits.to(torch.float64), dim=-1)\n\n if valid_mask is None:\n valid_mask = (labels != ignore_index)\n transformed_labels = torch.where(valid_mask, labels, 0)\n prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)\n\n return -torch.where(valid_mask, prediction_logprobs, 0)\n\n\ndef softmax_cross_entropy(logits, labels, ignore_index: int = -100):\n # Cast logits to f32\n # Flatten logits\n return F.cross_entropy(logits.to(torch.float32).view(-1, logits.shape[-1]), labels.to(torch.long).view(-1), ignore_index=ignore_index, reduction=\"none\").view(labels.shape)\n\n\nclass ACTLossHead(nn.Module):\n def __init__(self, model: nn.Module, loss_type: str):\n super().__init__()\n self.model = model\n self.loss_fn = globals()[loss_type]\n \n def initial_carry(self, *args, **kwargs):\n return self.model.initial_carry(*args, **kwargs) # type: ignore\n\n def forward(\n self,\n return_keys: Sequence[str],\n # Model args\n **model_kwargs,\n ) -> Tuple[Any, torch.Tensor, Dict[str, torch.Tensor], Optional[Dict[str, torch.Tensor]], torch.Tensor]:\n # Model logits\n # B x SeqLen x D\n new_carry, outputs = self.model(**model_kwargs)\n labels = new_carry.current_data[\"labels\"]\n\n with torch.no_grad():\n # Preds\n outputs[\"preds\"] = torch.argmax(outputs[\"logits\"], dim=-1)\n\n # Correctness\n mask = (labels != IGNORE_LABEL_ID)\n loss_counts = mask.sum(-1)\n loss_divisor = loss_counts.clamp_min(1).unsqueeze(-1) # Avoid NaNs in division\n\n is_correct = mask & (torch.argmax(outputs[\"logits\"], dim=-1) == labels)\n seq_is_correct = is_correct.sum(-1) == loss_counts\n \n # Metrics (halted)\n valid_metrics = new_carry.halted & (loss_counts > 0)\n metrics = {\n \"count\": valid_metrics.sum(),\n \n \"accuracy\": torch.where(valid_metrics, (is_correct.to(torch.float32) / loss_divisor).sum(-1), 0).sum(),\n \"exact_accuracy\": (valid_metrics & seq_is_correct).sum(),\n\n \"q_halt_accuracy\": (valid_metrics & ((outputs[\"q_halt_logits\"] >= 0) == seq_is_correct)).sum(),\n \"steps\": torch.where(valid_metrics, new_carry.steps, 0).sum(),\n }\n\n # Losses\n\n lm_loss = (self.loss_fn(outputs[\"logits\"], labels, ignore_index=IGNORE_LABEL_ID, valid_mask=mask) / loss_divisor).sum()\n q_halt_loss = F.binary_cross_entropy_with_logits(outputs[\"q_halt_logits\"], seq_is_correct.to(outputs[\"q_halt_logits\"].dtype), reduction=\"sum\")\n metrics.update({\n \"lm_loss\": lm_loss.detach(),\n \"q_halt_loss\": q_halt_loss.detach(),\n })\n # Q continue (bootstrapping target loss); Alexia: This fits Q-learning, but seems totally unecessary\n q_continue_loss = 0\n if \"target_q_continue\" in outputs:\n q_continue_loss = F.binary_cross_entropy_with_logits(outputs[\"q_continue_logits\"], outputs[\"target_q_continue\"], reduction=\"sum\")\n\n metrics[\"q_continue_loss\"] = q_continue_loss.detach()\n # Filter outputs for return\n detached_outputs = {k: outputs[k].detach() for k in return_keys if k in outputs}\n\n return new_carry, lm_loss + 0.5 * (q_halt_loss + q_continue_loss), metrics, detached_outputs, new_carry.halted.all()\n","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.losses.s","uri":"program://TinyRecursiveModels/function/models.losses.s#L11-L16","kind":"function","name":"s","path":"models/losses.py","language":"python","start_line":11,"end_line":16,"context_start_line":1,"context_end_line":36,"code":"from typing import Any, Tuple, Dict, Sequence, Optional\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nimport math\n\nIGNORE_LABEL_ID = -100\n\n\ndef s(x, epsilon=1e-30):\n return torch.where(\n x<0,\n 1/(1-x+ epsilon),\n x + 1\n )\n\n\ndef log_stablemax(x, dim=-1):\n s_x = s(x)\n return torch.log(s_x/torch.sum(s_x, dim=dim, keepdim=True))\n\n\ndef stablemax_cross_entropy(logits, labels, ignore_index: int = -100, valid_mask=None):\n logprobs = log_stablemax(logits.to(torch.float64), dim=-1)\n\n if valid_mask is None:\n valid_mask = (labels != ignore_index)\n transformed_labels = torch.where(valid_mask, labels, 0)\n prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)\n\n return -torch.where(valid_mask, prediction_logprobs, 0)\n\n\ndef softmax_cross_entropy(logits, labels, ignore_index: int = -100):\n # Cast logits to f32","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.losses.log_stablemax","uri":"program://TinyRecursiveModels/function/models.losses.log_stablemax#L19-L21","kind":"function","name":"log_stablemax","path":"models/losses.py","language":"python","start_line":19,"end_line":21,"context_start_line":1,"context_end_line":41,"code":"from typing import Any, Tuple, Dict, Sequence, Optional\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nimport math\n\nIGNORE_LABEL_ID = -100\n\n\ndef s(x, epsilon=1e-30):\n return torch.where(\n x<0,\n 1/(1-x+ epsilon),\n x + 1\n )\n\n\ndef log_stablemax(x, dim=-1):\n s_x = s(x)\n return torch.log(s_x/torch.sum(s_x, dim=dim, keepdim=True))\n\n\ndef stablemax_cross_entropy(logits, labels, ignore_index: int = -100, valid_mask=None):\n logprobs = log_stablemax(logits.to(torch.float64), dim=-1)\n\n if valid_mask is None:\n valid_mask = (labels != ignore_index)\n transformed_labels = torch.where(valid_mask, labels, 0)\n prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)\n\n return -torch.where(valid_mask, prediction_logprobs, 0)\n\n\ndef softmax_cross_entropy(logits, labels, ignore_index: int = -100):\n # Cast logits to f32\n # Flatten logits\n return F.cross_entropy(logits.to(torch.float32).view(-1, logits.shape[-1]), labels.to(torch.long).view(-1), ignore_index=ignore_index, reduction=\"none\").view(labels.shape)\n\n\nclass ACTLossHead(nn.Module):","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.losses.stablemax_cross_entropy","uri":"program://TinyRecursiveModels/function/models.losses.stablemax_cross_entropy#L24-L32","kind":"function","name":"stablemax_cross_entropy","path":"models/losses.py","language":"python","start_line":24,"end_line":32,"context_start_line":4,"context_end_line":52,"code":"import torch.nn.functional as F\nfrom torch import nn\nimport math\n\nIGNORE_LABEL_ID = -100\n\n\ndef s(x, epsilon=1e-30):\n return torch.where(\n x<0,\n 1/(1-x+ epsilon),\n x + 1\n )\n\n\ndef log_stablemax(x, dim=-1):\n s_x = s(x)\n return torch.log(s_x/torch.sum(s_x, dim=dim, keepdim=True))\n\n\ndef stablemax_cross_entropy(logits, labels, ignore_index: int = -100, valid_mask=None):\n logprobs = log_stablemax(logits.to(torch.float64), dim=-1)\n\n if valid_mask is None:\n valid_mask = (labels != ignore_index)\n transformed_labels = torch.where(valid_mask, labels, 0)\n prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)\n\n return -torch.where(valid_mask, prediction_logprobs, 0)\n\n\ndef softmax_cross_entropy(logits, labels, ignore_index: int = -100):\n # Cast logits to f32\n # Flatten logits\n return F.cross_entropy(logits.to(torch.float32).view(-1, logits.shape[-1]), labels.to(torch.long).view(-1), ignore_index=ignore_index, reduction=\"none\").view(labels.shape)\n\n\nclass ACTLossHead(nn.Module):\n def __init__(self, model: nn.Module, loss_type: str):\n super().__init__()\n self.model = model\n self.loss_fn = globals()[loss_type]\n \n def initial_carry(self, *args, **kwargs):\n return self.model.initial_carry(*args, **kwargs) # type: ignore\n\n def forward(\n self,\n return_keys: Sequence[str],","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.losses.softmax_cross_entropy","uri":"program://TinyRecursiveModels/function/models.losses.softmax_cross_entropy#L35-L38","kind":"function","name":"softmax_cross_entropy","path":"models/losses.py","language":"python","start_line":35,"end_line":38,"context_start_line":15,"context_end_line":58,"code":" x + 1\n )\n\n\ndef log_stablemax(x, dim=-1):\n s_x = s(x)\n return torch.log(s_x/torch.sum(s_x, dim=dim, keepdim=True))\n\n\ndef stablemax_cross_entropy(logits, labels, ignore_index: int = -100, valid_mask=None):\n logprobs = log_stablemax(logits.to(torch.float64), dim=-1)\n\n if valid_mask is None:\n valid_mask = (labels != ignore_index)\n transformed_labels = torch.where(valid_mask, labels, 0)\n prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)\n\n return -torch.where(valid_mask, prediction_logprobs, 0)\n\n\ndef softmax_cross_entropy(logits, labels, ignore_index: int = -100):\n # Cast logits to f32\n # Flatten logits\n return F.cross_entropy(logits.to(torch.float32).view(-1, logits.shape[-1]), labels.to(torch.long).view(-1), ignore_index=ignore_index, reduction=\"none\").view(labels.shape)\n\n\nclass ACTLossHead(nn.Module):\n def __init__(self, model: nn.Module, loss_type: str):\n super().__init__()\n self.model = model\n self.loss_fn = globals()[loss_type]\n \n def initial_carry(self, *args, **kwargs):\n return self.model.initial_carry(*args, **kwargs) # type: ignore\n\n def forward(\n self,\n return_keys: Sequence[str],\n # Model args\n **model_kwargs,\n ) -> Tuple[Any, torch.Tensor, Dict[str, torch.Tensor], Optional[Dict[str, torch.Tensor]], torch.Tensor]:\n # Model logits\n # B x SeqLen x D\n new_carry, outputs = self.model(**model_kwargs)","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.losses.ACTLossHead","uri":"program://TinyRecursiveModels/class/models.losses.ACTLossHead#L41-L102","kind":"class","name":"ACTLossHead","path":"models/losses.py","language":"python","start_line":41,"end_line":102,"context_start_line":21,"context_end_line":103,"code":" return torch.log(s_x/torch.sum(s_x, dim=dim, keepdim=True))\n\n\ndef stablemax_cross_entropy(logits, labels, ignore_index: int = -100, valid_mask=None):\n logprobs = log_stablemax(logits.to(torch.float64), dim=-1)\n\n if valid_mask is None:\n valid_mask = (labels != ignore_index)\n transformed_labels = torch.where(valid_mask, labels, 0)\n prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)\n\n return -torch.where(valid_mask, prediction_logprobs, 0)\n\n\ndef softmax_cross_entropy(logits, labels, ignore_index: int = -100):\n # Cast logits to f32\n # Flatten logits\n return F.cross_entropy(logits.to(torch.float32).view(-1, logits.shape[-1]), labels.to(torch.long).view(-1), ignore_index=ignore_index, reduction=\"none\").view(labels.shape)\n\n\nclass ACTLossHead(nn.Module):\n def __init__(self, model: nn.Module, loss_type: str):\n super().__init__()\n self.model = model\n self.loss_fn = globals()[loss_type]\n \n def initial_carry(self, *args, **kwargs):\n return self.model.initial_carry(*args, **kwargs) # type: ignore\n\n def forward(\n self,\n return_keys: Sequence[str],\n # Model args\n **model_kwargs,\n ) -> Tuple[Any, torch.Tensor, Dict[str, torch.Tensor], Optional[Dict[str, torch.Tensor]], torch.Tensor]:\n # Model logits\n # B x SeqLen x D\n new_carry, outputs = self.model(**model_kwargs)\n labels = new_carry.current_data[\"labels\"]\n\n with torch.no_grad():\n # Preds\n outputs[\"preds\"] = torch.argmax(outputs[\"logits\"], dim=-1)\n\n # Correctness\n mask = (labels != IGNORE_LABEL_ID)\n loss_counts = mask.sum(-1)\n loss_divisor = loss_counts.clamp_min(1).unsqueeze(-1) # Avoid NaNs in division\n\n is_correct = mask & (torch.argmax(outputs[\"logits\"], dim=-1) == labels)\n seq_is_correct = is_correct.sum(-1) == loss_counts\n \n # Metrics (halted)\n valid_metrics = new_carry.halted & (loss_counts > 0)\n metrics = {\n \"count\": valid_metrics.sum(),\n \n \"accuracy\": torch.where(valid_metrics, (is_correct.to(torch.float32) / loss_divisor).sum(-1), 0).sum(),\n \"exact_accuracy\": (valid_metrics & seq_is_correct).sum(),\n\n \"q_halt_accuracy\": (valid_metrics & ((outputs[\"q_halt_logits\"] >= 0) == seq_is_correct)).sum(),\n \"steps\": torch.where(valid_metrics, new_carry.steps, 0).sum(),\n }\n\n # Losses\n\n lm_loss = (self.loss_fn(outputs[\"logits\"], labels, ignore_index=IGNORE_LABEL_ID, valid_mask=mask) / loss_divisor).sum()\n q_halt_loss = F.binary_cross_entropy_with_logits(outputs[\"q_halt_logits\"], seq_is_correct.to(outputs[\"q_halt_logits\"].dtype), reduction=\"sum\")\n metrics.update({\n \"lm_loss\": lm_loss.detach(),\n \"q_halt_loss\": q_halt_loss.detach(),\n })\n # Q continue (bootstrapping target loss); Alexia: This fits Q-learning, but seems totally unecessary\n q_continue_loss = 0\n if \"target_q_continue\" in outputs:\n q_continue_loss = F.binary_cross_entropy_with_logits(outputs[\"q_continue_logits\"], outputs[\"target_q_continue\"], reduction=\"sum\")\n\n metrics[\"q_continue_loss\"] = q_continue_loss.detach()\n # Filter outputs for return\n detached_outputs = {k: outputs[k].detach() for k in return_keys if k in outputs}\n\n return new_carry, lm_loss + 0.5 * (q_halt_loss + q_continue_loss), metrics, detached_outputs, new_carry.halted.all()\n","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.losses.__init__","uri":"program://TinyRecursiveModels/function/models.losses.__init__#L42-L45","kind":"function","name":"__init__","path":"models/losses.py","language":"python","start_line":42,"end_line":45,"context_start_line":22,"context_end_line":65,"code":"\n\ndef stablemax_cross_entropy(logits, labels, ignore_index: int = -100, valid_mask=None):\n logprobs = log_stablemax(logits.to(torch.float64), dim=-1)\n\n if valid_mask is None:\n valid_mask = (labels != ignore_index)\n transformed_labels = torch.where(valid_mask, labels, 0)\n prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)\n\n return -torch.where(valid_mask, prediction_logprobs, 0)\n\n\ndef softmax_cross_entropy(logits, labels, ignore_index: int = -100):\n # Cast logits to f32\n # Flatten logits\n return F.cross_entropy(logits.to(torch.float32).view(-1, logits.shape[-1]), labels.to(torch.long).view(-1), ignore_index=ignore_index, reduction=\"none\").view(labels.shape)\n\n\nclass ACTLossHead(nn.Module):\n def __init__(self, model: nn.Module, loss_type: str):\n super().__init__()\n self.model = model\n self.loss_fn = globals()[loss_type]\n \n def initial_carry(self, *args, **kwargs):\n return self.model.initial_carry(*args, **kwargs) # type: ignore\n\n def forward(\n self,\n return_keys: Sequence[str],\n # Model args\n **model_kwargs,\n ) -> Tuple[Any, torch.Tensor, Dict[str, torch.Tensor], Optional[Dict[str, torch.Tensor]], torch.Tensor]:\n # Model logits\n # B x SeqLen x D\n new_carry, outputs = self.model(**model_kwargs)\n labels = new_carry.current_data[\"labels\"]\n\n with torch.no_grad():\n # Preds\n outputs[\"preds\"] = torch.argmax(outputs[\"logits\"], dim=-1)\n\n # Correctness","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.losses.initial_carry","uri":"program://TinyRecursiveModels/function/models.losses.initial_carry#L47-L48","kind":"function","name":"initial_carry","path":"models/losses.py","language":"python","start_line":47,"end_line":48,"context_start_line":27,"context_end_line":68,"code":" if valid_mask is None:\n valid_mask = (labels != ignore_index)\n transformed_labels = torch.where(valid_mask, labels, 0)\n prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)\n\n return -torch.where(valid_mask, prediction_logprobs, 0)\n\n\ndef softmax_cross_entropy(logits, labels, ignore_index: int = -100):\n # Cast logits to f32\n # Flatten logits\n return F.cross_entropy(logits.to(torch.float32).view(-1, logits.shape[-1]), labels.to(torch.long).view(-1), ignore_index=ignore_index, reduction=\"none\").view(labels.shape)\n\n\nclass ACTLossHead(nn.Module):\n def __init__(self, model: nn.Module, loss_type: str):\n super().__init__()\n self.model = model\n self.loss_fn = globals()[loss_type]\n \n def initial_carry(self, *args, **kwargs):\n return self.model.initial_carry(*args, **kwargs) # type: ignore\n\n def forward(\n self,\n return_keys: Sequence[str],\n # Model args\n **model_kwargs,\n ) -> Tuple[Any, torch.Tensor, Dict[str, torch.Tensor], Optional[Dict[str, torch.Tensor]], torch.Tensor]:\n # Model logits\n # B x SeqLen x D\n new_carry, outputs = self.model(**model_kwargs)\n labels = new_carry.current_data[\"labels\"]\n\n with torch.no_grad():\n # Preds\n outputs[\"preds\"] = torch.argmax(outputs[\"logits\"], dim=-1)\n\n # Correctness\n mask = (labels != IGNORE_LABEL_ID)\n loss_counts = mask.sum(-1)\n loss_divisor = loss_counts.clamp_min(1).unsqueeze(-1) # Avoid NaNs in division","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.losses.forward","uri":"program://TinyRecursiveModels/function/models.losses.forward#L50-L102","kind":"function","name":"forward","path":"models/losses.py","language":"python","start_line":50,"end_line":102,"context_start_line":30,"context_end_line":103,"code":" prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)\n\n return -torch.where(valid_mask, prediction_logprobs, 0)\n\n\ndef softmax_cross_entropy(logits, labels, ignore_index: int = -100):\n # Cast logits to f32\n # Flatten logits\n return F.cross_entropy(logits.to(torch.float32).view(-1, logits.shape[-1]), labels.to(torch.long).view(-1), ignore_index=ignore_index, reduction=\"none\").view(labels.shape)\n\n\nclass ACTLossHead(nn.Module):\n def __init__(self, model: nn.Module, loss_type: str):\n super().__init__()\n self.model = model\n self.loss_fn = globals()[loss_type]\n \n def initial_carry(self, *args, **kwargs):\n return self.model.initial_carry(*args, **kwargs) # type: ignore\n\n def forward(\n self,\n return_keys: Sequence[str],\n # Model args\n **model_kwargs,\n ) -> Tuple[Any, torch.Tensor, Dict[str, torch.Tensor], Optional[Dict[str, torch.Tensor]], torch.Tensor]:\n # Model logits\n # B x SeqLen x D\n new_carry, outputs = self.model(**model_kwargs)\n labels = new_carry.current_data[\"labels\"]\n\n with torch.no_grad():\n # Preds\n outputs[\"preds\"] = torch.argmax(outputs[\"logits\"], dim=-1)\n\n # Correctness\n mask = (labels != IGNORE_LABEL_ID)\n loss_counts = mask.sum(-1)\n loss_divisor = loss_counts.clamp_min(1).unsqueeze(-1) # Avoid NaNs in division\n\n is_correct = mask & (torch.argmax(outputs[\"logits\"], dim=-1) == labels)\n seq_is_correct = is_correct.sum(-1) == loss_counts\n \n # Metrics (halted)\n valid_metrics = new_carry.halted & (loss_counts > 0)\n metrics = {\n \"count\": valid_metrics.sum(),\n \n \"accuracy\": torch.where(valid_metrics, (is_correct.to(torch.float32) / loss_divisor).sum(-1), 0).sum(),\n \"exact_accuracy\": (valid_metrics & seq_is_correct).sum(),\n\n \"q_halt_accuracy\": (valid_metrics & ((outputs[\"q_halt_logits\"] >= 0) == seq_is_correct)).sum(),\n \"steps\": torch.where(valid_metrics, new_carry.steps, 0).sum(),\n }\n\n # Losses\n\n lm_loss = (self.loss_fn(outputs[\"logits\"], labels, ignore_index=IGNORE_LABEL_ID, valid_mask=mask) / loss_divisor).sum()\n q_halt_loss = F.binary_cross_entropy_with_logits(outputs[\"q_halt_logits\"], seq_is_correct.to(outputs[\"q_halt_logits\"].dtype), reduction=\"sum\")\n metrics.update({\n \"lm_loss\": lm_loss.detach(),\n \"q_halt_loss\": q_halt_loss.detach(),\n })\n # Q continue (bootstrapping target loss); Alexia: This fits Q-learning, but seems totally unecessary\n q_continue_loss = 0\n if \"target_q_continue\" in outputs:\n q_continue_loss = F.binary_cross_entropy_with_logits(outputs[\"q_continue_logits\"], outputs[\"target_q_continue\"], reduction=\"sum\")\n\n metrics[\"q_continue_loss\"] = q_continue_loss.detach()\n # Filter outputs for return\n detached_outputs = {k: outputs[k].detach() for k in return_keys if k in outputs}\n\n return new_carry, lm_loss + 0.5 * (q_halt_loss + q_continue_loss), metrics, detached_outputs, new_carry.halted.all()\n","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers","uri":"program://TinyRecursiveModels/module/models.layers#L1-L169","kind":"module","name":"models.layers","path":"models/layers.py","language":"python","start_line":1,"end_line":169,"context_start_line":1,"context_end_line":169,"code":"from typing import Tuple\nimport einops\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\n\n#try:\n# from flash_attn_interface import flash_attn_func # type: ignore[import]\n#except ImportError:\n# # Fallback to FlashAttention 2\n# from flash_attn import flash_attn_func # type: ignore[import]\nfrom torch.nn.functional import scaled_dot_product_attention\n\nfrom models.common import trunc_normal_init_\n\n\nCosSin = Tuple[torch.Tensor, torch.Tensor]\n\n\ndef _find_multiple(a, b):\n return (-(a // -b)) * b\n\n\ndef rotate_half(x: torch.Tensor):\n \"\"\"Rotates half the hidden dims of the input.\"\"\"\n x1 = x[..., : x.shape[-1] // 2]\n x2 = x[..., x.shape[-1] // 2 :]\n return torch.cat((-x2, x1), dim=-1)\n\n\ndef apply_rotary_pos_emb(q: torch.Tensor, k: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor):\n # q, k: [bs, seq_len, num_heads, head_dim]\n # cos, sin: [seq_len, head_dim]\n orig_dtype = q.dtype\n q = q.to(cos.dtype)\n k = k.to(cos.dtype)\n\n q_embed = (q * cos.unsqueeze(-2)) + (rotate_half(q) * sin.unsqueeze(-2))\n k_embed = (k * cos.unsqueeze(-2)) + (rotate_half(k) * sin.unsqueeze(-2))\n\n return q_embed.to(orig_dtype), k_embed.to(orig_dtype)\n\n\nclass CastedLinear(nn.Module):\n def __init__(self,\n in_features: int,\n out_features: int,\n bias: bool):\n super().__init__()\n # Truncated LeCun normal init\n self.weight = nn.Parameter(\n trunc_normal_init_(torch.empty((out_features, in_features)), std=1.0 / (in_features ** 0.5))\n )\n self.bias = None\n if bias:\n # Zero init bias\n self.bias = nn.Parameter(torch.zeros((out_features, )))\n\n def forward(self, input: torch.Tensor) -> torch.Tensor:\n return F.linear(input, self.weight.to(input.dtype), bias=self.bias.to(input.dtype) if self.bias is not None else None)\n\n\nclass CastedEmbedding(nn.Module):\n def __init__(self,\n num_embeddings: int,\n embedding_dim: int,\n init_std: float,\n cast_to: torch.dtype):\n super().__init__()\n self.cast_to = cast_to\n\n # Truncated LeCun normal init\n self.embedding_weight = nn.Parameter(\n trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std)\n )\n \n def forward(self, input: torch.Tensor) -> torch.Tensor:\n return F.embedding(input, self.embedding_weight.to(self.cast_to))\n\n\nclass RotaryEmbedding(nn.Module):\n def __init__(self, dim, max_position_embeddings, base, device=None):\n super().__init__()\n\n # RoPE\n inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2, dtype=torch.float32, device=device) / dim))\n t = torch.arange(max_position_embeddings, dtype=torch.float32, device=device)\n freqs = torch.outer(t, inv_freq)\n\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.cos_cached = nn.Buffer(emb.cos(), persistent=False)\n self.sin_cached = nn.Buffer(emb.sin(), persistent=False)\n\n def forward(self):\n return self.cos_cached, self.sin_cached\n\n\nclass Attention(nn.Module):\n def __init__(self, hidden_size, head_dim, num_heads, num_key_value_heads, causal=False):\n super().__init__()\n\n self.hidden_size = hidden_size\n self.head_dim = head_dim\n self.output_size = head_dim * num_heads\n self.num_heads = num_heads\n self.num_key_value_heads = num_key_value_heads\n self.causal = causal\n\n self.qkv_proj = CastedLinear(self.hidden_size, (self.num_heads + 2 * self.num_key_value_heads) * self.head_dim, bias=False)\n self.o_proj = CastedLinear(self.output_size, self.hidden_size, bias=False)\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n batch_size, seq_len, _ = hidden_states.shape\n\n # hidden_states: [bs, seq_len, num_heads, head_dim]\n qkv = self.qkv_proj(hidden_states)\n\n # Split head\n qkv = qkv.view(batch_size, seq_len, self.num_heads + 2 * self.num_key_value_heads, self.head_dim)\n query = qkv[:, :, :self.num_heads]\n key = qkv[:, :, self.num_heads: self.num_heads + self.num_key_value_heads]\n value = qkv[:, :, self.num_heads + self.num_key_value_heads:]\n\n # RoPE\n if cos_sin is not None:\n cos, sin = cos_sin\n query, key = apply_rotary_pos_emb(query, key, cos, sin)\n\n # flash attn\n query, key, value = map(lambda t: einops.rearrange(t, 'B S H D -> B H S D'), (query, key, value)) # needed for scaled_dot_product_attention but not flash_attn_func\n attn_output = scaled_dot_product_attention(query=query, key=key, value=value, is_causal=self.causal)\n attn_output = einops.rearrange(attn_output, 'B H S D -> B S H D')\n attn_output = attn_output.view(batch_size, seq_len, self.output_size) # type: ignore\n return self.o_proj(attn_output)\n\nclass LinearSwish(nn.Module):\n def __init__(self, hidden_size: int, reverse=False):\n super().__init__()\n\n self.linear = CastedLinear(hidden_size, hidden_size, bias=False)\n self.reverse = reverse\n\n def forward(self, x):\n if self.reverse:\n return F.silu(self.linear(x))\n else:\n return self.linear(F.silu(x))\n\n\nclass SwiGLU(nn.Module):\n def __init__(self, hidden_size: int, expansion: float):\n super().__init__()\n inter = _find_multiple(round(expansion * hidden_size * 2 / 3), 256)\n\n self.gate_up_proj = CastedLinear(hidden_size, inter * 2, bias=False)\n self.down_proj = CastedLinear(inter, hidden_size, bias=False)\n\n def forward(self, x):\n gate, up = self.gate_up_proj(x).chunk(2, dim=-1)\n return self.down_proj(F.silu(gate) * up)\n\ndef rms_norm(hidden_states: torch.Tensor, variance_epsilon: float) -> torch.Tensor:\n input_dtype = hidden_states.dtype\n hidden_states = hidden_states.to(torch.float32)\n\n variance = hidden_states.square().mean(-1, keepdim=True)\n hidden_states = hidden_states * torch.rsqrt(variance + variance_epsilon)\n return hidden_states.to(input_dtype)","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers._find_multiple","uri":"program://TinyRecursiveModels/function/models.layers._find_multiple#L20-L21","kind":"function","name":"_find_multiple","path":"models/layers.py","language":"python","start_line":20,"end_line":21,"context_start_line":1,"context_end_line":41,"code":"from typing import Tuple\nimport einops\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\n\n#try:\n# from flash_attn_interface import flash_attn_func # type: ignore[import]\n#except ImportError:\n# # Fallback to FlashAttention 2\n# from flash_attn import flash_attn_func # type: ignore[import]\nfrom torch.nn.functional import scaled_dot_product_attention\n\nfrom models.common import trunc_normal_init_\n\n\nCosSin = Tuple[torch.Tensor, torch.Tensor]\n\n\ndef _find_multiple(a, b):\n return (-(a // -b)) * b\n\n\ndef rotate_half(x: torch.Tensor):\n \"\"\"Rotates half the hidden dims of the input.\"\"\"\n x1 = x[..., : x.shape[-1] // 2]\n x2 = x[..., x.shape[-1] // 2 :]\n return torch.cat((-x2, x1), dim=-1)\n\n\ndef apply_rotary_pos_emb(q: torch.Tensor, k: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor):\n # q, k: [bs, seq_len, num_heads, head_dim]\n # cos, sin: [seq_len, head_dim]\n orig_dtype = q.dtype\n q = q.to(cos.dtype)\n k = k.to(cos.dtype)\n\n q_embed = (q * cos.unsqueeze(-2)) + (rotate_half(q) * sin.unsqueeze(-2))\n k_embed = (k * cos.unsqueeze(-2)) + (rotate_half(k) * sin.unsqueeze(-2))\n\n return q_embed.to(orig_dtype), k_embed.to(orig_dtype)","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.rotate_half","uri":"program://TinyRecursiveModels/function/models.layers.rotate_half#L24-L28","kind":"function","name":"rotate_half","path":"models/layers.py","language":"python","start_line":24,"end_line":28,"context_start_line":4,"context_end_line":48,"code":"from torch import nn\nimport torch.nn.functional as F\n\n#try:\n# from flash_attn_interface import flash_attn_func # type: ignore[import]\n#except ImportError:\n# # Fallback to FlashAttention 2\n# from flash_attn import flash_attn_func # type: ignore[import]\nfrom torch.nn.functional import scaled_dot_product_attention\n\nfrom models.common import trunc_normal_init_\n\n\nCosSin = Tuple[torch.Tensor, torch.Tensor]\n\n\ndef _find_multiple(a, b):\n return (-(a // -b)) * b\n\n\ndef rotate_half(x: torch.Tensor):\n \"\"\"Rotates half the hidden dims of the input.\"\"\"\n x1 = x[..., : x.shape[-1] // 2]\n x2 = x[..., x.shape[-1] // 2 :]\n return torch.cat((-x2, x1), dim=-1)\n\n\ndef apply_rotary_pos_emb(q: torch.Tensor, k: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor):\n # q, k: [bs, seq_len, num_heads, head_dim]\n # cos, sin: [seq_len, head_dim]\n orig_dtype = q.dtype\n q = q.to(cos.dtype)\n k = k.to(cos.dtype)\n\n q_embed = (q * cos.unsqueeze(-2)) + (rotate_half(q) * sin.unsqueeze(-2))\n k_embed = (k * cos.unsqueeze(-2)) + (rotate_half(k) * sin.unsqueeze(-2))\n\n return q_embed.to(orig_dtype), k_embed.to(orig_dtype)\n\n\nclass CastedLinear(nn.Module):\n def __init__(self,\n in_features: int,\n out_features: int,\n bias: bool):","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.apply_rotary_pos_emb","uri":"program://TinyRecursiveModels/function/models.layers.apply_rotary_pos_emb#L31-L41","kind":"function","name":"apply_rotary_pos_emb","path":"models/layers.py","language":"python","start_line":31,"end_line":41,"context_start_line":11,"context_end_line":61,"code":"# from flash_attn import flash_attn_func # type: ignore[import]\nfrom torch.nn.functional import scaled_dot_product_attention\n\nfrom models.common import trunc_normal_init_\n\n\nCosSin = Tuple[torch.Tensor, torch.Tensor]\n\n\ndef _find_multiple(a, b):\n return (-(a // -b)) * b\n\n\ndef rotate_half(x: torch.Tensor):\n \"\"\"Rotates half the hidden dims of the input.\"\"\"\n x1 = x[..., : x.shape[-1] // 2]\n x2 = x[..., x.shape[-1] // 2 :]\n return torch.cat((-x2, x1), dim=-1)\n\n\ndef apply_rotary_pos_emb(q: torch.Tensor, k: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor):\n # q, k: [bs, seq_len, num_heads, head_dim]\n # cos, sin: [seq_len, head_dim]\n orig_dtype = q.dtype\n q = q.to(cos.dtype)\n k = k.to(cos.dtype)\n\n q_embed = (q * cos.unsqueeze(-2)) + (rotate_half(q) * sin.unsqueeze(-2))\n k_embed = (k * cos.unsqueeze(-2)) + (rotate_half(k) * sin.unsqueeze(-2))\n\n return q_embed.to(orig_dtype), k_embed.to(orig_dtype)\n\n\nclass CastedLinear(nn.Module):\n def __init__(self,\n in_features: int,\n out_features: int,\n bias: bool):\n super().__init__()\n # Truncated LeCun normal init\n self.weight = nn.Parameter(\n trunc_normal_init_(torch.empty((out_features, in_features)), std=1.0 / (in_features ** 0.5))\n )\n self.bias = None\n if bias:\n # Zero init bias\n self.bias = nn.Parameter(torch.zeros((out_features, )))\n\n def forward(self, input: torch.Tensor) -> torch.Tensor:\n return F.linear(input, self.weight.to(input.dtype), bias=self.bias.to(input.dtype) if self.bias is not None else None)\n","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.CastedLinear","uri":"program://TinyRecursiveModels/class/models.layers.CastedLinear#L44-L60","kind":"class","name":"CastedLinear","path":"models/layers.py","language":"python","start_line":44,"end_line":60,"context_start_line":24,"context_end_line":80,"code":"def rotate_half(x: torch.Tensor):\n \"\"\"Rotates half the hidden dims of the input.\"\"\"\n x1 = x[..., : x.shape[-1] // 2]\n x2 = x[..., x.shape[-1] // 2 :]\n return torch.cat((-x2, x1), dim=-1)\n\n\ndef apply_rotary_pos_emb(q: torch.Tensor, k: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor):\n # q, k: [bs, seq_len, num_heads, head_dim]\n # cos, sin: [seq_len, head_dim]\n orig_dtype = q.dtype\n q = q.to(cos.dtype)\n k = k.to(cos.dtype)\n\n q_embed = (q * cos.unsqueeze(-2)) + (rotate_half(q) * sin.unsqueeze(-2))\n k_embed = (k * cos.unsqueeze(-2)) + (rotate_half(k) * sin.unsqueeze(-2))\n\n return q_embed.to(orig_dtype), k_embed.to(orig_dtype)\n\n\nclass CastedLinear(nn.Module):\n def __init__(self,\n in_features: int,\n out_features: int,\n bias: bool):\n super().__init__()\n # Truncated LeCun normal init\n self.weight = nn.Parameter(\n trunc_normal_init_(torch.empty((out_features, in_features)), std=1.0 / (in_features ** 0.5))\n )\n self.bias = None\n if bias:\n # Zero init bias\n self.bias = nn.Parameter(torch.zeros((out_features, )))\n\n def forward(self, input: torch.Tensor) -> torch.Tensor:\n return F.linear(input, self.weight.to(input.dtype), bias=self.bias.to(input.dtype) if self.bias is not None else None)\n\n\nclass CastedEmbedding(nn.Module):\n def __init__(self,\n num_embeddings: int,\n embedding_dim: int,\n init_std: float,\n cast_to: torch.dtype):\n super().__init__()\n self.cast_to = cast_to\n\n # Truncated LeCun normal init\n self.embedding_weight = nn.Parameter(\n trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std)\n )\n \n def forward(self, input: torch.Tensor) -> torch.Tensor:\n return F.embedding(input, self.embedding_weight.to(self.cast_to))\n\n","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.CastedEmbedding","uri":"program://TinyRecursiveModels/class/models.layers.CastedEmbedding#L63-L78","kind":"class","name":"CastedEmbedding","path":"models/layers.py","language":"python","start_line":63,"end_line":78,"context_start_line":43,"context_end_line":98,"code":"\nclass CastedLinear(nn.Module):\n def __init__(self,\n in_features: int,\n out_features: int,\n bias: bool):\n super().__init__()\n # Truncated LeCun normal init\n self.weight = nn.Parameter(\n trunc_normal_init_(torch.empty((out_features, in_features)), std=1.0 / (in_features ** 0.5))\n )\n self.bias = None\n if bias:\n # Zero init bias\n self.bias = nn.Parameter(torch.zeros((out_features, )))\n\n def forward(self, input: torch.Tensor) -> torch.Tensor:\n return F.linear(input, self.weight.to(input.dtype), bias=self.bias.to(input.dtype) if self.bias is not None else None)\n\n\nclass CastedEmbedding(nn.Module):\n def __init__(self,\n num_embeddings: int,\n embedding_dim: int,\n init_std: float,\n cast_to: torch.dtype):\n super().__init__()\n self.cast_to = cast_to\n\n # Truncated LeCun normal init\n self.embedding_weight = nn.Parameter(\n trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std)\n )\n \n def forward(self, input: torch.Tensor) -> torch.Tensor:\n return F.embedding(input, self.embedding_weight.to(self.cast_to))\n\n\nclass RotaryEmbedding(nn.Module):\n def __init__(self, dim, max_position_embeddings, base, device=None):\n super().__init__()\n\n # RoPE\n inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2, dtype=torch.float32, device=device) / dim))\n t = torch.arange(max_position_embeddings, dtype=torch.float32, device=device)\n freqs = torch.outer(t, inv_freq)\n\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.cos_cached = nn.Buffer(emb.cos(), persistent=False)\n self.sin_cached = nn.Buffer(emb.sin(), persistent=False)\n\n def forward(self):\n return self.cos_cached, self.sin_cached\n\n","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.RotaryEmbedding","uri":"program://TinyRecursiveModels/class/models.layers.RotaryEmbedding#L81-L96","kind":"class","name":"RotaryEmbedding","path":"models/layers.py","language":"python","start_line":81,"end_line":96,"context_start_line":61,"context_end_line":116,"code":"\n\nclass CastedEmbedding(nn.Module):\n def __init__(self,\n num_embeddings: int,\n embedding_dim: int,\n init_std: float,\n cast_to: torch.dtype):\n super().__init__()\n self.cast_to = cast_to\n\n # Truncated LeCun normal init\n self.embedding_weight = nn.Parameter(\n trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std)\n )\n \n def forward(self, input: torch.Tensor) -> torch.Tensor:\n return F.embedding(input, self.embedding_weight.to(self.cast_to))\n\n\nclass RotaryEmbedding(nn.Module):\n def __init__(self, dim, max_position_embeddings, base, device=None):\n super().__init__()\n\n # RoPE\n inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2, dtype=torch.float32, device=device) / dim))\n t = torch.arange(max_position_embeddings, dtype=torch.float32, device=device)\n freqs = torch.outer(t, inv_freq)\n\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.cos_cached = nn.Buffer(emb.cos(), persistent=False)\n self.sin_cached = nn.Buffer(emb.sin(), persistent=False)\n\n def forward(self):\n return self.cos_cached, self.sin_cached\n\n\nclass Attention(nn.Module):\n def __init__(self, hidden_size, head_dim, num_heads, num_key_value_heads, causal=False):\n super().__init__()\n\n self.hidden_size = hidden_size\n self.head_dim = head_dim\n self.output_size = head_dim * num_heads\n self.num_heads = num_heads\n self.num_key_value_heads = num_key_value_heads\n self.causal = causal\n\n self.qkv_proj = CastedLinear(self.hidden_size, (self.num_heads + 2 * self.num_key_value_heads) * self.head_dim, bias=False)\n self.o_proj = CastedLinear(self.output_size, self.hidden_size, bias=False)\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n batch_size, seq_len, _ = hidden_states.shape\n\n # hidden_states: [bs, seq_len, num_heads, head_dim]","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.Attention","uri":"program://TinyRecursiveModels/class/models.layers.Attention#L99-L135","kind":"class","name":"Attention","path":"models/layers.py","language":"python","start_line":99,"end_line":135,"context_start_line":79,"context_end_line":155,"code":"\n\nclass RotaryEmbedding(nn.Module):\n def __init__(self, dim, max_position_embeddings, base, device=None):\n super().__init__()\n\n # RoPE\n inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2, dtype=torch.float32, device=device) / dim))\n t = torch.arange(max_position_embeddings, dtype=torch.float32, device=device)\n freqs = torch.outer(t, inv_freq)\n\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.cos_cached = nn.Buffer(emb.cos(), persistent=False)\n self.sin_cached = nn.Buffer(emb.sin(), persistent=False)\n\n def forward(self):\n return self.cos_cached, self.sin_cached\n\n\nclass Attention(nn.Module):\n def __init__(self, hidden_size, head_dim, num_heads, num_key_value_heads, causal=False):\n super().__init__()\n\n self.hidden_size = hidden_size\n self.head_dim = head_dim\n self.output_size = head_dim * num_heads\n self.num_heads = num_heads\n self.num_key_value_heads = num_key_value_heads\n self.causal = causal\n\n self.qkv_proj = CastedLinear(self.hidden_size, (self.num_heads + 2 * self.num_key_value_heads) * self.head_dim, bias=False)\n self.o_proj = CastedLinear(self.output_size, self.hidden_size, bias=False)\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n batch_size, seq_len, _ = hidden_states.shape\n\n # hidden_states: [bs, seq_len, num_heads, head_dim]\n qkv = self.qkv_proj(hidden_states)\n\n # Split head\n qkv = qkv.view(batch_size, seq_len, self.num_heads + 2 * self.num_key_value_heads, self.head_dim)\n query = qkv[:, :, :self.num_heads]\n key = qkv[:, :, self.num_heads: self.num_heads + self.num_key_value_heads]\n value = qkv[:, :, self.num_heads + self.num_key_value_heads:]\n\n # RoPE\n if cos_sin is not None:\n cos, sin = cos_sin\n query, key = apply_rotary_pos_emb(query, key, cos, sin)\n\n # flash attn\n query, key, value = map(lambda t: einops.rearrange(t, 'B S H D -> B H S D'), (query, key, value)) # needed for scaled_dot_product_attention but not flash_attn_func\n attn_output = scaled_dot_product_attention(query=query, key=key, value=value, is_causal=self.causal)\n attn_output = einops.rearrange(attn_output, 'B H S D -> B S H D')\n attn_output = attn_output.view(batch_size, seq_len, self.output_size) # type: ignore\n return self.o_proj(attn_output)\n\nclass LinearSwish(nn.Module):\n def __init__(self, hidden_size: int, reverse=False):\n super().__init__()\n\n self.linear = CastedLinear(hidden_size, hidden_size, bias=False)\n self.reverse = reverse\n\n def forward(self, x):\n if self.reverse:\n return F.silu(self.linear(x))\n else:\n return self.linear(F.silu(x))\n\n\nclass SwiGLU(nn.Module):\n def __init__(self, hidden_size: int, expansion: float):\n super().__init__()\n inter = _find_multiple(round(expansion * hidden_size * 2 / 3), 256)\n","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.LinearSwish","uri":"program://TinyRecursiveModels/class/models.layers.LinearSwish#L137-L148","kind":"class","name":"LinearSwish","path":"models/layers.py","language":"python","start_line":137,"end_line":148,"context_start_line":117,"context_end_line":168,"code":" qkv = self.qkv_proj(hidden_states)\n\n # Split head\n qkv = qkv.view(batch_size, seq_len, self.num_heads + 2 * self.num_key_value_heads, self.head_dim)\n query = qkv[:, :, :self.num_heads]\n key = qkv[:, :, self.num_heads: self.num_heads + self.num_key_value_heads]\n value = qkv[:, :, self.num_heads + self.num_key_value_heads:]\n\n # RoPE\n if cos_sin is not None:\n cos, sin = cos_sin\n query, key = apply_rotary_pos_emb(query, key, cos, sin)\n\n # flash attn\n query, key, value = map(lambda t: einops.rearrange(t, 'B S H D -> B H S D'), (query, key, value)) # needed for scaled_dot_product_attention but not flash_attn_func\n attn_output = scaled_dot_product_attention(query=query, key=key, value=value, is_causal=self.causal)\n attn_output = einops.rearrange(attn_output, 'B H S D -> B S H D')\n attn_output = attn_output.view(batch_size, seq_len, self.output_size) # type: ignore\n return self.o_proj(attn_output)\n\nclass LinearSwish(nn.Module):\n def __init__(self, hidden_size: int, reverse=False):\n super().__init__()\n\n self.linear = CastedLinear(hidden_size, hidden_size, bias=False)\n self.reverse = reverse\n\n def forward(self, x):\n if self.reverse:\n return F.silu(self.linear(x))\n else:\n return self.linear(F.silu(x))\n\n\nclass SwiGLU(nn.Module):\n def __init__(self, hidden_size: int, expansion: float):\n super().__init__()\n inter = _find_multiple(round(expansion * hidden_size * 2 / 3), 256)\n\n self.gate_up_proj = CastedLinear(hidden_size, inter * 2, bias=False)\n self.down_proj = CastedLinear(inter, hidden_size, bias=False)\n\n def forward(self, x):\n gate, up = self.gate_up_proj(x).chunk(2, dim=-1)\n return self.down_proj(F.silu(gate) * up)\n\ndef rms_norm(hidden_states: torch.Tensor, variance_epsilon: float) -> torch.Tensor:\n input_dtype = hidden_states.dtype\n hidden_states = hidden_states.to(torch.float32)\n\n variance = hidden_states.square().mean(-1, keepdim=True)\n hidden_states = hidden_states * torch.rsqrt(variance + variance_epsilon)","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.SwiGLU","uri":"program://TinyRecursiveModels/class/models.layers.SwiGLU#L151-L161","kind":"class","name":"SwiGLU","path":"models/layers.py","language":"python","start_line":151,"end_line":161,"context_start_line":131,"context_end_line":169,"code":" query, key, value = map(lambda t: einops.rearrange(t, 'B S H D -> B H S D'), (query, key, value)) # needed for scaled_dot_product_attention but not flash_attn_func\n attn_output = scaled_dot_product_attention(query=query, key=key, value=value, is_causal=self.causal)\n attn_output = einops.rearrange(attn_output, 'B H S D -> B S H D')\n attn_output = attn_output.view(batch_size, seq_len, self.output_size) # type: ignore\n return self.o_proj(attn_output)\n\nclass LinearSwish(nn.Module):\n def __init__(self, hidden_size: int, reverse=False):\n super().__init__()\n\n self.linear = CastedLinear(hidden_size, hidden_size, bias=False)\n self.reverse = reverse\n\n def forward(self, x):\n if self.reverse:\n return F.silu(self.linear(x))\n else:\n return self.linear(F.silu(x))\n\n\nclass SwiGLU(nn.Module):\n def __init__(self, hidden_size: int, expansion: float):\n super().__init__()\n inter = _find_multiple(round(expansion * hidden_size * 2 / 3), 256)\n\n self.gate_up_proj = CastedLinear(hidden_size, inter * 2, bias=False)\n self.down_proj = CastedLinear(inter, hidden_size, bias=False)\n\n def forward(self, x):\n gate, up = self.gate_up_proj(x).chunk(2, dim=-1)\n return self.down_proj(F.silu(gate) * up)\n\ndef rms_norm(hidden_states: torch.Tensor, variance_epsilon: float) -> torch.Tensor:\n input_dtype = hidden_states.dtype\n hidden_states = hidden_states.to(torch.float32)\n\n variance = hidden_states.square().mean(-1, keepdim=True)\n hidden_states = hidden_states * torch.rsqrt(variance + variance_epsilon)\n return hidden_states.to(input_dtype)","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.rms_norm","uri":"program://TinyRecursiveModels/function/models.layers.rms_norm#L163-L169","kind":"function","name":"rms_norm","path":"models/layers.py","language":"python","start_line":163,"end_line":169,"context_start_line":143,"context_end_line":169,"code":"\n def forward(self, x):\n if self.reverse:\n return F.silu(self.linear(x))\n else:\n return self.linear(F.silu(x))\n\n\nclass SwiGLU(nn.Module):\n def __init__(self, hidden_size: int, expansion: float):\n super().__init__()\n inter = _find_multiple(round(expansion * hidden_size * 2 / 3), 256)\n\n self.gate_up_proj = CastedLinear(hidden_size, inter * 2, bias=False)\n self.down_proj = CastedLinear(inter, hidden_size, bias=False)\n\n def forward(self, x):\n gate, up = self.gate_up_proj(x).chunk(2, dim=-1)\n return self.down_proj(F.silu(gate) * up)\n\ndef rms_norm(hidden_states: torch.Tensor, variance_epsilon: float) -> torch.Tensor:\n input_dtype = hidden_states.dtype\n hidden_states = hidden_states.to(torch.float32)\n\n variance = hidden_states.square().mean(-1, keepdim=True)\n hidden_states = hidden_states * torch.rsqrt(variance + variance_epsilon)\n return hidden_states.to(input_dtype)","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.__init__","uri":"program://TinyRecursiveModels/function/models.layers.__init__#L152-L157","kind":"function","name":"__init__","path":"models/layers.py","language":"python","start_line":152,"end_line":157,"context_start_line":132,"context_end_line":169,"code":" attn_output = scaled_dot_product_attention(query=query, key=key, value=value, is_causal=self.causal)\n attn_output = einops.rearrange(attn_output, 'B H S D -> B S H D')\n attn_output = attn_output.view(batch_size, seq_len, self.output_size) # type: ignore\n return self.o_proj(attn_output)\n\nclass LinearSwish(nn.Module):\n def __init__(self, hidden_size: int, reverse=False):\n super().__init__()\n\n self.linear = CastedLinear(hidden_size, hidden_size, bias=False)\n self.reverse = reverse\n\n def forward(self, x):\n if self.reverse:\n return F.silu(self.linear(x))\n else:\n return self.linear(F.silu(x))\n\n\nclass SwiGLU(nn.Module):\n def __init__(self, hidden_size: int, expansion: float):\n super().__init__()\n inter = _find_multiple(round(expansion * hidden_size * 2 / 3), 256)\n\n self.gate_up_proj = CastedLinear(hidden_size, inter * 2, bias=False)\n self.down_proj = CastedLinear(inter, hidden_size, bias=False)\n\n def forward(self, x):\n gate, up = self.gate_up_proj(x).chunk(2, dim=-1)\n return self.down_proj(F.silu(gate) * up)\n\ndef rms_norm(hidden_states: torch.Tensor, variance_epsilon: float) -> torch.Tensor:\n input_dtype = hidden_states.dtype\n hidden_states = hidden_states.to(torch.float32)\n\n variance = hidden_states.square().mean(-1, keepdim=True)\n hidden_states = hidden_states * torch.rsqrt(variance + variance_epsilon)\n return hidden_states.to(input_dtype)","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.layers.forward","uri":"program://TinyRecursiveModels/function/models.layers.forward#L159-L161","kind":"function","name":"forward","path":"models/layers.py","language":"python","start_line":159,"end_line":161,"context_start_line":139,"context_end_line":169,"code":" super().__init__()\n\n self.linear = CastedLinear(hidden_size, hidden_size, bias=False)\n self.reverse = reverse\n\n def forward(self, x):\n if self.reverse:\n return F.silu(self.linear(x))\n else:\n return self.linear(F.silu(x))\n\n\nclass SwiGLU(nn.Module):\n def __init__(self, hidden_size: int, expansion: float):\n super().__init__()\n inter = _find_multiple(round(expansion * hidden_size * 2 / 3), 256)\n\n self.gate_up_proj = CastedLinear(hidden_size, inter * 2, bias=False)\n self.down_proj = CastedLinear(inter, hidden_size, bias=False)\n\n def forward(self, x):\n gate, up = self.gate_up_proj(x).chunk(2, dim=-1)\n return self.down_proj(F.silu(gate) * up)\n\ndef rms_norm(hidden_states: torch.Tensor, variance_epsilon: float) -> torch.Tensor:\n input_dtype = hidden_states.dtype\n hidden_states = hidden_states.to(torch.float32)\n\n variance = hidden_states.square().mean(-1, keepdim=True)\n hidden_states = hidden_states * torch.rsqrt(variance + variance_epsilon)\n return hidden_states.to(input_dtype)","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.ema","uri":"program://TinyRecursiveModels/module/models.ema#L1-L40","kind":"module","name":"models.ema","path":"models/ema.py","language":"python","start_line":1,"end_line":40,"context_start_line":1,"context_end_line":40,"code":"import copy\nimport torch.nn as nn\n\nclass EMAHelper(object):\n def __init__(self, mu=0.999):\n self.mu = mu\n self.shadow = {}\n\n def register(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name] = param.data.clone()\n\n def update(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n\n def ema(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n param.data.copy_(self.shadow[name].data)\n\n def ema_copy(self, module):\n module_copy = copy.deepcopy(module)\n self.ema(module_copy)\n return module_copy\n\n def state_dict(self):\n return self.shadow\n\n def load_state_dict(self, state_dict):\n self.shadow = state_dict\n","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.ema.EMAHelper","uri":"program://TinyRecursiveModels/class/models.ema.EMAHelper#L4-L39","kind":"class","name":"EMAHelper","path":"models/ema.py","language":"python","start_line":4,"end_line":39,"context_start_line":1,"context_end_line":40,"code":"import copy\nimport torch.nn as nn\n\nclass EMAHelper(object):\n def __init__(self, mu=0.999):\n self.mu = mu\n self.shadow = {}\n\n def register(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name] = param.data.clone()\n\n def update(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n\n def ema(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n param.data.copy_(self.shadow[name].data)\n\n def ema_copy(self, module):\n module_copy = copy.deepcopy(module)\n self.ema(module_copy)\n return module_copy\n\n def state_dict(self):\n return self.shadow\n\n def load_state_dict(self, state_dict):\n self.shadow = state_dict\n","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.ema.__init__","uri":"program://TinyRecursiveModels/function/models.ema.__init__#L5-L7","kind":"function","name":"__init__","path":"models/ema.py","language":"python","start_line":5,"end_line":7,"context_start_line":1,"context_end_line":27,"code":"import copy\nimport torch.nn as nn\n\nclass EMAHelper(object):\n def __init__(self, mu=0.999):\n self.mu = mu\n self.shadow = {}\n\n def register(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name] = param.data.clone()\n\n def update(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n\n def ema(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.ema.register","uri":"program://TinyRecursiveModels/function/models.ema.register#L9-L14","kind":"function","name":"register","path":"models/ema.py","language":"python","start_line":9,"end_line":14,"context_start_line":1,"context_end_line":34,"code":"import copy\nimport torch.nn as nn\n\nclass EMAHelper(object):\n def __init__(self, mu=0.999):\n self.mu = mu\n self.shadow = {}\n\n def register(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name] = param.data.clone()\n\n def update(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n\n def ema(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n param.data.copy_(self.shadow[name].data)\n\n def ema_copy(self, module):\n module_copy = copy.deepcopy(module)\n self.ema(module_copy)\n return module_copy\n","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.ema.update","uri":"program://TinyRecursiveModels/function/models.ema.update#L16-L21","kind":"function","name":"update","path":"models/ema.py","language":"python","start_line":16,"end_line":21,"context_start_line":1,"context_end_line":40,"code":"import copy\nimport torch.nn as nn\n\nclass EMAHelper(object):\n def __init__(self, mu=0.999):\n self.mu = mu\n self.shadow = {}\n\n def register(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name] = param.data.clone()\n\n def update(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n\n def ema(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n param.data.copy_(self.shadow[name].data)\n\n def ema_copy(self, module):\n module_copy = copy.deepcopy(module)\n self.ema(module_copy)\n return module_copy\n\n def state_dict(self):\n return self.shadow\n\n def load_state_dict(self, state_dict):\n self.shadow = state_dict\n","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.ema.ema","uri":"program://TinyRecursiveModels/function/models.ema.ema#L23-L28","kind":"function","name":"ema","path":"models/ema.py","language":"python","start_line":23,"end_line":28,"context_start_line":3,"context_end_line":40,"code":"\nclass EMAHelper(object):\n def __init__(self, mu=0.999):\n self.mu = mu\n self.shadow = {}\n\n def register(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name] = param.data.clone()\n\n def update(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n\n def ema(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n param.data.copy_(self.shadow[name].data)\n\n def ema_copy(self, module):\n module_copy = copy.deepcopy(module)\n self.ema(module_copy)\n return module_copy\n\n def state_dict(self):\n return self.shadow\n\n def load_state_dict(self, state_dict):\n self.shadow = state_dict\n","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.ema.ema_copy","uri":"program://TinyRecursiveModels/function/models.ema.ema_copy#L30-L33","kind":"function","name":"ema_copy","path":"models/ema.py","language":"python","start_line":30,"end_line":33,"context_start_line":10,"context_end_line":40,"code":" if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name] = param.data.clone()\n\n def update(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n\n def ema(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n param.data.copy_(self.shadow[name].data)\n\n def ema_copy(self, module):\n module_copy = copy.deepcopy(module)\n self.ema(module_copy)\n return module_copy\n\n def state_dict(self):\n return self.shadow\n\n def load_state_dict(self, state_dict):\n self.shadow = state_dict\n","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.ema.state_dict","uri":"program://TinyRecursiveModels/function/models.ema.state_dict#L35-L36","kind":"function","name":"state_dict","path":"models/ema.py","language":"python","start_line":35,"end_line":36,"context_start_line":15,"context_end_line":40,"code":"\n def update(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n\n def ema(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n param.data.copy_(self.shadow[name].data)\n\n def ema_copy(self, module):\n module_copy = copy.deepcopy(module)\n self.ema(module_copy)\n return module_copy\n\n def state_dict(self):\n return self.shadow\n\n def load_state_dict(self, state_dict):\n self.shadow = state_dict\n","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.ema.load_state_dict","uri":"program://TinyRecursiveModels/function/models.ema.load_state_dict#L38-L39","kind":"function","name":"load_state_dict","path":"models/ema.py","language":"python","start_line":38,"end_line":39,"context_start_line":18,"context_end_line":40,"code":" module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data\n\n def ema(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n param.data.copy_(self.shadow[name].data)\n\n def ema_copy(self, module):\n module_copy = copy.deepcopy(module)\n self.ema(module_copy)\n return module_copy\n\n def state_dict(self):\n return self.shadow\n\n def load_state_dict(self, state_dict):\n self.shadow = state_dict\n","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.sparse_embedding","uri":"program://TinyRecursiveModels/module/models.sparse_embedding#L1-L132","kind":"module","name":"models.sparse_embedding","path":"models/sparse_embedding.py","language":"python","start_line":1,"end_line":132,"context_start_line":1,"context_end_line":132,"code":"from typing import Union\n\nimport torch\nfrom torch import nn\nimport torch.distributed as dist\nfrom torch.optim.optimizer import Optimizer, ParamsT\n\nfrom models.common import trunc_normal_init_\n\n\nclass CastedSparseEmbedding(nn.Module):\n def __init__(self, num_embeddings: int, embedding_dim: int, batch_size: int, init_std: float, cast_to: torch.dtype):\n super().__init__()\n self.cast_to = cast_to\n\n # Real Weights\n # Truncated LeCun normal init\n self.weights = nn.Buffer(\n trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std), persistent=True\n )\n\n # Local weights and IDs\n # Local embeddings, with gradient, not persistent\n self.local_weights = nn.Buffer(torch.zeros(batch_size, embedding_dim, requires_grad=True), persistent=False)\n # Local embedding IDs, not persistent\n self.local_ids = nn.Buffer(torch.zeros(batch_size, dtype=torch.int32), persistent=False)\n\n def forward(self, inputs: torch.Tensor) -> torch.Tensor:\n if not self.training:\n # Test mode, no gradient\n return self.weights[inputs].to(self.cast_to)\n \n # Training mode, fill puzzle embedding from weights\n with torch.no_grad():\n self.local_weights.copy_(self.weights[inputs])\n self.local_ids.copy_(inputs)\n\n return self.local_weights.to(self.cast_to)\n\n\nclass CastedSparseEmbeddingSignSGD_Distributed(Optimizer):\n def __init__(\n self,\n params: ParamsT,\n\n world_size: int,\n lr: Union[float, torch.Tensor] = 1e-3,\n weight_decay: float = 1e-2,\n ):\n if not 0.0 <= lr:\n raise ValueError(f\"Invalid learning rate: {lr}\")\n if not 0.0 <= weight_decay:\n raise ValueError(f\"Invalid weight_decay value: {weight_decay}\")\n\n defaults = dict(\n lr=lr,\n weight_decay=weight_decay,\n world_size=world_size\n )\n super().__init__(params, defaults)\n\n @torch.no_grad\n def step(self, closure=None): # type: ignore\n for group in self.param_groups:\n # Find the sparse embedding weights\n local_weights_grad = None\n local_ids = None\n weights = None\n \n assert len(group[\"params\"]) == 3\n for p in group[\"params\"]:\n if p.requires_grad:\n local_weights_grad = p.grad\n elif p.ndim == 1:\n local_ids = p\n elif p.ndim == 2:\n weights = p\n else:\n assert False\n \n assert local_ids is not None\n assert weights is not None\n \n # Apply SignSGD\n # Adam ≈ SignSGD if gradient is very sparse\n if local_weights_grad is not None:\n _sparse_emb_signsgd_dist(\n local_weights_grad,\n local_ids,\n weights,\n \n lr=group[\"lr\"],\n weight_decay=group[\"weight_decay\"],\n world_size=group[\"world_size\"]\n )\n\n\ndef _sparse_emb_signsgd_dist(\n local_weights_grad: torch.Tensor,\n local_ids: torch.Tensor,\n weights: torch.Tensor,\n \n lr: float,\n weight_decay: float,\n world_size: int\n) -> None:\n N, D = local_weights_grad.shape\n \n # All-gather\n all_weights_grad = local_weights_grad\n all_ids = local_ids\n\n if world_size > 1:\n all_weights_grad = torch.empty((world_size * N, D), dtype=local_weights_grad.dtype, device=local_weights_grad.device)\n all_ids = torch.empty(world_size * N, dtype=local_ids.dtype, device=local_ids.device)\n \n dist.all_gather_into_tensor(all_weights_grad, local_weights_grad)\n dist.all_gather_into_tensor(all_ids, local_ids)\n\n # Unique\n grad_ids, inv = all_ids.unique(return_inverse=True)\n\n grad = torch.zeros((grad_ids.shape[0], D), dtype=all_weights_grad.dtype, device=all_weights_grad.device)\n grad.scatter_add_(0, inv.unsqueeze(-1).expand(-1, D), all_weights_grad)\n\n # SignSGD with decoupled weight decay\n p = weights[grad_ids]\n\n p.mul_(1.0 - lr * weight_decay).add_(torch.sign(grad), alpha=-lr)\n\n # Write updated slices back\n weights[grad_ids] = p","source_hash":"9429742ce022918751331acf92c1a9b8d0f2f364e9acef5d71fb81b886c7a2d0","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.sparse_embedding.CastedSparseEmbedding","uri":"program://TinyRecursiveModels/class/models.sparse_embedding.CastedSparseEmbedding#L11-L38","kind":"class","name":"CastedSparseEmbedding","path":"models/sparse_embedding.py","language":"python","start_line":11,"end_line":38,"context_start_line":1,"context_end_line":58,"code":"from typing import Union\n\nimport torch\nfrom torch import nn\nimport torch.distributed as dist\nfrom torch.optim.optimizer import Optimizer, ParamsT\n\nfrom models.common import trunc_normal_init_\n\n\nclass CastedSparseEmbedding(nn.Module):\n def __init__(self, num_embeddings: int, embedding_dim: int, batch_size: int, init_std: float, cast_to: torch.dtype):\n super().__init__()\n self.cast_to = cast_to\n\n # Real Weights\n # Truncated LeCun normal init\n self.weights = nn.Buffer(\n trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std), persistent=True\n )\n\n # Local weights and IDs\n # Local embeddings, with gradient, not persistent\n self.local_weights = nn.Buffer(torch.zeros(batch_size, embedding_dim, requires_grad=True), persistent=False)\n # Local embedding IDs, not persistent\n self.local_ids = nn.Buffer(torch.zeros(batch_size, dtype=torch.int32), persistent=False)\n\n def forward(self, inputs: torch.Tensor) -> torch.Tensor:\n if not self.training:\n # Test mode, no gradient\n return self.weights[inputs].to(self.cast_to)\n \n # Training mode, fill puzzle embedding from weights\n with torch.no_grad():\n self.local_weights.copy_(self.weights[inputs])\n self.local_ids.copy_(inputs)\n\n return self.local_weights.to(self.cast_to)\n\n\nclass CastedSparseEmbeddingSignSGD_Distributed(Optimizer):\n def __init__(\n self,\n params: ParamsT,\n\n world_size: int,\n lr: Union[float, torch.Tensor] = 1e-3,\n weight_decay: float = 1e-2,\n ):\n if not 0.0 <= lr:\n raise ValueError(f\"Invalid learning rate: {lr}\")\n if not 0.0 <= weight_decay:\n raise ValueError(f\"Invalid weight_decay value: {weight_decay}\")\n\n defaults = dict(\n lr=lr,\n weight_decay=weight_decay,\n world_size=world_size","source_hash":"9429742ce022918751331acf92c1a9b8d0f2f364e9acef5d71fb81b886c7a2d0","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.sparse_embedding.CastedSparseEmbeddingSignSGD_Distributed","uri":"program://TinyRecursiveModels/class/models.sparse_embedding.CastedSparseEmbeddingSignSGD_Distributed#L41-L95","kind":"class","name":"CastedSparseEmbeddingSignSGD_Distributed","path":"models/sparse_embedding.py","language":"python","start_line":41,"end_line":95,"context_start_line":21,"context_end_line":115,"code":"\n # Local weights and IDs\n # Local embeddings, with gradient, not persistent\n self.local_weights = nn.Buffer(torch.zeros(batch_size, embedding_dim, requires_grad=True), persistent=False)\n # Local embedding IDs, not persistent\n self.local_ids = nn.Buffer(torch.zeros(batch_size, dtype=torch.int32), persistent=False)\n\n def forward(self, inputs: torch.Tensor) -> torch.Tensor:\n if not self.training:\n # Test mode, no gradient\n return self.weights[inputs].to(self.cast_to)\n \n # Training mode, fill puzzle embedding from weights\n with torch.no_grad():\n self.local_weights.copy_(self.weights[inputs])\n self.local_ids.copy_(inputs)\n\n return self.local_weights.to(self.cast_to)\n\n\nclass CastedSparseEmbeddingSignSGD_Distributed(Optimizer):\n def __init__(\n self,\n params: ParamsT,\n\n world_size: int,\n lr: Union[float, torch.Tensor] = 1e-3,\n weight_decay: float = 1e-2,\n ):\n if not 0.0 <= lr:\n raise ValueError(f\"Invalid learning rate: {lr}\")\n if not 0.0 <= weight_decay:\n raise ValueError(f\"Invalid weight_decay value: {weight_decay}\")\n\n defaults = dict(\n lr=lr,\n weight_decay=weight_decay,\n world_size=world_size\n )\n super().__init__(params, defaults)\n\n @torch.no_grad\n def step(self, closure=None): # type: ignore\n for group in self.param_groups:\n # Find the sparse embedding weights\n local_weights_grad = None\n local_ids = None\n weights = None\n \n assert len(group[\"params\"]) == 3\n for p in group[\"params\"]:\n if p.requires_grad:\n local_weights_grad = p.grad\n elif p.ndim == 1:\n local_ids = p\n elif p.ndim == 2:\n weights = p\n else:\n assert False\n \n assert local_ids is not None\n assert weights is not None\n \n # Apply SignSGD\n # Adam ≈ SignSGD if gradient is very sparse\n if local_weights_grad is not None:\n _sparse_emb_signsgd_dist(\n local_weights_grad,\n local_ids,\n weights,\n \n lr=group[\"lr\"],\n weight_decay=group[\"weight_decay\"],\n world_size=group[\"world_size\"]\n )\n\n\ndef _sparse_emb_signsgd_dist(\n local_weights_grad: torch.Tensor,\n local_ids: torch.Tensor,\n weights: torch.Tensor,\n \n lr: float,\n weight_decay: float,\n world_size: int\n) -> None:\n N, D = local_weights_grad.shape\n \n # All-gather\n all_weights_grad = local_weights_grad\n all_ids = local_ids\n\n if world_size > 1:\n all_weights_grad = torch.empty((world_size * N, D), dtype=local_weights_grad.dtype, device=local_weights_grad.device)\n all_ids = torch.empty(world_size * N, dtype=local_ids.dtype, device=local_ids.device)","source_hash":"9429742ce022918751331acf92c1a9b8d0f2f364e9acef5d71fb81b886c7a2d0","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.sparse_embedding._sparse_emb_signsgd_dist","uri":"program://TinyRecursiveModels/function/models.sparse_embedding._sparse_emb_signsgd_dist#L98-L132","kind":"function","name":"_sparse_emb_signsgd_dist","path":"models/sparse_embedding.py","language":"python","start_line":98,"end_line":132,"context_start_line":78,"context_end_line":132,"code":" else:\n assert False\n \n assert local_ids is not None\n assert weights is not None\n \n # Apply SignSGD\n # Adam ≈ SignSGD if gradient is very sparse\n if local_weights_grad is not None:\n _sparse_emb_signsgd_dist(\n local_weights_grad,\n local_ids,\n weights,\n \n lr=group[\"lr\"],\n weight_decay=group[\"weight_decay\"],\n world_size=group[\"world_size\"]\n )\n\n\ndef _sparse_emb_signsgd_dist(\n local_weights_grad: torch.Tensor,\n local_ids: torch.Tensor,\n weights: torch.Tensor,\n \n lr: float,\n weight_decay: float,\n world_size: int\n) -> None:\n N, D = local_weights_grad.shape\n \n # All-gather\n all_weights_grad = local_weights_grad\n all_ids = local_ids\n\n if world_size > 1:\n all_weights_grad = torch.empty((world_size * N, D), dtype=local_weights_grad.dtype, device=local_weights_grad.device)\n all_ids = torch.empty(world_size * N, dtype=local_ids.dtype, device=local_ids.device)\n \n dist.all_gather_into_tensor(all_weights_grad, local_weights_grad)\n dist.all_gather_into_tensor(all_ids, local_ids)\n\n # Unique\n grad_ids, inv = all_ids.unique(return_inverse=True)\n\n grad = torch.zeros((grad_ids.shape[0], D), dtype=all_weights_grad.dtype, device=all_weights_grad.device)\n grad.scatter_add_(0, inv.unsqueeze(-1).expand(-1, D), all_weights_grad)\n\n # SignSGD with decoupled weight decay\n p = weights[grad_ids]\n\n p.mul_(1.0 - lr * weight_decay).add_(torch.sign(grad), alpha=-lr)\n\n # Write updated slices back\n weights[grad_ids] = p","source_hash":"9429742ce022918751331acf92c1a9b8d0f2f364e9acef5d71fb81b886c7a2d0","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.sparse_embedding.__init__","uri":"program://TinyRecursiveModels/function/models.sparse_embedding.__init__#L42-L60","kind":"function","name":"__init__","path":"models/sparse_embedding.py","language":"python","start_line":42,"end_line":60,"context_start_line":22,"context_end_line":80,"code":" # Local weights and IDs\n # Local embeddings, with gradient, not persistent\n self.local_weights = nn.Buffer(torch.zeros(batch_size, embedding_dim, requires_grad=True), persistent=False)\n # Local embedding IDs, not persistent\n self.local_ids = nn.Buffer(torch.zeros(batch_size, dtype=torch.int32), persistent=False)\n\n def forward(self, inputs: torch.Tensor) -> torch.Tensor:\n if not self.training:\n # Test mode, no gradient\n return self.weights[inputs].to(self.cast_to)\n \n # Training mode, fill puzzle embedding from weights\n with torch.no_grad():\n self.local_weights.copy_(self.weights[inputs])\n self.local_ids.copy_(inputs)\n\n return self.local_weights.to(self.cast_to)\n\n\nclass CastedSparseEmbeddingSignSGD_Distributed(Optimizer):\n def __init__(\n self,\n params: ParamsT,\n\n world_size: int,\n lr: Union[float, torch.Tensor] = 1e-3,\n weight_decay: float = 1e-2,\n ):\n if not 0.0 <= lr:\n raise ValueError(f\"Invalid learning rate: {lr}\")\n if not 0.0 <= weight_decay:\n raise ValueError(f\"Invalid weight_decay value: {weight_decay}\")\n\n defaults = dict(\n lr=lr,\n weight_decay=weight_decay,\n world_size=world_size\n )\n super().__init__(params, defaults)\n\n @torch.no_grad\n def step(self, closure=None): # type: ignore\n for group in self.param_groups:\n # Find the sparse embedding weights\n local_weights_grad = None\n local_ids = None\n weights = None\n \n assert len(group[\"params\"]) == 3\n for p in group[\"params\"]:\n if p.requires_grad:\n local_weights_grad = p.grad\n elif p.ndim == 1:\n local_ids = p\n elif p.ndim == 2:\n weights = p\n else:\n assert False\n ","source_hash":"9429742ce022918751331acf92c1a9b8d0f2f364e9acef5d71fb81b886c7a2d0","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.sparse_embedding.forward","uri":"program://TinyRecursiveModels/function/models.sparse_embedding.forward#L28-L38","kind":"function","name":"forward","path":"models/sparse_embedding.py","language":"python","start_line":28,"end_line":38,"context_start_line":8,"context_end_line":58,"code":"from models.common import trunc_normal_init_\n\n\nclass CastedSparseEmbedding(nn.Module):\n def __init__(self, num_embeddings: int, embedding_dim: int, batch_size: int, init_std: float, cast_to: torch.dtype):\n super().__init__()\n self.cast_to = cast_to\n\n # Real Weights\n # Truncated LeCun normal init\n self.weights = nn.Buffer(\n trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std), persistent=True\n )\n\n # Local weights and IDs\n # Local embeddings, with gradient, not persistent\n self.local_weights = nn.Buffer(torch.zeros(batch_size, embedding_dim, requires_grad=True), persistent=False)\n # Local embedding IDs, not persistent\n self.local_ids = nn.Buffer(torch.zeros(batch_size, dtype=torch.int32), persistent=False)\n\n def forward(self, inputs: torch.Tensor) -> torch.Tensor:\n if not self.training:\n # Test mode, no gradient\n return self.weights[inputs].to(self.cast_to)\n \n # Training mode, fill puzzle embedding from weights\n with torch.no_grad():\n self.local_weights.copy_(self.weights[inputs])\n self.local_ids.copy_(inputs)\n\n return self.local_weights.to(self.cast_to)\n\n\nclass CastedSparseEmbeddingSignSGD_Distributed(Optimizer):\n def __init__(\n self,\n params: ParamsT,\n\n world_size: int,\n lr: Union[float, torch.Tensor] = 1e-3,\n weight_decay: float = 1e-2,\n ):\n if not 0.0 <= lr:\n raise ValueError(f\"Invalid learning rate: {lr}\")\n if not 0.0 <= weight_decay:\n raise ValueError(f\"Invalid weight_decay value: {weight_decay}\")\n\n defaults = dict(\n lr=lr,\n weight_decay=weight_decay,\n world_size=world_size","source_hash":"9429742ce022918751331acf92c1a9b8d0f2f364e9acef5d71fb81b886c7a2d0","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.sparse_embedding.step","uri":"program://TinyRecursiveModels/function/models.sparse_embedding.step#L63-L95","kind":"function","name":"step","path":"models/sparse_embedding.py","language":"python","start_line":63,"end_line":95,"context_start_line":43,"context_end_line":115,"code":" self,\n params: ParamsT,\n\n world_size: int,\n lr: Union[float, torch.Tensor] = 1e-3,\n weight_decay: float = 1e-2,\n ):\n if not 0.0 <= lr:\n raise ValueError(f\"Invalid learning rate: {lr}\")\n if not 0.0 <= weight_decay:\n raise ValueError(f\"Invalid weight_decay value: {weight_decay}\")\n\n defaults = dict(\n lr=lr,\n weight_decay=weight_decay,\n world_size=world_size\n )\n super().__init__(params, defaults)\n\n @torch.no_grad\n def step(self, closure=None): # type: ignore\n for group in self.param_groups:\n # Find the sparse embedding weights\n local_weights_grad = None\n local_ids = None\n weights = None\n \n assert len(group[\"params\"]) == 3\n for p in group[\"params\"]:\n if p.requires_grad:\n local_weights_grad = p.grad\n elif p.ndim == 1:\n local_ids = p\n elif p.ndim == 2:\n weights = p\n else:\n assert False\n \n assert local_ids is not None\n assert weights is not None\n \n # Apply SignSGD\n # Adam ≈ SignSGD if gradient is very sparse\n if local_weights_grad is not None:\n _sparse_emb_signsgd_dist(\n local_weights_grad,\n local_ids,\n weights,\n \n lr=group[\"lr\"],\n weight_decay=group[\"weight_decay\"],\n world_size=group[\"world_size\"]\n )\n\n\ndef _sparse_emb_signsgd_dist(\n local_weights_grad: torch.Tensor,\n local_ids: torch.Tensor,\n weights: torch.Tensor,\n \n lr: float,\n weight_decay: float,\n world_size: int\n) -> None:\n N, D = local_weights_grad.shape\n \n # All-gather\n all_weights_grad = local_weights_grad\n all_ids = local_ids\n\n if world_size > 1:\n all_weights_grad = torch.empty((world_size * N, D), dtype=local_weights_grad.dtype, device=local_weights_grad.device)\n all_ids = torch.empty(world_size * N, dtype=local_ids.dtype, device=local_ids.device)","source_hash":"9429742ce022918751331acf92c1a9b8d0f2f364e9acef5d71fb81b886c7a2d0","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm","uri":"program://TinyRecursiveModels/module/models.recursive_reasoning.trm#L1-L297","kind":"module","name":"models.recursive_reasoning.trm","path":"models/recursive_reasoning/trm.py","language":"python","start_line":1,"end_line":297,"context_start_line":1,"context_end_line":297,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int # ignored\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool = False # use mlp on L instead of transformer\n puzzle_emb_len: int = 16 # if non-zero, its specified to this value\n no_ACT_continue: bool = True # No continue ACT loss, only use the sigmoid of the halt which makes much more sense\n\nclass TinyRecursiveReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n hidden_states = hidden_states + input_injection\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype)\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.L_level = TinyRecursiveReasoningModel_ACTV1ReasoningModule(layers=[TinyRecursiveReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_H, z_L = carry.z_H, carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n \n if self.config.no_ACT_continue:\n halted = halted | (q_halt_logits > 0)\n else:\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n if not self.config.no_ACT_continue:\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n _, _, (next_q_halt_logits, next_q_continue_logits), _, _ = self.inner(new_inner_carry, new_current_data)\n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return TinyRecursiveReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1InnerCarry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1InnerCarry#L17-L19","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1InnerCarry","path":"models/recursive_reasoning/trm.py","language":"python","start_line":17,"end_line":19,"context_start_line":1,"context_end_line":39,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1Carry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1Carry#L23-L29","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1Carry","path":"models/recursive_reasoning/trm.py","language":"python","start_line":23,"end_line":29,"context_start_line":3,"context_end_line":49,"code":"import math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int # ignored\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1Config","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1Config#L32-L63","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1Config","path":"models/recursive_reasoning/trm.py","language":"python","start_line":32,"end_line":63,"context_start_line":12,"context_end_line":83,"code":"from models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int # ignored\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool = False # use mlp on L instead of transformer\n puzzle_emb_len: int = 16 # if non-zero, its specified to this value\n no_ACT_continue: bool = True # No continue ACT loss, only use the sigmoid of the halt which makes much more sense\n\nclass TinyRecursiveReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1Block","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1Block#L65-L104","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1Block","path":"models/recursive_reasoning/trm.py","language":"python","start_line":65,"end_line":104,"context_start_line":45,"context_end_line":124,"code":" # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool = False # use mlp on L instead of transformer\n puzzle_emb_len: int = 16 # if non-zero, its specified to this value\n no_ACT_continue: bool = True # No continue ACT loss, only use the sigmoid of the halt which makes much more sense\n\nclass TinyRecursiveReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n hidden_states = hidden_states + input_injection\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1ReasoningModule","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1ReasoningModule#L106-L115","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1ReasoningModule","path":"models/recursive_reasoning/trm.py","language":"python","start_line":106,"end_line":115,"context_start_line":86,"context_end_line":135,"code":" expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n hidden_states = hidden_states + input_injection\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1_Inner","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1_Inner#L118-L222","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1_Inner","path":"models/recursive_reasoning/trm.py","language":"python","start_line":118,"end_line":222,"context_start_line":98,"context_end_line":242,"code":" else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n hidden_states = hidden_states + input_injection\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype)\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.L_level = TinyRecursiveReasoningModel_ACTV1ReasoningModule(layers=[TinyRecursiveReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_H, z_L = carry.z_H, carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n ","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm.TinyRecursiveReasoningModel_ACTV1#L225-L297","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1","path":"models/recursive_reasoning/trm.py","language":"python","start_line":225,"end_line":297,"context_start_line":205,"context_end_line":297,"code":" it = 0\n z_H, z_L = carry.z_H, carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n \n if self.config.no_ACT_continue:\n halted = halted | (q_halt_logits > 0)\n else:\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n if not self.config.no_ACT_continue:\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n _, _, (next_q_halt_logits, next_q_continue_logits), _, _ = self.inner(new_inner_carry, new_current_data)\n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return TinyRecursiveReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.__init__","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm.__init__#L228-L231","kind":"function","name":"__init__","path":"models/recursive_reasoning/trm.py","language":"python","start_line":228,"end_line":231,"context_start_line":208,"context_end_line":251,"code":" with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.forward","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm.forward#L249-L297","kind":"function","name":"forward","path":"models/recursive_reasoning/trm.py","language":"python","start_line":249,"end_line":297,"context_start_line":229,"context_end_line":297,"code":" super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n \n if self.config.no_ACT_continue:\n halted = halted | (q_halt_logits > 0)\n else:\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n if not self.config.no_ACT_continue:\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n _, _, (next_q_halt_logits, next_q_continue_logits), _, _ = self.inner(new_inner_carry, new_current_data)\n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return TinyRecursiveReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm._input_embeddings","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm._input_embeddings#L162-L182","kind":"function","name":"_input_embeddings","path":"models/recursive_reasoning/trm.py","language":"python","start_line":162,"end_line":182,"context_start_line":142,"context_end_line":202,"code":" max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.L_level = TinyRecursiveReasoningModel_ACTV1ReasoningModule(layers=[TinyRecursiveReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.empty_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm.empty_carry#L184-L188","kind":"function","name":"empty_carry","path":"models/recursive_reasoning/trm.py","language":"python","start_line":184,"end_line":188,"context_start_line":164,"context_end_line":208,"code":" embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_H, z_L = carry.z_H, carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.reset_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm.reset_carry#L190-L194","kind":"function","name":"reset_carry","path":"models/recursive_reasoning/trm.py","language":"python","start_line":190,"end_line":194,"context_start_line":170,"context_end_line":214,"code":" pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_H, z_L = carry.z_H, carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.puzzle_emb","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm.puzzle_emb#L234-L235","kind":"function","name":"puzzle_emb","path":"models/recursive_reasoning/trm.py","language":"python","start_line":234,"end_line":235,"context_start_line":214,"context_end_line":255,"code":" for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.L_level(z_H, z_L, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm.initial_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm.initial_carry#L237-L247","kind":"function","name":"initial_carry","path":"models/recursive_reasoning/trm.py","language":"python","start_line":237,"end_line":247,"context_start_line":217,"context_end_line":267,"code":"\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6","uri":"program://TinyRecursiveModels/module/models.recursive_reasoning.trm_hier6#L1-L323","kind":"module","name":"models.recursive_reasoning.trm_hier6","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":1,"end_line":323,"context_start_line":1,"context_end_line":323,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L1: torch.Tensor\n z_L2: torch.Tensor\n z_L3: torch.Tensor\n z_L4: torch.Tensor\n z_L5: torch.Tensor\n z_L6: torch.Tensor\n\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int # ignored\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool = False # use mlp on L instead of transformer\n puzzle_emb_len: int = 16 # if non-zero, its specified to this value\n no_ACT_continue: bool = True # No continue ACT loss, only use the sigmoid of the halt which makes much more sense\n\nclass TinyRecursiveReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n hidden_states = hidden_states + input_injection\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype)\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.L_level = TinyRecursiveReasoningModel_ACTV1ReasoningModule(layers=[TinyRecursiveReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L1_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L2_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L3_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L4_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L5_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L6_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L1=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L2=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L3=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L4=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L5=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L6=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L1=torch.where(reset_flag.view(-1, 1, 1), self.L1_init, carry.z_L1),\n z_L2=torch.where(reset_flag.view(-1, 1, 1), self.L2_init, carry.z_L2),\n z_L3=torch.where(reset_flag.view(-1, 1, 1), self.L3_init, carry.z_L3),\n z_L4=torch.where(reset_flag.view(-1, 1, 1), self.L4_init, carry.z_L4),\n z_L5=torch.where(reset_flag.view(-1, 1, 1), self.L5_init, carry.z_L5),\n z_L6=torch.where(reset_flag.view(-1, 1, 1), self.L6_init, carry.z_L6),\n )\n\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_H, z_L = carry.z_H, [carry.z_L1, carry.z_L2, carry.z_L3, carry.z_L4, carry.z_L5, carry.z_L6]\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_H = self.L_level(z_H, z_L_, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_H = self.L_level(z_H, z_L_, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L1=z_L[0].detach(), z_L2=z_L[1].detach(), z_L3=z_L[2].detach(), z_L4=z_L[3].detach(), z_L5=z_L[4].detach(), z_L6=z_L[5].detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n \n if self.config.no_ACT_continue:\n halted = halted | (q_halt_logits > 0)\n else:\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n if not self.config.no_ACT_continue:\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n _, _, (next_q_halt_logits, next_q_continue_logits), _, _ = self.inner(new_inner_carry, new_current_data)\n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return TinyRecursiveReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1InnerCarry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1InnerCarry#L17-L24","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1InnerCarry","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":17,"end_line":24,"context_start_line":1,"context_end_line":44,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L1: torch.Tensor\n z_L2: torch.Tensor\n z_L3: torch.Tensor\n z_L4: torch.Tensor\n z_L5: torch.Tensor\n z_L6: torch.Tensor\n\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1Carry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1Carry#L29-L35","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1Carry","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":29,"end_line":35,"context_start_line":9,"context_end_line":55,"code":"import random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L1: torch.Tensor\n z_L2: torch.Tensor\n z_L3: torch.Tensor\n z_L4: torch.Tensor\n z_L5: torch.Tensor\n z_L6: torch.Tensor\n\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int # ignored\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1Config","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1Config#L38-L69","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1Config","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":38,"end_line":69,"context_start_line":18,"context_end_line":89,"code":" z_H: torch.Tensor\n z_L1: torch.Tensor\n z_L2: torch.Tensor\n z_L3: torch.Tensor\n z_L4: torch.Tensor\n z_L5: torch.Tensor\n z_L6: torch.Tensor\n\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int # ignored\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool = False # use mlp on L instead of transformer\n puzzle_emb_len: int = 16 # if non-zero, its specified to this value\n no_ACT_continue: bool = True # No continue ACT loss, only use the sigmoid of the halt which makes much more sense\n\nclass TinyRecursiveReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1Block","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1Block#L71-L110","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1Block","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":71,"end_line":110,"context_start_line":51,"context_end_line":130,"code":" # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool = False # use mlp on L instead of transformer\n puzzle_emb_len: int = 16 # if non-zero, its specified to this value\n no_ACT_continue: bool = True # No continue ACT loss, only use the sigmoid of the halt which makes much more sense\n\nclass TinyRecursiveReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n hidden_states = hidden_states + input_injection\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1ReasoningModule","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1ReasoningModule#L112-L121","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1ReasoningModule","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":112,"end_line":121,"context_start_line":92,"context_end_line":141,"code":" expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n hidden_states = hidden_states + input_injection\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1_Inner","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1_Inner#L124-L248","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1_Inner","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":124,"end_line":248,"context_start_line":104,"context_end_line":268,"code":" else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n hidden_states = hidden_states + input_injection\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype)\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.L_level = TinyRecursiveReasoningModel_ACTV1ReasoningModule(layers=[TinyRecursiveReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L1_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L2_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L3_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L4_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L5_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L6_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L1=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L2=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L3=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L4=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L5=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L6=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L1=torch.where(reset_flag.view(-1, 1, 1), self.L1_init, carry.z_L1),\n z_L2=torch.where(reset_flag.view(-1, 1, 1), self.L2_init, carry.z_L2),\n z_L3=torch.where(reset_flag.view(-1, 1, 1), self.L3_init, carry.z_L3),\n z_L4=torch.where(reset_flag.view(-1, 1, 1), self.L4_init, carry.z_L4),\n z_L5=torch.where(reset_flag.view(-1, 1, 1), self.L5_init, carry.z_L5),\n z_L6=torch.where(reset_flag.view(-1, 1, 1), self.L6_init, carry.z_L6),\n )\n\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_H, z_L = carry.z_H, [carry.z_L1, carry.z_L2, carry.z_L3, carry.z_L4, carry.z_L5, carry.z_L6]\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_H = self.L_level(z_H, z_L_, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_H = self.L_level(z_H, z_L_, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L1=z_L[0].detach(), z_L2=z_L[1].detach(), z_L3=z_L[2].detach(), z_L4=z_L[3].detach(), z_L5=z_L[4].detach(), z_L6=z_L[5].detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n ","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_hier6.TinyRecursiveReasoningModel_ACTV1#L251-L323","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":251,"end_line":323,"context_start_line":231,"context_end_line":323,"code":" for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_H = self.L_level(z_H, z_L_, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_H = self.L_level(z_H, z_L_, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L1=z_L[0].detach(), z_L2=z_L[1].detach(), z_L3=z_L[2].detach(), z_L4=z_L[3].detach(), z_L5=z_L[4].detach(), z_L6=z_L[5].detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n \n if self.config.no_ACT_continue:\n halted = halted | (q_halt_logits > 0)\n else:\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n if not self.config.no_ACT_continue:\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n _, _, (next_q_halt_logits, next_q_continue_logits), _, _ = self.inner(new_inner_carry, new_current_data)\n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return TinyRecursiveReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.__init__","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_hier6.__init__#L254-L257","kind":"function","name":"__init__","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":254,"end_line":257,"context_start_line":234,"context_end_line":277,"code":" z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_H = self.L_level(z_H, z_L_, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_H = self.L_level(z_H, z_L_, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L1=z_L[0].detach(), z_L2=z_L[1].detach(), z_L3=z_L[2].detach(), z_L4=z_L[3].detach(), z_L5=z_L[4].detach(), z_L6=z_L[5].detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.forward","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_hier6.forward#L275-L323","kind":"function","name":"forward","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":275,"end_line":323,"context_start_line":255,"context_end_line":323,"code":" super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n \n if self.config.no_ACT_continue:\n halted = halted | (q_halt_logits > 0)\n else:\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n if not self.config.no_ACT_continue:\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n _, _, (next_q_halt_logits, next_q_continue_logits), _, _ = self.inner(new_inner_carry, new_current_data)\n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return TinyRecursiveReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6._input_embeddings","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_hier6._input_embeddings#L173-L193","kind":"function","name":"_input_embeddings","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":173,"end_line":193,"context_start_line":153,"context_end_line":213,"code":" pass\n\n # Reasoning Layers\n self.L_level = TinyRecursiveReasoningModel_ACTV1ReasoningModule(layers=[TinyRecursiveReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L1_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L2_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L3_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L4_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L5_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L6_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L1=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L2=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L3=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L4=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L5=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L6=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L1=torch.where(reset_flag.view(-1, 1, 1), self.L1_init, carry.z_L1),\n z_L2=torch.where(reset_flag.view(-1, 1, 1), self.L2_init, carry.z_L2),\n z_L3=torch.where(reset_flag.view(-1, 1, 1), self.L3_init, carry.z_L3),\n z_L4=torch.where(reset_flag.view(-1, 1, 1), self.L4_init, carry.z_L4),\n z_L5=torch.where(reset_flag.view(-1, 1, 1), self.L5_init, carry.z_L5),","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.empty_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_hier6.empty_carry#L195-L204","kind":"function","name":"empty_carry","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":195,"end_line":204,"context_start_line":175,"context_end_line":224,"code":" embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L1=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L2=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L3=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L4=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L5=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L6=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L1=torch.where(reset_flag.view(-1, 1, 1), self.L1_init, carry.z_L1),\n z_L2=torch.where(reset_flag.view(-1, 1, 1), self.L2_init, carry.z_L2),\n z_L3=torch.where(reset_flag.view(-1, 1, 1), self.L3_init, carry.z_L3),\n z_L4=torch.where(reset_flag.view(-1, 1, 1), self.L4_init, carry.z_L4),\n z_L5=torch.where(reset_flag.view(-1, 1, 1), self.L5_init, carry.z_L5),\n z_L6=torch.where(reset_flag.view(-1, 1, 1), self.L6_init, carry.z_L6),\n )\n\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.reset_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_hier6.reset_carry#L206-L215","kind":"function","name":"reset_carry","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":206,"end_line":215,"context_start_line":186,"context_end_line":235,"code":"\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L1=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L2=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L3=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L4=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L5=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L6=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L1=torch.where(reset_flag.view(-1, 1, 1), self.L1_init, carry.z_L1),\n z_L2=torch.where(reset_flag.view(-1, 1, 1), self.L2_init, carry.z_L2),\n z_L3=torch.where(reset_flag.view(-1, 1, 1), self.L3_init, carry.z_L3),\n z_L4=torch.where(reset_flag.view(-1, 1, 1), self.L4_init, carry.z_L4),\n z_L5=torch.where(reset_flag.view(-1, 1, 1), self.L5_init, carry.z_L5),\n z_L6=torch.where(reset_flag.view(-1, 1, 1), self.L6_init, carry.z_L6),\n )\n\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_H, z_L = carry.z_H, [carry.z_L1, carry.z_L2, carry.z_L3, carry.z_L4, carry.z_L5, carry.z_L6]\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.puzzle_emb","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_hier6.puzzle_emb#L260-L261","kind":"function","name":"puzzle_emb","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":260,"end_line":261,"context_start_line":240,"context_end_line":281,"code":" z_L[_L_step] = self.L_level(z_L_, z_H + input_embeddings, **seq_info)\n z_L_ = z_L[0] + z_L[1] + z_L[2] + z_L[3] + z_L[4] + z_L[5]\n z_H = self.L_level(z_H, z_L_, **seq_info)\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L1=z_L[0].detach(), z_L2=z_L[1].detach(), z_L3=z_L[2].detach(), z_L4=z_L[3].detach(), z_L5=z_L[4].detach(), z_L6=z_L[5].detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_hier6.initial_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_hier6.initial_carry#L263-L273","kind":"function","name":"initial_carry","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":263,"end_line":273,"context_start_line":243,"context_end_line":293,"code":"\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L1=z_L[0].detach(), z_L2=z_L[1].detach(), z_L3=z_L[2].detach(), z_L4=z_L[3].detach(), z_L5=z_L[4].detach(), z_L6=z_L[5].detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm","uri":"program://TinyRecursiveModels/module/models.recursive_reasoning.hrm#L1-L294","kind":"module","name":"models.recursive_reasoning.hrm","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":1,"end_line":294,"context_start_line":1,"context_end_line":294,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\n\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1Carry:\n inner_carry: HierarchicalReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass HierarchicalReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool=False # use mlp on L instead of transformer\n\nclass HierarchicalReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size)\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass HierarchicalReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[HierarchicalReasoningModel_ACTV1Block]):\n super().__init__()\n\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n # Input injection (add)\n hidden_states = hidden_states + input_injection\n # Layers\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n\n return hidden_states\n\n\nclass HierarchicalReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype)\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.H_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.H_layers)])\n self.L_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: HierarchicalReasoningModel_ACTV1InnerCarry):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: HierarchicalReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n with torch.no_grad():\n z_H, z_L = carry.z_H, carry.z_L\n for _H_step in range(self.config.H_cycles):\n for _L_step in range(self.config.L_cycles):\n if not ((_H_step == self.config.H_cycles - 1) and (_L_step == self.config.L_cycles - 1)):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n if not (_H_step == self.config.H_cycles - 1):\n z_H = self.H_level(z_H, z_L, **seq_info)\n assert not z_H.requires_grad and not z_L.requires_grad\n # 1-step grad\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.H_level(z_H, z_L, **seq_info)\n\n # LM Outputs\n new_carry = HierarchicalReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n \n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass HierarchicalReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = HierarchicalReasoningModel_ACTV1Config(**config_dict)\n self.inner = HierarchicalReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return HierarchicalReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: HierarchicalReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n \n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n\n halted = halted & (new_steps >= min_halt_steps)\n\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n next_q_halt_logits, next_q_continue_logits = self.inner(new_inner_carry, new_current_data)[-1]\n \n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return HierarchicalReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1InnerCarry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1InnerCarry#L14-L16","kind":"class","name":"HierarchicalReasoningModel_ACTV1InnerCarry","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":14,"end_line":16,"context_start_line":1,"context_end_line":36,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\n\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1Carry:\n inner_carry: HierarchicalReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass HierarchicalReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1Carry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1Carry#L20-L26","kind":"class","name":"HierarchicalReasoningModel_ACTV1Carry","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":20,"end_line":26,"context_start_line":1,"context_end_line":46,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\n\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1Carry:\n inner_carry: HierarchicalReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass HierarchicalReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1Config","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1Config#L29-L58","kind":"class","name":"HierarchicalReasoningModel_ACTV1Config","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":29,"end_line":58,"context_start_line":9,"context_end_line":78,"code":"from models.common import trunc_normal_init_\nfrom models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1Carry:\n inner_carry: HierarchicalReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass HierarchicalReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool=False # use mlp on L instead of transformer\n\nclass HierarchicalReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size)\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1Block","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1Block#L60-L99","kind":"class","name":"HierarchicalReasoningModel_ACTV1Block","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":60,"end_line":99,"context_start_line":40,"context_end_line":119,"code":" L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool=False # use mlp on L instead of transformer\n\nclass HierarchicalReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size)\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass HierarchicalReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[HierarchicalReasoningModel_ACTV1Block]):\n super().__init__()\n\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n # Input injection (add)\n hidden_states = hidden_states + input_injection\n # Layers\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n\n return hidden_states\n\n\nclass HierarchicalReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None:\n super().__init__()","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1ReasoningModule","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1ReasoningModule#L101-L114","kind":"class","name":"HierarchicalReasoningModel_ACTV1ReasoningModule","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":101,"end_line":114,"context_start_line":81,"context_end_line":134,"code":" expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass HierarchicalReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[HierarchicalReasoningModel_ACTV1Block]):\n super().__init__()\n\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n # Input injection (add)\n hidden_states = hidden_states + input_injection\n # Layers\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n\n return hidden_states\n\n\nclass HierarchicalReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1_Inner","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1_Inner#L117-L224","kind":"class","name":"HierarchicalReasoningModel_ACTV1_Inner","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":117,"end_line":224,"context_start_line":97,"context_end_line":244,"code":" out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass HierarchicalReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[HierarchicalReasoningModel_ACTV1Block]):\n super().__init__()\n\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n # Input injection (add)\n hidden_states = hidden_states + input_injection\n # Layers\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n\n return hidden_states\n\n\nclass HierarchicalReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype)\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.H_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.H_layers)])\n self.L_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: HierarchicalReasoningModel_ACTV1InnerCarry):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: HierarchicalReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n with torch.no_grad():\n z_H, z_L = carry.z_H, carry.z_L\n for _H_step in range(self.config.H_cycles):\n for _L_step in range(self.config.L_cycles):\n if not ((_H_step == self.config.H_cycles - 1) and (_L_step == self.config.L_cycles - 1)):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n if not (_H_step == self.config.H_cycles - 1):\n z_H = self.H_level(z_H, z_L, **seq_info)\n assert not z_H.requires_grad and not z_L.requires_grad\n # 1-step grad\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.H_level(z_H, z_L, **seq_info)\n\n # LM Outputs\n new_carry = HierarchicalReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n \n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass HierarchicalReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = HierarchicalReasoningModel_ACTV1Config(**config_dict)\n self.inner = HierarchicalReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return HierarchicalReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n ","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.hrm.HierarchicalReasoningModel_ACTV1#L227-L294","kind":"class","name":"HierarchicalReasoningModel_ACTV1","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":227,"end_line":294,"context_start_line":207,"context_end_line":294,"code":" for _L_step in range(self.config.L_cycles):\n if not ((_H_step == self.config.H_cycles - 1) and (_L_step == self.config.L_cycles - 1)):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n if not (_H_step == self.config.H_cycles - 1):\n z_H = self.H_level(z_H, z_L, **seq_info)\n assert not z_H.requires_grad and not z_L.requires_grad\n # 1-step grad\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.H_level(z_H, z_L, **seq_info)\n\n # LM Outputs\n new_carry = HierarchicalReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n \n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass HierarchicalReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = HierarchicalReasoningModel_ACTV1Config(**config_dict)\n self.inner = HierarchicalReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return HierarchicalReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: HierarchicalReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n \n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n\n halted = halted & (new_steps >= min_halt_steps)\n\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n next_q_halt_logits, next_q_continue_logits = self.inner(new_inner_carry, new_current_data)[-1]\n \n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return HierarchicalReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.__init__","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.hrm.__init__#L230-L233","kind":"function","name":"__init__","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":230,"end_line":233,"context_start_line":210,"context_end_line":253,"code":" if not (_H_step == self.config.H_cycles - 1):\n z_H = self.H_level(z_H, z_L, **seq_info)\n assert not z_H.requires_grad and not z_L.requires_grad\n # 1-step grad\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n z_H = self.H_level(z_H, z_L, **seq_info)\n\n # LM Outputs\n new_carry = HierarchicalReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n \n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass HierarchicalReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = HierarchicalReasoningModel_ACTV1Config(**config_dict)\n self.inner = HierarchicalReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return HierarchicalReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: HierarchicalReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.forward","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.hrm.forward#L251-L294","kind":"function","name":"forward","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":251,"end_line":294,"context_start_line":231,"context_end_line":294,"code":" super().__init__()\n self.config = HierarchicalReasoningModel_ACTV1Config(**config_dict)\n self.inner = HierarchicalReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return HierarchicalReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: HierarchicalReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n \n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n\n halted = halted & (new_steps >= min_halt_steps)\n\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n next_q_halt_logits, next_q_continue_logits = self.inner(new_inner_carry, new_current_data)[-1]\n \n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return HierarchicalReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm._input_embeddings","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.hrm._input_embeddings#L161-L181","kind":"function","name":"_input_embeddings","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":161,"end_line":181,"context_start_line":141,"context_end_line":201,"code":" base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.H_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.H_layers)])\n self.L_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: HierarchicalReasoningModel_ACTV1InnerCarry):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: HierarchicalReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.empty_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.hrm.empty_carry#L183-L187","kind":"function","name":"empty_carry","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":183,"end_line":187,"context_start_line":163,"context_end_line":207,"code":" embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: HierarchicalReasoningModel_ACTV1InnerCarry):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: HierarchicalReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n with torch.no_grad():\n z_H, z_L = carry.z_H, carry.z_L\n for _H_step in range(self.config.H_cycles):\n for _L_step in range(self.config.L_cycles):","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.reset_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.hrm.reset_carry#L189-L193","kind":"function","name":"reset_carry","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":189,"end_line":193,"context_start_line":169,"context_end_line":213,"code":" pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: HierarchicalReasoningModel_ACTV1InnerCarry):\n return HierarchicalReasoningModel_ACTV1InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: HierarchicalReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n with torch.no_grad():\n z_H, z_L = carry.z_H, carry.z_L\n for _H_step in range(self.config.H_cycles):\n for _L_step in range(self.config.L_cycles):\n if not ((_H_step == self.config.H_cycles - 1) and (_L_step == self.config.L_cycles - 1)):\n z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info)\n if not (_H_step == self.config.H_cycles - 1):\n z_H = self.H_level(z_H, z_L, **seq_info)\n assert not z_H.requires_grad and not z_L.requires_grad\n # 1-step grad","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.puzzle_emb","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.hrm.puzzle_emb#L236-L237","kind":"function","name":"puzzle_emb","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":236,"end_line":237,"context_start_line":216,"context_end_line":257,"code":"\n # LM Outputs\n new_carry = HierarchicalReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n \n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass HierarchicalReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = HierarchicalReasoningModel_ACTV1Config(**config_dict)\n self.inner = HierarchicalReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return HierarchicalReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: HierarchicalReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.hrm.initial_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.hrm.initial_carry#L239-L249","kind":"function","name":"initial_carry","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":239,"end_line":249,"context_start_line":219,"context_end_line":269,"code":" output = self.lm_head(z_H)[:, self.puzzle_emb_len:]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n \n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass HierarchicalReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = HierarchicalReasoningModel_ACTV1Config(**config_dict)\n self.inner = HierarchicalReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return HierarchicalReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: HierarchicalReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n \n with torch.no_grad():\n # Step","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline","uri":"program://TinyRecursiveModels/module/models.recursive_reasoning.transformers_baseline#L1-L342","kind":"module","name":"models.recursive_reasoning.transformers_baseline","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":1,"end_line":342,"context_start_line":1,"context_end_line":342,"code":"\"\"\"\nHRM ACT V2: Transformer Baseline for Architecture Ablation\n\nThis is an architecture ablation of the Hierarchical Reasoning Model (HRM).\nKey changes from V1:\n1. REMOVED hierarchical split (no separate H and L levels)\n2. REMOVED inner cycles (no H_cycles/L_cycles loops within reasoning)\n3. KEPT ACT outer loop structure intact\n4. KEPT all data preprocessing, embeddings, and evaluation infrastructure\n\nArchitecture: Single-level transformer that processes the full 30x30 grid as a\n900-token sequence, with the same positional encodings and sparse embeddings as V1.\n\n\"\"\"\n\nfrom typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\n\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\n\n@dataclass\nclass Model_ACTV2InnerCarry:\n z_H: torch.Tensor\n\n\n@dataclass\nclass Model_ACTV2Carry:\n inner_carry: Model_ACTV2InnerCarry\n\n steps: torch.Tensor\n halted: torch.Tensor\n\n current_data: Dict[str, torch.Tensor]\n\n\nclass Model_ACTV2Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n\n H_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n\n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n act_enabled: bool = True # If False, always run halt_max_steps (no early stopping during training)\n act_inference: bool = False # If True, use adaptive computation during inference\n\n forward_dtype: str = \"bfloat16\"\n\n\nclass Model_ACTV2Block(nn.Module):\n def __init__(self, config: Model_ACTV2Config) -> None:\n super().__init__()\n\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False,\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # Post Norm\n # Self Attention\n hidden_states = rms_norm(\n hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states),\n variance_epsilon=self.norm_eps,\n )\n # Fully Connected\n hidden_states = rms_norm(hidden_states + self.mlp(hidden_states), variance_epsilon=self.norm_eps)\n return hidden_states\n\n\nclass Model_ACTV2ReasoningModule(nn.Module):\n def __init__(self, layers: List[Model_ACTV2Block]):\n super().__init__()\n\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n # Input injection (add)\n hidden_states = hidden_states + input_injection\n # Layers\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n\n return hidden_states\n\n\nclass Model_ACTV2_Inner(nn.Module):\n def __init__(self, config: Model_ACTV2Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(\n self.config.vocab_size,\n self.config.hidden_size,\n init_std=embed_init_std,\n cast_to=self.forward_dtype,\n )\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(\n self.config.num_puzzle_identifiers,\n self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size,\n init_std=0,\n cast_to=self.forward_dtype,\n )\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(\n dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta,\n )\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(\n self.config.seq_len + self.puzzle_emb_len,\n self.config.hidden_size,\n init_std=embed_init_std,\n cast_to=self.forward_dtype,\n )\n else:\n raise NotImplementedError()\n\n # Reasoning Layers\n self.H_level = Model_ACTV2ReasoningModule(\n layers=[Model_ACTV2Block(self.config) for _i in range(self.config.H_layers)]\n )\n\n # Initial states\n self.H_init = nn.Buffer(\n trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1),\n persistent=True,\n )\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n\n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat(\n (puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2\n )\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return Model_ACTV2InnerCarry(\n z_H=torch.empty(\n batch_size,\n self.config.seq_len + self.puzzle_emb_len,\n self.config.hidden_size,\n dtype=self.forward_dtype,\n ),\n )\n\n def reset_carry(self, reset_flag: torch.Tensor, carry: Model_ACTV2InnerCarry):\n return Model_ACTV2InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n )\n\n def forward(\n self, carry: Model_ACTV2InnerCarry, batch: Dict[str, torch.Tensor]\n ) -> Tuple[Model_ACTV2InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # 1-step grad\n z_H = self.H_level(carry.z_H, input_embeddings, **seq_info)\n\n # LM Outputs\n new_carry = Model_ACTV2InnerCarry(\n z_H=z_H.detach(),\n ) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len :]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass Model_ACTV2(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = Model_ACTV2Config(**config_dict)\n self.inner = Model_ACTV2_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return Model_ACTV2Carry(\n inner_carry=self.inner.empty_carry(\n batch_size\n ), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n steps=torch.zeros((batch_size,), dtype=torch.int32),\n halted=torch.ones((batch_size,), dtype=torch.bool), # Default to halted\n current_data={k: torch.empty_like(v) for k, v in batch.items()},\n )\n\n def forward(\n self,\n carry: Model_ACTV2Carry,\n batch: Dict[str, torch.Tensor],\n compute_target_q: bool = False,\n ) -> Tuple[Model_ACTV2Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n\n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {\n k: torch.where(carry.halted.view((-1,) + (1,) * (batch[k].ndim - 1)), batch[k], v)\n for k, v in carry.current_data.items()\n }\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(\n new_inner_carry, new_current_data\n )\n\n outputs = {\"logits\": logits, \"q_halt_logits\": q_halt_logits, \"q_continue_logits\": q_continue_logits}\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n\n halted = is_last_step\n\n # Check if adaptive computation should be used\n use_adaptive = (self.config.halt_max_steps > 1) and (\n (self.training and self.config.act_enabled)\n or (not self.training and self.config.act_inference)\n )\n\n if use_adaptive:\n # Halt signal based on Q-values (but always halt at max steps)\n q_halt_signal = q_halt_logits > q_continue_logits\n halted = halted | q_halt_signal\n\n # Store actual steps used for logging (only during inference)\n if not self.training:\n outputs[\"actual_steps\"] = new_steps.float()\n\n # Exploration (only during training)\n if self.training:\n min_halt_steps = (\n torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob\n ) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n # Compute target Q (only during training)\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n if self.training and compute_target_q:\n next_q_halt_logits, next_q_continue_logits = self.inner(\n new_inner_carry, new_current_data\n )[-1]\n\n outputs[\"target_q_continue\"] = torch.sigmoid(\n torch.where(\n is_last_step,\n next_q_halt_logits,\n torch.maximum(next_q_halt_logits, next_q_continue_logits),\n )\n )\n\n return Model_ACTV2Carry(\n new_inner_carry, new_steps, halted, new_current_data\n ), outputs","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.Model_ACTV2InnerCarry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.transformers_baseline.Model_ACTV2InnerCarry#L31-L32","kind":"class","name":"Model_ACTV2InnerCarry","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":31,"end_line":32,"context_start_line":11,"context_end_line":52,"code":"Architecture: Single-level transformer that processes the full 30x30 grid as a\n900-token sequence, with the same positional encodings and sparse embeddings as V1.\n\n\"\"\"\n\nfrom typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\n\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\n\n@dataclass\nclass Model_ACTV2InnerCarry:\n z_H: torch.Tensor\n\n\n@dataclass\nclass Model_ACTV2Carry:\n inner_carry: Model_ACTV2InnerCarry\n\n steps: torch.Tensor\n halted: torch.Tensor\n\n current_data: Dict[str, torch.Tensor]\n\n\nclass Model_ACTV2Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.Model_ACTV2Carry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.transformers_baseline.Model_ACTV2Carry#L36-L42","kind":"class","name":"Model_ACTV2Carry","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":36,"end_line":42,"context_start_line":16,"context_end_line":62,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\n\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\n\n@dataclass\nclass Model_ACTV2InnerCarry:\n z_H: torch.Tensor\n\n\n@dataclass\nclass Model_ACTV2Carry:\n inner_carry: Model_ACTV2InnerCarry\n\n steps: torch.Tensor\n halted: torch.Tensor\n\n current_data: Dict[str, torch.Tensor]\n\n\nclass Model_ACTV2Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n\n H_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.Model_ACTV2Config","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.transformers_baseline.Model_ACTV2Config#L45-L71","kind":"class","name":"Model_ACTV2Config","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":45,"end_line":71,"context_start_line":25,"context_end_line":91,"code":"from models.common import trunc_normal_init_\nfrom models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\n\n@dataclass\nclass Model_ACTV2InnerCarry:\n z_H: torch.Tensor\n\n\n@dataclass\nclass Model_ACTV2Carry:\n inner_carry: Model_ACTV2InnerCarry\n\n steps: torch.Tensor\n halted: torch.Tensor\n\n current_data: Dict[str, torch.Tensor]\n\n\nclass Model_ACTV2Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n\n H_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n\n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n act_enabled: bool = True # If False, always run halt_max_steps (no early stopping during training)\n act_inference: bool = False # If True, use adaptive computation during inference\n\n forward_dtype: str = \"bfloat16\"\n\n\nclass Model_ACTV2Block(nn.Module):\n def __init__(self, config: Model_ACTV2Config) -> None:\n super().__init__()\n\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False,\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.Model_ACTV2Block","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.transformers_baseline.Model_ACTV2Block#L74-L100","kind":"class","name":"Model_ACTV2Block","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":74,"end_line":100,"context_start_line":54,"context_end_line":120,"code":" H_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n\n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n act_enabled: bool = True # If False, always run halt_max_steps (no early stopping during training)\n act_inference: bool = False # If True, use adaptive computation during inference\n\n forward_dtype: str = \"bfloat16\"\n\n\nclass Model_ACTV2Block(nn.Module):\n def __init__(self, config: Model_ACTV2Config) -> None:\n super().__init__()\n\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False,\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # Post Norm\n # Self Attention\n hidden_states = rms_norm(\n hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states),\n variance_epsilon=self.norm_eps,\n )\n # Fully Connected\n hidden_states = rms_norm(hidden_states + self.mlp(hidden_states), variance_epsilon=self.norm_eps)\n return hidden_states\n\n\nclass Model_ACTV2ReasoningModule(nn.Module):\n def __init__(self, layers: List[Model_ACTV2Block]):\n super().__init__()\n\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n # Input injection (add)\n hidden_states = hidden_states + input_injection\n # Layers\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n\n return hidden_states\n\n\nclass Model_ACTV2_Inner(nn.Module):\n def __init__(self, config: Model_ACTV2Config) -> None:","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.Model_ACTV2ReasoningModule","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.transformers_baseline.Model_ACTV2ReasoningModule#L103-L116","kind":"class","name":"Model_ACTV2ReasoningModule","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":103,"end_line":116,"context_start_line":83,"context_end_line":136,"code":" causal=False,\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # Post Norm\n # Self Attention\n hidden_states = rms_norm(\n hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states),\n variance_epsilon=self.norm_eps,\n )\n # Fully Connected\n hidden_states = rms_norm(hidden_states + self.mlp(hidden_states), variance_epsilon=self.norm_eps)\n return hidden_states\n\n\nclass Model_ACTV2ReasoningModule(nn.Module):\n def __init__(self, layers: List[Model_ACTV2Block]):\n super().__init__()\n\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n # Input injection (add)\n hidden_states = hidden_states + input_injection\n # Layers\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n\n return hidden_states\n\n\nclass Model_ACTV2_Inner(nn.Module):\n def __init__(self, config: Model_ACTV2Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(\n self.config.vocab_size,\n self.config.hidden_size,\n init_std=embed_init_std,\n cast_to=self.forward_dtype,\n )\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.Model_ACTV2_Inner","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.transformers_baseline.Model_ACTV2_Inner#L119-L244","kind":"class","name":"Model_ACTV2_Inner","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":119,"end_line":244,"context_start_line":99,"context_end_line":264,"code":" hidden_states = rms_norm(hidden_states + self.mlp(hidden_states), variance_epsilon=self.norm_eps)\n return hidden_states\n\n\nclass Model_ACTV2ReasoningModule(nn.Module):\n def __init__(self, layers: List[Model_ACTV2Block]):\n super().__init__()\n\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor:\n # Input injection (add)\n hidden_states = hidden_states + input_injection\n # Layers\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n\n return hidden_states\n\n\nclass Model_ACTV2_Inner(nn.Module):\n def __init__(self, config: Model_ACTV2Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(\n self.config.vocab_size,\n self.config.hidden_size,\n init_std=embed_init_std,\n cast_to=self.forward_dtype,\n )\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(\n self.config.num_puzzle_identifiers,\n self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size,\n init_std=0,\n cast_to=self.forward_dtype,\n )\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(\n dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta,\n )\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(\n self.config.seq_len + self.puzzle_emb_len,\n self.config.hidden_size,\n init_std=embed_init_std,\n cast_to=self.forward_dtype,\n )\n else:\n raise NotImplementedError()\n\n # Reasoning Layers\n self.H_level = Model_ACTV2ReasoningModule(\n layers=[Model_ACTV2Block(self.config) for _i in range(self.config.H_layers)]\n )\n\n # Initial states\n self.H_init = nn.Buffer(\n trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1),\n persistent=True,\n )\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n\n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat(\n (puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2\n )\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return Model_ACTV2InnerCarry(\n z_H=torch.empty(\n batch_size,\n self.config.seq_len + self.puzzle_emb_len,\n self.config.hidden_size,\n dtype=self.forward_dtype,\n ),\n )\n\n def reset_carry(self, reset_flag: torch.Tensor, carry: Model_ACTV2InnerCarry):\n return Model_ACTV2InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n )\n\n def forward(\n self, carry: Model_ACTV2InnerCarry, batch: Dict[str, torch.Tensor]\n ) -> Tuple[Model_ACTV2InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # 1-step grad\n z_H = self.H_level(carry.z_H, input_embeddings, **seq_info)\n\n # LM Outputs\n new_carry = Model_ACTV2InnerCarry(\n z_H=z_H.detach(),\n ) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len :]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass Model_ACTV2(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = Model_ACTV2Config(**config_dict)\n self.inner = Model_ACTV2_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return Model_ACTV2Carry(\n inner_carry=self.inner.empty_carry(\n batch_size","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.Model_ACTV2","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.transformers_baseline.Model_ACTV2#L247-L342","kind":"class","name":"Model_ACTV2","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":247,"end_line":342,"context_start_line":227,"context_end_line":342,"code":" )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # 1-step grad\n z_H = self.H_level(carry.z_H, input_embeddings, **seq_info)\n\n # LM Outputs\n new_carry = Model_ACTV2InnerCarry(\n z_H=z_H.detach(),\n ) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len :]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass Model_ACTV2(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = Model_ACTV2Config(**config_dict)\n self.inner = Model_ACTV2_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return Model_ACTV2Carry(\n inner_carry=self.inner.empty_carry(\n batch_size\n ), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n steps=torch.zeros((batch_size,), dtype=torch.int32),\n halted=torch.ones((batch_size,), dtype=torch.bool), # Default to halted\n current_data={k: torch.empty_like(v) for k, v in batch.items()},\n )\n\n def forward(\n self,\n carry: Model_ACTV2Carry,\n batch: Dict[str, torch.Tensor],\n compute_target_q: bool = False,\n ) -> Tuple[Model_ACTV2Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n\n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {\n k: torch.where(carry.halted.view((-1,) + (1,) * (batch[k].ndim - 1)), batch[k], v)\n for k, v in carry.current_data.items()\n }\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(\n new_inner_carry, new_current_data\n )\n\n outputs = {\"logits\": logits, \"q_halt_logits\": q_halt_logits, \"q_continue_logits\": q_continue_logits}\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n\n halted = is_last_step\n\n # Check if adaptive computation should be used\n use_adaptive = (self.config.halt_max_steps > 1) and (\n (self.training and self.config.act_enabled)\n or (not self.training and self.config.act_inference)\n )\n\n if use_adaptive:\n # Halt signal based on Q-values (but always halt at max steps)\n q_halt_signal = q_halt_logits > q_continue_logits\n halted = halted | q_halt_signal\n\n # Store actual steps used for logging (only during inference)\n if not self.training:\n outputs[\"actual_steps\"] = new_steps.float()\n\n # Exploration (only during training)\n if self.training:\n min_halt_steps = (\n torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob\n ) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n # Compute target Q (only during training)\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n if self.training and compute_target_q:\n next_q_halt_logits, next_q_continue_logits = self.inner(\n new_inner_carry, new_current_data\n )[-1]\n\n outputs[\"target_q_continue\"] = torch.sigmoid(\n torch.where(\n is_last_step,\n next_q_halt_logits,\n torch.maximum(next_q_halt_logits, next_q_continue_logits),\n )\n )\n\n return Model_ACTV2Carry(\n new_inner_carry, new_steps, halted, new_current_data\n ), outputs","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.__init__","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.transformers_baseline.__init__#L250-L253","kind":"function","name":"__init__","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":250,"end_line":253,"context_start_line":230,"context_end_line":273,"code":" input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # 1-step grad\n z_H = self.H_level(carry.z_H, input_embeddings, **seq_info)\n\n # LM Outputs\n new_carry = Model_ACTV2InnerCarry(\n z_H=z_H.detach(),\n ) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len :]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass Model_ACTV2(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = Model_ACTV2Config(**config_dict)\n self.inner = Model_ACTV2_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return Model_ACTV2Carry(\n inner_carry=self.inner.empty_carry(\n batch_size\n ), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n steps=torch.zeros((batch_size,), dtype=torch.int32),\n halted=torch.ones((batch_size,), dtype=torch.bool), # Default to halted\n current_data={k: torch.empty_like(v) for k, v in batch.items()},\n )\n\n def forward(\n self,\n carry: Model_ACTV2Carry,","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.forward","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.transformers_baseline.forward#L271-L342","kind":"function","name":"forward","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":271,"end_line":342,"context_start_line":251,"context_end_line":342,"code":" super().__init__()\n self.config = Model_ACTV2Config(**config_dict)\n self.inner = Model_ACTV2_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return Model_ACTV2Carry(\n inner_carry=self.inner.empty_carry(\n batch_size\n ), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n steps=torch.zeros((batch_size,), dtype=torch.int32),\n halted=torch.ones((batch_size,), dtype=torch.bool), # Default to halted\n current_data={k: torch.empty_like(v) for k, v in batch.items()},\n )\n\n def forward(\n self,\n carry: Model_ACTV2Carry,\n batch: Dict[str, torch.Tensor],\n compute_target_q: bool = False,\n ) -> Tuple[Model_ACTV2Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n\n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {\n k: torch.where(carry.halted.view((-1,) + (1,) * (batch[k].ndim - 1)), batch[k], v)\n for k, v in carry.current_data.items()\n }\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(\n new_inner_carry, new_current_data\n )\n\n outputs = {\"logits\": logits, \"q_halt_logits\": q_halt_logits, \"q_continue_logits\": q_continue_logits}\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n\n halted = is_last_step\n\n # Check if adaptive computation should be used\n use_adaptive = (self.config.halt_max_steps > 1) and (\n (self.training and self.config.act_enabled)\n or (not self.training and self.config.act_inference)\n )\n\n if use_adaptive:\n # Halt signal based on Q-values (but always halt at max steps)\n q_halt_signal = q_halt_logits > q_continue_logits\n halted = halted | q_halt_signal\n\n # Store actual steps used for logging (only during inference)\n if not self.training:\n outputs[\"actual_steps\"] = new_steps.float()\n\n # Exploration (only during training)\n if self.training:\n min_halt_steps = (\n torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob\n ) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n # Compute target Q (only during training)\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n if self.training and compute_target_q:\n next_q_halt_logits, next_q_continue_logits = self.inner(\n new_inner_carry, new_current_data\n )[-1]\n\n outputs[\"target_q_continue\"] = torch.sigmoid(\n torch.where(\n is_last_step,\n next_q_halt_logits,\n torch.maximum(next_q_halt_logits, next_q_continue_logits),\n )\n )\n\n return Model_ACTV2Carry(\n new_inner_carry, new_steps, halted, new_current_data\n ), outputs","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline._input_embeddings","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.transformers_baseline._input_embeddings#L183-L205","kind":"function","name":"_input_embeddings","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":183,"end_line":205,"context_start_line":163,"context_end_line":225,"code":" else:\n raise NotImplementedError()\n\n # Reasoning Layers\n self.H_level = Model_ACTV2ReasoningModule(\n layers=[Model_ACTV2Block(self.config) for _i in range(self.config.H_layers)]\n )\n\n # Initial states\n self.H_init = nn.Buffer(\n trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1),\n persistent=True,\n )\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n\n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat(\n (puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2\n )\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return Model_ACTV2InnerCarry(\n z_H=torch.empty(\n batch_size,\n self.config.seq_len + self.puzzle_emb_len,\n self.config.hidden_size,\n dtype=self.forward_dtype,\n ),\n )\n\n def reset_carry(self, reset_flag: torch.Tensor, carry: Model_ACTV2InnerCarry):\n return Model_ACTV2InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n )\n\n def forward(\n self, carry: Model_ACTV2InnerCarry, batch: Dict[str, torch.Tensor]\n ) -> Tuple[Model_ACTV2InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.empty_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.transformers_baseline.empty_carry#L207-L215","kind":"function","name":"empty_carry","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":207,"end_line":215,"context_start_line":187,"context_end_line":235,"code":" # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n\n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat(\n (puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2\n )\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return Model_ACTV2InnerCarry(\n z_H=torch.empty(\n batch_size,\n self.config.seq_len + self.puzzle_emb_len,\n self.config.hidden_size,\n dtype=self.forward_dtype,\n ),\n )\n\n def reset_carry(self, reset_flag: torch.Tensor, carry: Model_ACTV2InnerCarry):\n return Model_ACTV2InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n )\n\n def forward(\n self, carry: Model_ACTV2InnerCarry, batch: Dict[str, torch.Tensor]\n ) -> Tuple[Model_ACTV2InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # 1-step grad\n z_H = self.H_level(carry.z_H, input_embeddings, **seq_info)\n\n # LM Outputs","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.reset_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.transformers_baseline.reset_carry#L217-L220","kind":"function","name":"reset_carry","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":217,"end_line":220,"context_start_line":197,"context_end_line":240,"code":" )\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return Model_ACTV2InnerCarry(\n z_H=torch.empty(\n batch_size,\n self.config.seq_len + self.puzzle_emb_len,\n self.config.hidden_size,\n dtype=self.forward_dtype,\n ),\n )\n\n def reset_carry(self, reset_flag: torch.Tensor, carry: Model_ACTV2InnerCarry):\n return Model_ACTV2InnerCarry(\n z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H),\n )\n\n def forward(\n self, carry: Model_ACTV2InnerCarry, batch: Dict[str, torch.Tensor]\n ) -> Tuple[Model_ACTV2InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # 1-step grad\n z_H = self.H_level(carry.z_H, input_embeddings, **seq_info)\n\n # LM Outputs\n new_carry = Model_ACTV2InnerCarry(\n z_H=z_H.detach(),\n ) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len :]\n","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.puzzle_emb","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.transformers_baseline.puzzle_emb#L256-L257","kind":"function","name":"puzzle_emb","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":256,"end_line":257,"context_start_line":236,"context_end_line":277,"code":" new_carry = Model_ACTV2InnerCarry(\n z_H=z_H.detach(),\n ) # New carry no grad\n output = self.lm_head(z_H)[:, self.puzzle_emb_len :]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass Model_ACTV2(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = Model_ACTV2Config(**config_dict)\n self.inner = Model_ACTV2_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return Model_ACTV2Carry(\n inner_carry=self.inner.empty_carry(\n batch_size\n ), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n steps=torch.zeros((batch_size,), dtype=torch.int32),\n halted=torch.ones((batch_size,), dtype=torch.bool), # Default to halted\n current_data={k: torch.empty_like(v) for k, v in batch.items()},\n )\n\n def forward(\n self,\n carry: Model_ACTV2Carry,\n batch: Dict[str, torch.Tensor],\n compute_target_q: bool = False,\n ) -> Tuple[Model_ACTV2Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.transformers_baseline.initial_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.transformers_baseline.initial_carry#L259-L269","kind":"function","name":"initial_carry","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":259,"end_line":269,"context_start_line":239,"context_end_line":289,"code":" output = self.lm_head(z_H)[:, self.puzzle_emb_len :]\n\n # Q head\n q_logits = self.q_head(z_H[:, 0]).to(torch.float32)\n\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass Model_ACTV2(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = Model_ACTV2Config(**config_dict)\n self.inner = Model_ACTV2_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return Model_ACTV2Carry(\n inner_carry=self.inner.empty_carry(\n batch_size\n ), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n steps=torch.zeros((batch_size,), dtype=torch.int32),\n halted=torch.ones((batch_size,), dtype=torch.bool), # Default to halted\n current_data={k: torch.empty_like(v) for k, v in batch.items()},\n )\n\n def forward(\n self,\n carry: Model_ACTV2Carry,\n batch: Dict[str, torch.Tensor],\n compute_target_q: bool = False,\n ) -> Tuple[Model_ACTV2Carry, Dict[str, torch.Tensor]]:\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n\n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {\n k: torch.where(carry.halted.view((-1,) + (1,) * (batch[k].ndim - 1)), batch[k], v)\n for k, v in carry.current_data.items()\n }\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(\n new_inner_carry, new_current_data","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez","uri":"program://TinyRecursiveModels/module/models.recursive_reasoning.trm_singlez#L1-L294","kind":"module","name":"models.recursive_reasoning.trm_singlez","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":1,"end_line":294,"context_start_line":1,"context_end_line":294,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_L: torch.Tensor\n\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int # ignored\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool = False # use mlp on L instead of transformer\n puzzle_emb_len: int = 16 # if non-zero, its specified to this value\n no_ACT_continue: bool = True # No continue ACT loss, only use the sigmoid of the halt which makes much more sense\n\nclass TinyRecursiveReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, **kwargs) -> torch.Tensor:\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype)\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.L_level = TinyRecursiveReasoningModel_ACTV1ReasoningModule(layers=[TinyRecursiveReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_L = carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n z_out = z_L\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_out)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_out[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n \n if self.config.no_ACT_continue:\n halted = halted | (q_halt_logits > 0)\n else:\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n if not self.config.no_ACT_continue:\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n _, _, (next_q_halt_logits, next_q_continue_logits), _, _ = self.inner(new_inner_carry, new_current_data)\n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return TinyRecursiveReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1InnerCarry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1InnerCarry#L17-L18","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1InnerCarry","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":17,"end_line":18,"context_start_line":1,"context_end_line":38,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_L: torch.Tensor\n\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1Carry","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1Carry#L23-L29","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1Carry","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":23,"end_line":29,"context_start_line":3,"context_end_line":49,"code":"import math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_L: torch.Tensor\n\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int # ignored\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1Config","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1Config#L32-L63","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1Config","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":32,"end_line":63,"context_start_line":12,"context_end_line":83,"code":"from models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_L: torch.Tensor\n\n\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1Carry:\n inner_carry: TinyRecursiveReasoningModel_ACTV1InnerCarry\n \n steps: torch.Tensor\n halted: torch.Tensor\n \n current_data: Dict[str, torch.Tensor]\n\n\nclass TinyRecursiveReasoningModel_ACTV1Config(BaseModel):\n batch_size: int\n seq_len: int\n puzzle_emb_ndim: int = 0\n num_puzzle_identifiers: int\n vocab_size: int\n\n H_cycles: int\n L_cycles: int\n\n H_layers: int # ignored\n L_layers: int\n\n # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool = False # use mlp on L instead of transformer\n puzzle_emb_len: int = 16 # if non-zero, its specified to this value\n no_ACT_continue: bool = True # No continue ACT loss, only use the sigmoid of the halt which makes much more sense\n\nclass TinyRecursiveReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1Block","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1Block#L65-L104","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1Block","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":65,"end_line":104,"context_start_line":45,"context_end_line":124,"code":" # Transformer config\n hidden_size: int\n expansion: float\n num_heads: int\n pos_encodings: str\n\n rms_norm_eps: float = 1e-5\n rope_theta: float = 10000.0\n \n # Halting Q-learning config\n halt_max_steps: int\n halt_exploration_prob: float\n\n forward_dtype: str = \"bfloat16\"\n\n # Alexia: added\n mlp_t: bool = False # use mlp on L instead of transformer\n puzzle_emb_len: int = 16 # if non-zero, its specified to this value\n no_ACT_continue: bool = True # No continue ACT loss, only use the sigmoid of the halt which makes much more sense\n\nclass TinyRecursiveReasoningModel_ACTV1Block(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n\n self.config = config\n if self.config.mlp_t:\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len\n self.mlp_t = SwiGLU(\n hidden_size=self.config.seq_len + self.puzzle_emb_len, # L\n expansion=config.expansion,\n )\n else:\n self.self_attn = Attention(\n hidden_size=config.hidden_size,\n head_dim=config.hidden_size // config.num_heads,\n num_heads=config.num_heads,\n num_key_value_heads=config.num_heads,\n causal=False\n )\n self.mlp = SwiGLU(\n hidden_size=config.hidden_size,\n expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, **kwargs) -> torch.Tensor:\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1ReasoningModule","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1ReasoningModule#L106-L114","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1ReasoningModule","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":106,"end_line":114,"context_start_line":86,"context_end_line":134,"code":" expansion=config.expansion,\n )\n self.norm_eps = config.rms_norm_eps\n\n def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor:\n # B, L, D = hidden_states.shape\n # Post Norm\n if self.config.mlp_t:\n hidden_states = hidden_states.transpose(1,2)\n out = self.mlp_t(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, **kwargs) -> torch.Tensor:\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1_Inner","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1_Inner#L117-L219","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1_Inner","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":117,"end_line":219,"context_start_line":97,"context_end_line":239,"code":" hidden_states = hidden_states.transpose(1,2)\n else:\n # Self Attention\n hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps)\n # Fully Connected\n out = self.mlp(hidden_states)\n hidden_states = rms_norm(hidden_states + out, variance_epsilon=self.norm_eps)\n return hidden_states\n\nclass TinyRecursiveReasoningModel_ACTV1ReasoningModule(nn.Module):\n def __init__(self, layers: List[TinyRecursiveReasoningModel_ACTV1Block]):\n super().__init__()\n self.layers = torch.nn.ModuleList(layers)\n\n def forward(self, hidden_states: torch.Tensor, **kwargs) -> torch.Tensor:\n for layer in self.layers:\n hidden_states = layer(hidden_states=hidden_states, **kwargs)\n return hidden_states\n\n\nclass TinyRecursiveReasoningModel_ACTV1_Inner(nn.Module):\n def __init__(self, config: TinyRecursiveReasoningModel_ACTV1Config) -> None:\n super().__init__()\n self.config = config\n self.forward_dtype = getattr(torch, self.config.forward_dtype)\n\n # I/O\n\n self.embed_scale = math.sqrt(self.config.hidden_size)\n embed_init_std = 1.0 / self.embed_scale\n\n self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)\n self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True)\n\n self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) if self.config.puzzle_emb_len == 0 else self.config.puzzle_emb_len # ceil div\n if self.config.puzzle_emb_ndim > 0:\n # Zero init puzzle embeddings\n self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,\n batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype)\n\n # LM Blocks\n if self.config.pos_encodings == \"rope\":\n self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.L_level = TinyRecursiveReasoningModel_ACTV1ReasoningModule(layers=[TinyRecursiveReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_L = carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n z_out = z_L\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_out)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_out[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n ","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1","uri":"program://TinyRecursiveModels/class/models.recursive_reasoning.trm_singlez.TinyRecursiveReasoningModel_ACTV1#L222-L294","kind":"class","name":"TinyRecursiveReasoningModel_ACTV1","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":222,"end_line":294,"context_start_line":202,"context_end_line":294,"code":" z_L = carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n z_out = z_L\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_out)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_out[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n \n if self.config.no_ACT_continue:\n halted = halted | (q_halt_logits > 0)\n else:\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n if not self.config.no_ACT_continue:\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n _, _, (next_q_halt_logits, next_q_continue_logits), _, _ = self.inner(new_inner_carry, new_current_data)\n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return TinyRecursiveReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.__init__","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_singlez.__init__#L225-L228","kind":"function","name":"__init__","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":225,"end_line":228,"context_start_line":205,"context_end_line":248,"code":" for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n z_out = z_L\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_out)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_out[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.forward","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_singlez.forward#L246-L294","kind":"function","name":"forward","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":246,"end_line":294,"context_start_line":226,"context_end_line":294,"code":" super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():\n # Step\n new_steps = new_steps + 1\n is_last_step = new_steps >= self.config.halt_max_steps\n \n halted = is_last_step\n\n # if training, and ACT is enabled\n if self.training and (self.config.halt_max_steps > 1):\n\n # Halt signal\n # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes\n \n if self.config.no_ACT_continue:\n halted = halted | (q_halt_logits > 0)\n else:\n halted = halted | (q_halt_logits > q_continue_logits)\n\n # Exploration\n min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1)\n halted = halted & (new_steps >= min_halt_steps)\n\n if not self.config.no_ACT_continue:\n # Compute target Q\n # NOTE: No replay buffer and target networks for computing target Q-value.\n # As batch_size is large, there're many parallel envs.\n # Similar concept as PQN https://arxiv.org/abs/2407.04811\n _, _, (next_q_halt_logits, next_q_continue_logits), _, _ = self.inner(new_inner_carry, new_current_data)\n outputs[\"target_q_continue\"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits)))\n\n return TinyRecursiveReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez._input_embeddings","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_singlez._input_embeddings#L160-L180","kind":"function","name":"_input_embeddings","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":160,"end_line":180,"context_start_line":140,"context_end_line":200,"code":" self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,\n max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,\n base=self.config.rope_theta)\n elif self.config.pos_encodings == \"learned\":\n self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)\n else:\n pass\n\n # Reasoning Layers\n self.L_level = TinyRecursiveReasoningModel_ACTV1ReasoningModule(layers=[TinyRecursiveReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)])\n\n # Initial states\n self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True)\n\n # Q head special init\n # Init Q to (almost) zero for faster learning during bootstrapping\n with torch.no_grad():\n self.q_head.weight.zero_()\n self.q_head.bias.fill_(-5) # type: ignore\n\n def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):\n # Token embedding\n embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.empty_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_singlez.empty_carry#L182-L185","kind":"function","name":"empty_carry","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":182,"end_line":185,"context_start_line":162,"context_end_line":205,"code":" embedding = self.embed_tokens(input.to(torch.int32))\n\n # Puzzle embeddings\n if self.config.puzzle_emb_ndim > 0:\n puzzle_embedding = self.puzzle_emb(puzzle_identifiers)\n \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_L = carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.reset_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_singlez.reset_carry#L187-L190","kind":"function","name":"reset_carry","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":187,"end_line":190,"context_start_line":167,"context_end_line":210,"code":" \n pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]\n if pad_count > 0:\n puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))\n\n embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)\n\n # Position embeddings\n if self.config.pos_encodings == \"learned\":\n # scale by 1/sqrt(2) to maintain forward variance\n embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))\n\n # Scale\n return self.embed_scale * embedding\n\n def empty_carry(self, batch_size: int):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype),\n )\n \n def reset_carry(self, reset_flag: torch.Tensor, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry):\n return TinyRecursiveReasoningModel_ACTV1InnerCarry(\n z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L),\n )\n\n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n seq_info = dict(\n cos_sin=self.rotary_emb() if hasattr(self, \"rotary_emb\") else None,\n )\n\n # Input encoding\n input_embeddings = self._input_embeddings(batch[\"inputs\"], batch[\"puzzle_identifiers\"])\n\n # Forward iterations\n it = 0\n z_L = carry.z_L\n # H_cycles-1 without grad\n with torch.no_grad():\n for _H_step in range(self.config.H_cycles-1):\n for _L_step in range(self.config.L_cycles):\n z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n # 1 with grad\n for _L_step in range(self.config.L_cycles):","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.puzzle_emb","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_singlez.puzzle_emb#L231-L232","kind":"function","name":"puzzle_emb","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":231,"end_line":232,"context_start_line":211,"context_end_line":252,"code":" z_L = self.L_level(z_L + input_embeddings, **seq_info)\n z_L = self.L_level(z_L, **seq_info)\n z_out = z_L\n\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_out)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_out[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:models.recursive_reasoning.trm_singlez.initial_carry","uri":"program://TinyRecursiveModels/function/models.recursive_reasoning.trm_singlez.initial_carry#L234-L244","kind":"function","name":"initial_carry","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":234,"end_line":244,"context_start_line":214,"context_end_line":264,"code":"\n # LM Outputs\n new_carry = TinyRecursiveReasoningModel_ACTV1InnerCarry(z_L=z_L.detach()) # New carry no grad\n output = self.lm_head(z_out)[:, self.puzzle_emb_len:]\n q_logits = self.q_head(z_out[:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position\n return new_carry, output, (q_logits[..., 0], q_logits[..., 1])\n\n\nclass TinyRecursiveReasoningModel_ACTV1(nn.Module):\n \"\"\"ACT wrapper.\"\"\"\n\n def __init__(self, config_dict: dict):\n super().__init__()\n self.config = TinyRecursiveReasoningModel_ACTV1Config(**config_dict)\n self.inner = TinyRecursiveReasoningModel_ACTV1_Inner(self.config)\n\n @property\n def puzzle_emb(self):\n return self.inner.puzzle_emb\n\n def initial_carry(self, batch: Dict[str, torch.Tensor]):\n batch_size = batch[\"inputs\"].shape[0]\n\n return TinyRecursiveReasoningModel_ACTV1Carry(\n inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted.\n \n steps=torch.zeros((batch_size, ), dtype=torch.int32),\n halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted\n \n current_data={k: torch.empty_like(v) for k, v in batch.items()}\n )\n \n def forward(self, carry: TinyRecursiveReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[TinyRecursiveReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]:\n\n # Update data, carry (removing halted sequences)\n new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry)\n \n new_steps = torch.where(carry.halted, 0, carry.steps)\n\n new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()}\n\n # Forward inner model\n new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data)\n\n outputs = {\n \"logits\": logits,\n \"q_halt_logits\": q_halt_logits,\n \"q_continue_logits\": q_continue_logits\n }\n\n with torch.no_grad():","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:utils.functions","uri":"program://TinyRecursiveModels/module/utils.functions#L1-L19","kind":"module","name":"utils.functions","path":"utils/functions.py","language":"python","start_line":1,"end_line":19,"context_start_line":1,"context_end_line":19,"code":"import importlib\nimport inspect\n\n\ndef load_model_class(identifier: str, prefix: str = \"models.\"):\n module_path, class_name = identifier.split('@')\n\n # Import the module\n module = importlib.import_module(prefix + module_path)\n cls = getattr(module, class_name)\n \n return cls\n\n\ndef get_model_source_path(identifier: str, prefix: str = \"models.\"):\n module_path, class_name = identifier.split('@')\n\n module = importlib.import_module(prefix + module_path)\n return inspect.getsourcefile(module)","source_hash":"a7c54723be9ade0317afd1fe42d42da5e7a33e1b5cffbf9bdfc66f3791a3caef","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:utils.functions.load_model_class","uri":"program://TinyRecursiveModels/function/utils.functions.load_model_class#L5-L12","kind":"function","name":"load_model_class","path":"utils/functions.py","language":"python","start_line":5,"end_line":12,"context_start_line":1,"context_end_line":19,"code":"import importlib\nimport inspect\n\n\ndef load_model_class(identifier: str, prefix: str = \"models.\"):\n module_path, class_name = identifier.split('@')\n\n # Import the module\n module = importlib.import_module(prefix + module_path)\n cls = getattr(module, class_name)\n \n return cls\n\n\ndef get_model_source_path(identifier: str, prefix: str = \"models.\"):\n module_path, class_name = identifier.split('@')\n\n module = importlib.import_module(prefix + module_path)\n return inspect.getsourcefile(module)","source_hash":"a7c54723be9ade0317afd1fe42d42da5e7a33e1b5cffbf9bdfc66f3791a3caef","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:utils.functions.get_model_source_path","uri":"program://TinyRecursiveModels/function/utils.functions.get_model_source_path#L15-L19","kind":"function","name":"get_model_source_path","path":"utils/functions.py","language":"python","start_line":15,"end_line":19,"context_start_line":1,"context_end_line":19,"code":"import importlib\nimport inspect\n\n\ndef load_model_class(identifier: str, prefix: str = \"models.\"):\n module_path, class_name = identifier.split('@')\n\n # Import the module\n module = importlib.import_module(prefix + module_path)\n cls = getattr(module, class_name)\n \n return cls\n\n\ndef get_model_source_path(identifier: str, prefix: str = \"models.\"):\n module_path, class_name = identifier.split('@')\n\n module = importlib.import_module(prefix + module_path)\n return inspect.getsourcefile(module)","source_hash":"a7c54723be9ade0317afd1fe42d42da5e7a33e1b5cffbf9bdfc66f3791a3caef","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.common","uri":"program://TinyRecursiveModels/module/dataset.common#L1-L49","kind":"module","name":"dataset.common","path":"dataset/common.py","language":"python","start_line":1,"end_line":49,"context_start_line":1,"context_end_line":49,"code":"from typing import List, Optional\n\nimport pydantic\nimport numpy as np\n\n\n# Global list mapping each dihedral transform id to its inverse.\n# Index corresponds to the original tid, and the value is its inverse.\nDIHEDRAL_INVERSE = [0, 3, 2, 1, 4, 5, 6, 7]\n\n\nclass PuzzleDatasetMetadata(pydantic.BaseModel):\n pad_id: int\n ignore_label_id: Optional[int]\n blank_identifier_id: int\n vocab_size: int\n seq_len: int\n num_puzzle_identifiers: int\n total_groups: int\n mean_puzzle_examples: float\n total_puzzles: int\n sets: List[str]\n\n\ndef dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray:\n \"\"\"8 dihedral symmetries by rotate, flip and mirror\"\"\"\n \n if tid == 0:\n return arr # identity\n elif tid == 1:\n return np.rot90(arr, k=1)\n elif tid == 2:\n return np.rot90(arr, k=2)\n elif tid == 3:\n return np.rot90(arr, k=3)\n elif tid == 4:\n return np.fliplr(arr) # horizontal flip\n elif tid == 5:\n return np.flipud(arr) # vertical flip\n elif tid == 6:\n return arr.T # transpose (reflection along main diagonal)\n elif tid == 7:\n return np.fliplr(np.rot90(arr, k=1)) # anti-diagonal reflection\n else:\n return arr\n \n \ndef inverse_dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray:\n return dihedral_transform(arr, DIHEDRAL_INVERSE[tid])","source_hash":"be9d442d6a72a9351fda551ac1aeb05328512417faf6e8b7ed481915470f24d6","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.common.PuzzleDatasetMetadata","uri":"program://TinyRecursiveModels/class/dataset.common.PuzzleDatasetMetadata#L12-L22","kind":"class","name":"PuzzleDatasetMetadata","path":"dataset/common.py","language":"python","start_line":12,"end_line":22,"context_start_line":1,"context_end_line":42,"code":"from typing import List, Optional\n\nimport pydantic\nimport numpy as np\n\n\n# Global list mapping each dihedral transform id to its inverse.\n# Index corresponds to the original tid, and the value is its inverse.\nDIHEDRAL_INVERSE = [0, 3, 2, 1, 4, 5, 6, 7]\n\n\nclass PuzzleDatasetMetadata(pydantic.BaseModel):\n pad_id: int\n ignore_label_id: Optional[int]\n blank_identifier_id: int\n vocab_size: int\n seq_len: int\n num_puzzle_identifiers: int\n total_groups: int\n mean_puzzle_examples: float\n total_puzzles: int\n sets: List[str]\n\n\ndef dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray:\n \"\"\"8 dihedral symmetries by rotate, flip and mirror\"\"\"\n \n if tid == 0:\n return arr # identity\n elif tid == 1:\n return np.rot90(arr, k=1)\n elif tid == 2:\n return np.rot90(arr, k=2)\n elif tid == 3:\n return np.rot90(arr, k=3)\n elif tid == 4:\n return np.fliplr(arr) # horizontal flip\n elif tid == 5:\n return np.flipud(arr) # vertical flip\n elif tid == 6:\n return arr.T # transpose (reflection along main diagonal)\n elif tid == 7:","source_hash":"be9d442d6a72a9351fda551ac1aeb05328512417faf6e8b7ed481915470f24d6","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.common.dihedral_transform","uri":"program://TinyRecursiveModels/function/dataset.common.dihedral_transform#L25-L45","kind":"function","name":"dihedral_transform","path":"dataset/common.py","language":"python","start_line":25,"end_line":45,"context_start_line":5,"context_end_line":49,"code":"\n\n# Global list mapping each dihedral transform id to its inverse.\n# Index corresponds to the original tid, and the value is its inverse.\nDIHEDRAL_INVERSE = [0, 3, 2, 1, 4, 5, 6, 7]\n\n\nclass PuzzleDatasetMetadata(pydantic.BaseModel):\n pad_id: int\n ignore_label_id: Optional[int]\n blank_identifier_id: int\n vocab_size: int\n seq_len: int\n num_puzzle_identifiers: int\n total_groups: int\n mean_puzzle_examples: float\n total_puzzles: int\n sets: List[str]\n\n\ndef dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray:\n \"\"\"8 dihedral symmetries by rotate, flip and mirror\"\"\"\n \n if tid == 0:\n return arr # identity\n elif tid == 1:\n return np.rot90(arr, k=1)\n elif tid == 2:\n return np.rot90(arr, k=2)\n elif tid == 3:\n return np.rot90(arr, k=3)\n elif tid == 4:\n return np.fliplr(arr) # horizontal flip\n elif tid == 5:\n return np.flipud(arr) # vertical flip\n elif tid == 6:\n return arr.T # transpose (reflection along main diagonal)\n elif tid == 7:\n return np.fliplr(np.rot90(arr, k=1)) # anti-diagonal reflection\n else:\n return arr\n \n \ndef inverse_dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray:\n return dihedral_transform(arr, DIHEDRAL_INVERSE[tid])","source_hash":"be9d442d6a72a9351fda551ac1aeb05328512417faf6e8b7ed481915470f24d6","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.common.inverse_dihedral_transform","uri":"program://TinyRecursiveModels/function/dataset.common.inverse_dihedral_transform#L48-L49","kind":"function","name":"inverse_dihedral_transform","path":"dataset/common.py","language":"python","start_line":48,"end_line":49,"context_start_line":28,"context_end_line":49,"code":" if tid == 0:\n return arr # identity\n elif tid == 1:\n return np.rot90(arr, k=1)\n elif tid == 2:\n return np.rot90(arr, k=2)\n elif tid == 3:\n return np.rot90(arr, k=3)\n elif tid == 4:\n return np.fliplr(arr) # horizontal flip\n elif tid == 5:\n return np.flipud(arr) # vertical flip\n elif tid == 6:\n return arr.T # transpose (reflection along main diagonal)\n elif tid == 7:\n return np.fliplr(np.rot90(arr, k=1)) # anti-diagonal reflection\n else:\n return arr\n \n \ndef inverse_dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray:\n return dihedral_transform(arr, DIHEDRAL_INVERSE[tid])","source_hash":"be9d442d6a72a9351fda551ac1aeb05328512417faf6e8b7ed481915470f24d6","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_maze_dataset","uri":"program://TinyRecursiveModels/module/dataset.build_maze_dataset#L1-L140","kind":"module","name":"dataset.build_maze_dataset","path":"dataset/build_maze_dataset.py","language":"python","start_line":1,"end_line":140,"context_start_line":1,"context_end_line":140,"code":"from typing import Optional\nimport math\nimport os\nimport csv\nimport json\nimport numpy as np\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\nfrom tqdm import tqdm\nfrom huggingface_hub import hf_hub_download\n\nfrom common import PuzzleDatasetMetadata, dihedral_transform\n\n\nCHARSET = \"# SGo\"\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n source_repo: str = \"sapientinc/maze-30x30-hard-1k\"\n output_dir: str = \"data/maze-30x30-hard-1k\"\n\n subsample_size: Optional[int] = None\n aug: bool = False\n\n\ndef convert_subset(set_name: str, config: DataProcessConfig):\n # Read CSV\n all_chars = set()\n grid_size = None\n inputs = []\n labels = []\n \n with open(hf_hub_download(config.source_repo, f\"{set_name}.csv\", repo_type=\"dataset\"), newline=\"\") as csvfile: # type: ignore\n reader = csv.reader(csvfile)\n next(reader) # Skip header\n for source, q, a, rating in reader:\n all_chars.update(q)\n all_chars.update(a)\n\n if grid_size is None:\n n = int(len(q) ** 0.5)\n grid_size = (n, n)\n \n inputs.append(np.frombuffer(q.encode(), dtype=np.uint8).reshape(grid_size))\n labels.append(np.frombuffer(a.encode(), dtype=np.uint8).reshape(grid_size))\n\n # If subsample_size is specified for the training set,\n # randomly sample the desired number of examples.\n if set_name == \"train\" and config.subsample_size is not None:\n total_samples = len(inputs)\n if config.subsample_size < total_samples:\n indices = np.random.choice(total_samples, size=config.subsample_size, replace=False)\n inputs = [inputs[i] for i in indices]\n labels = [labels[i] for i in indices]\n\n # Generate dataset\n results = {k: [] for k in [\"inputs\", \"labels\", \"puzzle_identifiers\", \"puzzle_indices\", \"group_indices\"]}\n puzzle_id = 0\n example_id = 0\n \n results[\"puzzle_indices\"].append(0)\n results[\"group_indices\"].append(0)\n \n for inp, out in zip(tqdm(inputs), labels):\n # Dihedral transformations for augmentation\n for aug_idx in range(8 if (set_name == \"train\" and config.aug) else 1):\n results[\"inputs\"].append(dihedral_transform(inp, aug_idx))\n results[\"labels\"].append(dihedral_transform(out, aug_idx))\n example_id += 1\n puzzle_id += 1\n \n results[\"puzzle_indices\"].append(example_id)\n results[\"puzzle_identifiers\"].append(0)\n \n # Push group\n results[\"group_indices\"].append(puzzle_id)\n \n # Char mappings\n assert len(all_chars - set(CHARSET)) == 0\n \n char2id = np.zeros(256, np.uint8)\n char2id[np.array(list(map(ord, CHARSET)))] = np.arange(len(CHARSET)) + 1\n\n # To Numpy\n def _seq_to_numpy(seq):\n arr = np.vstack([char2id[s.reshape(-1)] for s in seq])\n \n return arr\n \n results = {\n \"inputs\": _seq_to_numpy(results[\"inputs\"]),\n \"labels\": _seq_to_numpy(results[\"labels\"]),\n \n \"group_indices\": np.array(results[\"group_indices\"], dtype=np.int32),\n \"puzzle_indices\": np.array(results[\"puzzle_indices\"], dtype=np.int32),\n \"puzzle_identifiers\": np.array(results[\"puzzle_identifiers\"], dtype=np.int32),\n }\n\n # Metadata\n metadata = PuzzleDatasetMetadata(\n seq_len=int(math.prod(grid_size)), # type: ignore\n vocab_size=len(CHARSET) + 1, # PAD + Charset\n pad_id=0,\n ignore_label_id=0,\n blank_identifier_id=0,\n num_puzzle_identifiers=1,\n total_groups=len(results[\"group_indices\"]) - 1,\n mean_puzzle_examples=1,\n total_puzzles=len(results[\"group_indices\"]) - 1,\n sets=[\"all\"]\n )\n\n # Save metadata as JSON.\n save_dir = os.path.join(config.output_dir, set_name)\n os.makedirs(save_dir, exist_ok=True)\n \n with open(os.path.join(save_dir, \"dataset.json\"), \"w\") as f:\n json.dump(metadata.model_dump(), f)\n \n # Save data\n for k, v in results.items():\n np.save(os.path.join(save_dir, f\"all__{k}.npy\"), v)\n \n # Save IDs mapping (for visualization only)\n with open(os.path.join(config.output_dir, \"identifiers.json\"), \"w\") as f:\n json.dump([\"\"], f)\n\n\n@cli.command(singleton=True)\ndef preprocess_data(config: DataProcessConfig):\n convert_subset(\"train\", config)\n convert_subset(\"test\", config)\n\n\nif __name__ == \"__main__\":\n cli()","source_hash":"839f29bf5f9fa98f3620572691bc7b869d818b4d38907c4a7b3bdaec6931965b","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_maze_dataset.DataProcessConfig","uri":"program://TinyRecursiveModels/class/dataset.build_maze_dataset.DataProcessConfig#L22-L27","kind":"class","name":"DataProcessConfig","path":"dataset/build_maze_dataset.py","language":"python","start_line":22,"end_line":27,"context_start_line":2,"context_end_line":47,"code":"import math\nimport os\nimport csv\nimport json\nimport numpy as np\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\nfrom tqdm import tqdm\nfrom huggingface_hub import hf_hub_download\n\nfrom common import PuzzleDatasetMetadata, dihedral_transform\n\n\nCHARSET = \"# SGo\"\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n source_repo: str = \"sapientinc/maze-30x30-hard-1k\"\n output_dir: str = \"data/maze-30x30-hard-1k\"\n\n subsample_size: Optional[int] = None\n aug: bool = False\n\n\ndef convert_subset(set_name: str, config: DataProcessConfig):\n # Read CSV\n all_chars = set()\n grid_size = None\n inputs = []\n labels = []\n \n with open(hf_hub_download(config.source_repo, f\"{set_name}.csv\", repo_type=\"dataset\"), newline=\"\") as csvfile: # type: ignore\n reader = csv.reader(csvfile)\n next(reader) # Skip header\n for source, q, a, rating in reader:\n all_chars.update(q)\n all_chars.update(a)\n\n if grid_size is None:\n n = int(len(q) ** 0.5)\n grid_size = (n, n)\n ","source_hash":"839f29bf5f9fa98f3620572691bc7b869d818b4d38907c4a7b3bdaec6931965b","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_maze_dataset.convert_subset","uri":"program://TinyRecursiveModels/function/dataset.build_maze_dataset.convert_subset#L30-L130","kind":"function","name":"convert_subset","path":"dataset/build_maze_dataset.py","language":"python","start_line":30,"end_line":130,"context_start_line":10,"context_end_line":140,"code":"from tqdm import tqdm\nfrom huggingface_hub import hf_hub_download\n\nfrom common import PuzzleDatasetMetadata, dihedral_transform\n\n\nCHARSET = \"# SGo\"\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n source_repo: str = \"sapientinc/maze-30x30-hard-1k\"\n output_dir: str = \"data/maze-30x30-hard-1k\"\n\n subsample_size: Optional[int] = None\n aug: bool = False\n\n\ndef convert_subset(set_name: str, config: DataProcessConfig):\n # Read CSV\n all_chars = set()\n grid_size = None\n inputs = []\n labels = []\n \n with open(hf_hub_download(config.source_repo, f\"{set_name}.csv\", repo_type=\"dataset\"), newline=\"\") as csvfile: # type: ignore\n reader = csv.reader(csvfile)\n next(reader) # Skip header\n for source, q, a, rating in reader:\n all_chars.update(q)\n all_chars.update(a)\n\n if grid_size is None:\n n = int(len(q) ** 0.5)\n grid_size = (n, n)\n \n inputs.append(np.frombuffer(q.encode(), dtype=np.uint8).reshape(grid_size))\n labels.append(np.frombuffer(a.encode(), dtype=np.uint8).reshape(grid_size))\n\n # If subsample_size is specified for the training set,\n # randomly sample the desired number of examples.\n if set_name == \"train\" and config.subsample_size is not None:\n total_samples = len(inputs)\n if config.subsample_size < total_samples:\n indices = np.random.choice(total_samples, size=config.subsample_size, replace=False)\n inputs = [inputs[i] for i in indices]\n labels = [labels[i] for i in indices]\n\n # Generate dataset\n results = {k: [] for k in [\"inputs\", \"labels\", \"puzzle_identifiers\", \"puzzle_indices\", \"group_indices\"]}\n puzzle_id = 0\n example_id = 0\n \n results[\"puzzle_indices\"].append(0)\n results[\"group_indices\"].append(0)\n \n for inp, out in zip(tqdm(inputs), labels):\n # Dihedral transformations for augmentation\n for aug_idx in range(8 if (set_name == \"train\" and config.aug) else 1):\n results[\"inputs\"].append(dihedral_transform(inp, aug_idx))\n results[\"labels\"].append(dihedral_transform(out, aug_idx))\n example_id += 1\n puzzle_id += 1\n \n results[\"puzzle_indices\"].append(example_id)\n results[\"puzzle_identifiers\"].append(0)\n \n # Push group\n results[\"group_indices\"].append(puzzle_id)\n \n # Char mappings\n assert len(all_chars - set(CHARSET)) == 0\n \n char2id = np.zeros(256, np.uint8)\n char2id[np.array(list(map(ord, CHARSET)))] = np.arange(len(CHARSET)) + 1\n\n # To Numpy\n def _seq_to_numpy(seq):\n arr = np.vstack([char2id[s.reshape(-1)] for s in seq])\n \n return arr\n \n results = {\n \"inputs\": _seq_to_numpy(results[\"inputs\"]),\n \"labels\": _seq_to_numpy(results[\"labels\"]),\n \n \"group_indices\": np.array(results[\"group_indices\"], dtype=np.int32),\n \"puzzle_indices\": np.array(results[\"puzzle_indices\"], dtype=np.int32),\n \"puzzle_identifiers\": np.array(results[\"puzzle_identifiers\"], dtype=np.int32),\n }\n\n # Metadata\n metadata = PuzzleDatasetMetadata(\n seq_len=int(math.prod(grid_size)), # type: ignore\n vocab_size=len(CHARSET) + 1, # PAD + Charset\n pad_id=0,\n ignore_label_id=0,\n blank_identifier_id=0,\n num_puzzle_identifiers=1,\n total_groups=len(results[\"group_indices\"]) - 1,\n mean_puzzle_examples=1,\n total_puzzles=len(results[\"group_indices\"]) - 1,\n sets=[\"all\"]\n )\n\n # Save metadata as JSON.\n save_dir = os.path.join(config.output_dir, set_name)\n os.makedirs(save_dir, exist_ok=True)\n \n with open(os.path.join(save_dir, \"dataset.json\"), \"w\") as f:\n json.dump(metadata.model_dump(), f)\n \n # Save data\n for k, v in results.items():\n np.save(os.path.join(save_dir, f\"all__{k}.npy\"), v)\n \n # Save IDs mapping (for visualization only)\n with open(os.path.join(config.output_dir, \"identifiers.json\"), \"w\") as f:\n json.dump([\"\"], f)\n\n\n@cli.command(singleton=True)\ndef preprocess_data(config: DataProcessConfig):\n convert_subset(\"train\", config)\n convert_subset(\"test\", config)\n\n\nif __name__ == \"__main__\":\n cli()","source_hash":"839f29bf5f9fa98f3620572691bc7b869d818b4d38907c4a7b3bdaec6931965b","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_maze_dataset.preprocess_data","uri":"program://TinyRecursiveModels/function/dataset.build_maze_dataset.preprocess_data#L134-L136","kind":"function","name":"preprocess_data","path":"dataset/build_maze_dataset.py","language":"python","start_line":134,"end_line":136,"context_start_line":114,"context_end_line":140,"code":" sets=[\"all\"]\n )\n\n # Save metadata as JSON.\n save_dir = os.path.join(config.output_dir, set_name)\n os.makedirs(save_dir, exist_ok=True)\n \n with open(os.path.join(save_dir, \"dataset.json\"), \"w\") as f:\n json.dump(metadata.model_dump(), f)\n \n # Save data\n for k, v in results.items():\n np.save(os.path.join(save_dir, f\"all__{k}.npy\"), v)\n \n # Save IDs mapping (for visualization only)\n with open(os.path.join(config.output_dir, \"identifiers.json\"), \"w\") as f:\n json.dump([\"\"], f)\n\n\n@cli.command(singleton=True)\ndef preprocess_data(config: DataProcessConfig):\n convert_subset(\"train\", config)\n convert_subset(\"test\", config)\n\n\nif __name__ == \"__main__\":\n cli()","source_hash":"839f29bf5f9fa98f3620572691bc7b869d818b4d38907c4a7b3bdaec6931965b","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_maze_dataset._seq_to_numpy","uri":"program://TinyRecursiveModels/function/dataset.build_maze_dataset._seq_to_numpy#L89-L92","kind":"function","name":"_seq_to_numpy","path":"dataset/build_maze_dataset.py","language":"python","start_line":89,"end_line":92,"context_start_line":69,"context_end_line":112,"code":" # Dihedral transformations for augmentation\n for aug_idx in range(8 if (set_name == \"train\" and config.aug) else 1):\n results[\"inputs\"].append(dihedral_transform(inp, aug_idx))\n results[\"labels\"].append(dihedral_transform(out, aug_idx))\n example_id += 1\n puzzle_id += 1\n \n results[\"puzzle_indices\"].append(example_id)\n results[\"puzzle_identifiers\"].append(0)\n \n # Push group\n results[\"group_indices\"].append(puzzle_id)\n \n # Char mappings\n assert len(all_chars - set(CHARSET)) == 0\n \n char2id = np.zeros(256, np.uint8)\n char2id[np.array(list(map(ord, CHARSET)))] = np.arange(len(CHARSET)) + 1\n\n # To Numpy\n def _seq_to_numpy(seq):\n arr = np.vstack([char2id[s.reshape(-1)] for s in seq])\n \n return arr\n \n results = {\n \"inputs\": _seq_to_numpy(results[\"inputs\"]),\n \"labels\": _seq_to_numpy(results[\"labels\"]),\n \n \"group_indices\": np.array(results[\"group_indices\"], dtype=np.int32),\n \"puzzle_indices\": np.array(results[\"puzzle_indices\"], dtype=np.int32),\n \"puzzle_identifiers\": np.array(results[\"puzzle_identifiers\"], dtype=np.int32),\n }\n\n # Metadata\n metadata = PuzzleDatasetMetadata(\n seq_len=int(math.prod(grid_size)), # type: ignore\n vocab_size=len(CHARSET) + 1, # PAD + Charset\n pad_id=0,\n ignore_label_id=0,\n blank_identifier_id=0,\n num_puzzle_identifiers=1,\n total_groups=len(results[\"group_indices\"]) - 1,\n mean_puzzle_examples=1,","source_hash":"839f29bf5f9fa98f3620572691bc7b869d818b4d38907c4a7b3bdaec6931965b","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_sudoku_dataset","uri":"program://TinyRecursiveModels/module/dataset.build_sudoku_dataset#L1-L167","kind":"module","name":"dataset.build_sudoku_dataset","path":"dataset/build_sudoku_dataset.py","language":"python","start_line":1,"end_line":167,"context_start_line":1,"context_end_line":167,"code":"from typing import Optional\nimport os\nimport csv\nimport json\nimport numpy as np\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\nfrom tqdm import tqdm\nfrom huggingface_hub import hf_hub_download\n\nfrom common import PuzzleDatasetMetadata\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n source_repo: str = \"sapientinc/sudoku-extreme\"\n output_dir: str = \"data/sudoku-extreme-full\"\n\n subsample_size: Optional[int] = None\n min_difficulty: Optional[int] = None\n num_aug: int = 0\n\n\ndef shuffle_sudoku(board: np.ndarray, solution: np.ndarray):\n # Create a random digit mapping: a permutation of 1..9, with zero (blank) unchanged\n digit_map = np.pad(np.random.permutation(np.arange(1, 10)), (1, 0))\n \n # Randomly decide whether to transpose.\n transpose_flag = np.random.rand() < 0.5\n\n # Generate a valid row permutation:\n # - Shuffle the 3 bands (each band = 3 rows) and for each band, shuffle its 3 rows.\n bands = np.random.permutation(3)\n row_perm = np.concatenate([b * 3 + np.random.permutation(3) for b in bands])\n\n # Similarly for columns (stacks).\n stacks = np.random.permutation(3)\n col_perm = np.concatenate([s * 3 + np.random.permutation(3) for s in stacks])\n\n # Build an 81->81 mapping. For each new cell at (i, j)\n # (row index = i // 9, col index = i % 9),\n # its value comes from old row = row_perm[i//9] and old col = col_perm[i%9].\n mapping = np.array([row_perm[i // 9] * 9 + col_perm[i % 9] for i in range(81)])\n\n def apply_transformation(x: np.ndarray) -> np.ndarray:\n # Apply transpose flag\n if transpose_flag:\n x = x.T\n # Apply the position mapping.\n new_board = x.flatten()[mapping].reshape(9, 9).copy()\n # Apply digit mapping\n return digit_map[new_board]\n\n return apply_transformation(board), apply_transformation(solution)\n\n\ndef convert_subset(set_name: str, config: DataProcessConfig):\n # Read CSV\n inputs = []\n labels = []\n \n with open(hf_hub_download(config.source_repo, f\"{set_name}.csv\", repo_type=\"dataset\"), newline=\"\") as csvfile:\n reader = csv.reader(csvfile)\n next(reader) # Skip header\n for source, q, a, rating in reader:\n if (config.min_difficulty is None) or (int(rating) >= config.min_difficulty):\n assert len(q) == 81 and len(a) == 81\n \n inputs.append(np.frombuffer(q.replace('.', '0').encode(), dtype=np.uint8).reshape(9, 9) - ord('0'))\n labels.append(np.frombuffer(a.encode(), dtype=np.uint8).reshape(9, 9) - ord('0'))\n\n # If subsample_size is specified for the training set,\n # randomly sample the desired number of examples.\n if set_name == \"train\" and config.subsample_size is not None:\n total_samples = len(inputs)\n if config.subsample_size < total_samples:\n indices = np.random.choice(total_samples, size=config.subsample_size, replace=False)\n inputs = [inputs[i] for i in indices]\n labels = [labels[i] for i in indices]\n\n # Generate dataset\n num_augments = config.num_aug if set_name == \"train\" else 0\n\n results = {k: [] for k in [\"inputs\", \"labels\", \"puzzle_identifiers\", \"puzzle_indices\", \"group_indices\"]}\n puzzle_id = 0\n example_id = 0\n \n results[\"puzzle_indices\"].append(0)\n results[\"group_indices\"].append(0)\n \n for orig_inp, orig_out in zip(tqdm(inputs), labels):\n for aug_idx in range(1 + num_augments):\n # First index is not augmented\n if aug_idx == 0:\n inp, out = orig_inp, orig_out\n else:\n inp, out = shuffle_sudoku(orig_inp, orig_out)\n\n # Push puzzle (only single example)\n results[\"inputs\"].append(inp)\n results[\"labels\"].append(out)\n example_id += 1\n puzzle_id += 1\n \n results[\"puzzle_indices\"].append(example_id)\n results[\"puzzle_identifiers\"].append(0)\n \n # Push group\n results[\"group_indices\"].append(puzzle_id)\n \n # To Numpy\n def _seq_to_numpy(seq):\n arr = np.concatenate(seq).reshape(len(seq), -1)\n \n assert np.all((arr >= 0) & (arr <= 9))\n return arr + 1\n \n results = {\n \"inputs\": _seq_to_numpy(results[\"inputs\"]),\n \"labels\": _seq_to_numpy(results[\"labels\"]),\n \n \"group_indices\": np.array(results[\"group_indices\"], dtype=np.int32),\n \"puzzle_indices\": np.array(results[\"puzzle_indices\"], dtype=np.int32),\n \"puzzle_identifiers\": np.array(results[\"puzzle_identifiers\"], dtype=np.int32),\n }\n\n # Metadata\n metadata = PuzzleDatasetMetadata(\n seq_len=81,\n vocab_size=10 + 1, # PAD + \"0\" ... \"9\"\n pad_id=0,\n ignore_label_id=0,\n blank_identifier_id=0,\n num_puzzle_identifiers=1,\n total_groups=len(results[\"group_indices\"]) - 1,\n mean_puzzle_examples=1,\n total_puzzles=len(results[\"group_indices\"]) - 1,\n sets=[\"all\"]\n )\n\n # Save metadata as JSON.\n save_dir = os.path.join(config.output_dir, set_name)\n os.makedirs(save_dir, exist_ok=True)\n \n with open(os.path.join(save_dir, \"dataset.json\"), \"w\") as f:\n json.dump(metadata.model_dump(), f)\n \n # Save data\n for k, v in results.items():\n np.save(os.path.join(save_dir, f\"all__{k}.npy\"), v)\n \n # Save IDs mapping (for visualization only)\n with open(os.path.join(config.output_dir, \"identifiers.json\"), \"w\") as f:\n json.dump([\"\"], f)\n\n\n@cli.command(singleton=True)\ndef preprocess_data(config: DataProcessConfig):\n convert_subset(\"train\", config)\n convert_subset(\"test\", config)\n\n\nif __name__ == \"__main__\":\n cli()","source_hash":"9cd1c28c4b186d990b9d671f82e4697eac19ae63ac58c3c29a54c662f2da1ea4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_sudoku_dataset.DataProcessConfig","uri":"program://TinyRecursiveModels/class/dataset.build_sudoku_dataset.DataProcessConfig#L18-L24","kind":"class","name":"DataProcessConfig","path":"dataset/build_sudoku_dataset.py","language":"python","start_line":18,"end_line":24,"context_start_line":1,"context_end_line":44,"code":"from typing import Optional\nimport os\nimport csv\nimport json\nimport numpy as np\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\nfrom tqdm import tqdm\nfrom huggingface_hub import hf_hub_download\n\nfrom common import PuzzleDatasetMetadata\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n source_repo: str = \"sapientinc/sudoku-extreme\"\n output_dir: str = \"data/sudoku-extreme-full\"\n\n subsample_size: Optional[int] = None\n min_difficulty: Optional[int] = None\n num_aug: int = 0\n\n\ndef shuffle_sudoku(board: np.ndarray, solution: np.ndarray):\n # Create a random digit mapping: a permutation of 1..9, with zero (blank) unchanged\n digit_map = np.pad(np.random.permutation(np.arange(1, 10)), (1, 0))\n \n # Randomly decide whether to transpose.\n transpose_flag = np.random.rand() < 0.5\n\n # Generate a valid row permutation:\n # - Shuffle the 3 bands (each band = 3 rows) and for each band, shuffle its 3 rows.\n bands = np.random.permutation(3)\n row_perm = np.concatenate([b * 3 + np.random.permutation(3) for b in bands])\n\n # Similarly for columns (stacks).\n stacks = np.random.permutation(3)\n col_perm = np.concatenate([s * 3 + np.random.permutation(3) for s in stacks])\n\n # Build an 81->81 mapping. For each new cell at (i, j)\n # (row index = i // 9, col index = i % 9),","source_hash":"9cd1c28c4b186d990b9d671f82e4697eac19ae63ac58c3c29a54c662f2da1ea4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_sudoku_dataset.shuffle_sudoku","uri":"program://TinyRecursiveModels/function/dataset.build_sudoku_dataset.shuffle_sudoku#L27-L57","kind":"function","name":"shuffle_sudoku","path":"dataset/build_sudoku_dataset.py","language":"python","start_line":27,"end_line":57,"context_start_line":7,"context_end_line":77,"code":"from argdantic import ArgParser\nfrom pydantic import BaseModel\nfrom tqdm import tqdm\nfrom huggingface_hub import hf_hub_download\n\nfrom common import PuzzleDatasetMetadata\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n source_repo: str = \"sapientinc/sudoku-extreme\"\n output_dir: str = \"data/sudoku-extreme-full\"\n\n subsample_size: Optional[int] = None\n min_difficulty: Optional[int] = None\n num_aug: int = 0\n\n\ndef shuffle_sudoku(board: np.ndarray, solution: np.ndarray):\n # Create a random digit mapping: a permutation of 1..9, with zero (blank) unchanged\n digit_map = np.pad(np.random.permutation(np.arange(1, 10)), (1, 0))\n \n # Randomly decide whether to transpose.\n transpose_flag = np.random.rand() < 0.5\n\n # Generate a valid row permutation:\n # - Shuffle the 3 bands (each band = 3 rows) and for each band, shuffle its 3 rows.\n bands = np.random.permutation(3)\n row_perm = np.concatenate([b * 3 + np.random.permutation(3) for b in bands])\n\n # Similarly for columns (stacks).\n stacks = np.random.permutation(3)\n col_perm = np.concatenate([s * 3 + np.random.permutation(3) for s in stacks])\n\n # Build an 81->81 mapping. For each new cell at (i, j)\n # (row index = i // 9, col index = i % 9),\n # its value comes from old row = row_perm[i//9] and old col = col_perm[i%9].\n mapping = np.array([row_perm[i // 9] * 9 + col_perm[i % 9] for i in range(81)])\n\n def apply_transformation(x: np.ndarray) -> np.ndarray:\n # Apply transpose flag\n if transpose_flag:\n x = x.T\n # Apply the position mapping.\n new_board = x.flatten()[mapping].reshape(9, 9).copy()\n # Apply digit mapping\n return digit_map[new_board]\n\n return apply_transformation(board), apply_transformation(solution)\n\n\ndef convert_subset(set_name: str, config: DataProcessConfig):\n # Read CSV\n inputs = []\n labels = []\n \n with open(hf_hub_download(config.source_repo, f\"{set_name}.csv\", repo_type=\"dataset\"), newline=\"\") as csvfile:\n reader = csv.reader(csvfile)\n next(reader) # Skip header\n for source, q, a, rating in reader:\n if (config.min_difficulty is None) or (int(rating) >= config.min_difficulty):\n assert len(q) == 81 and len(a) == 81\n \n inputs.append(np.frombuffer(q.replace('.', '0').encode(), dtype=np.uint8).reshape(9, 9) - ord('0'))\n labels.append(np.frombuffer(a.encode(), dtype=np.uint8).reshape(9, 9) - ord('0'))\n\n # If subsample_size is specified for the training set,\n # randomly sample the desired number of examples.\n if set_name == \"train\" and config.subsample_size is not None:","source_hash":"9cd1c28c4b186d990b9d671f82e4697eac19ae63ac58c3c29a54c662f2da1ea4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_sudoku_dataset.convert_subset","uri":"program://TinyRecursiveModels/function/dataset.build_sudoku_dataset.convert_subset#L60-L157","kind":"function","name":"convert_subset","path":"dataset/build_sudoku_dataset.py","language":"python","start_line":60,"end_line":157,"context_start_line":40,"context_end_line":167,"code":" stacks = np.random.permutation(3)\n col_perm = np.concatenate([s * 3 + np.random.permutation(3) for s in stacks])\n\n # Build an 81->81 mapping. For each new cell at (i, j)\n # (row index = i // 9, col index = i % 9),\n # its value comes from old row = row_perm[i//9] and old col = col_perm[i%9].\n mapping = np.array([row_perm[i // 9] * 9 + col_perm[i % 9] for i in range(81)])\n\n def apply_transformation(x: np.ndarray) -> np.ndarray:\n # Apply transpose flag\n if transpose_flag:\n x = x.T\n # Apply the position mapping.\n new_board = x.flatten()[mapping].reshape(9, 9).copy()\n # Apply digit mapping\n return digit_map[new_board]\n\n return apply_transformation(board), apply_transformation(solution)\n\n\ndef convert_subset(set_name: str, config: DataProcessConfig):\n # Read CSV\n inputs = []\n labels = []\n \n with open(hf_hub_download(config.source_repo, f\"{set_name}.csv\", repo_type=\"dataset\"), newline=\"\") as csvfile:\n reader = csv.reader(csvfile)\n next(reader) # Skip header\n for source, q, a, rating in reader:\n if (config.min_difficulty is None) or (int(rating) >= config.min_difficulty):\n assert len(q) == 81 and len(a) == 81\n \n inputs.append(np.frombuffer(q.replace('.', '0').encode(), dtype=np.uint8).reshape(9, 9) - ord('0'))\n labels.append(np.frombuffer(a.encode(), dtype=np.uint8).reshape(9, 9) - ord('0'))\n\n # If subsample_size is specified for the training set,\n # randomly sample the desired number of examples.\n if set_name == \"train\" and config.subsample_size is not None:\n total_samples = len(inputs)\n if config.subsample_size < total_samples:\n indices = np.random.choice(total_samples, size=config.subsample_size, replace=False)\n inputs = [inputs[i] for i in indices]\n labels = [labels[i] for i in indices]\n\n # Generate dataset\n num_augments = config.num_aug if set_name == \"train\" else 0\n\n results = {k: [] for k in [\"inputs\", \"labels\", \"puzzle_identifiers\", \"puzzle_indices\", \"group_indices\"]}\n puzzle_id = 0\n example_id = 0\n \n results[\"puzzle_indices\"].append(0)\n results[\"group_indices\"].append(0)\n \n for orig_inp, orig_out in zip(tqdm(inputs), labels):\n for aug_idx in range(1 + num_augments):\n # First index is not augmented\n if aug_idx == 0:\n inp, out = orig_inp, orig_out\n else:\n inp, out = shuffle_sudoku(orig_inp, orig_out)\n\n # Push puzzle (only single example)\n results[\"inputs\"].append(inp)\n results[\"labels\"].append(out)\n example_id += 1\n puzzle_id += 1\n \n results[\"puzzle_indices\"].append(example_id)\n results[\"puzzle_identifiers\"].append(0)\n \n # Push group\n results[\"group_indices\"].append(puzzle_id)\n \n # To Numpy\n def _seq_to_numpy(seq):\n arr = np.concatenate(seq).reshape(len(seq), -1)\n \n assert np.all((arr >= 0) & (arr <= 9))\n return arr + 1\n \n results = {\n \"inputs\": _seq_to_numpy(results[\"inputs\"]),\n \"labels\": _seq_to_numpy(results[\"labels\"]),\n \n \"group_indices\": np.array(results[\"group_indices\"], dtype=np.int32),\n \"puzzle_indices\": np.array(results[\"puzzle_indices\"], dtype=np.int32),\n \"puzzle_identifiers\": np.array(results[\"puzzle_identifiers\"], dtype=np.int32),\n }\n\n # Metadata\n metadata = PuzzleDatasetMetadata(\n seq_len=81,\n vocab_size=10 + 1, # PAD + \"0\" ... \"9\"\n pad_id=0,\n ignore_label_id=0,\n blank_identifier_id=0,\n num_puzzle_identifiers=1,\n total_groups=len(results[\"group_indices\"]) - 1,\n mean_puzzle_examples=1,\n total_puzzles=len(results[\"group_indices\"]) - 1,\n sets=[\"all\"]\n )\n\n # Save metadata as JSON.\n save_dir = os.path.join(config.output_dir, set_name)\n os.makedirs(save_dir, exist_ok=True)\n \n with open(os.path.join(save_dir, \"dataset.json\"), \"w\") as f:\n json.dump(metadata.model_dump(), f)\n \n # Save data\n for k, v in results.items():\n np.save(os.path.join(save_dir, f\"all__{k}.npy\"), v)\n \n # Save IDs mapping (for visualization only)\n with open(os.path.join(config.output_dir, \"identifiers.json\"), \"w\") as f:\n json.dump([\"\"], f)\n\n\n@cli.command(singleton=True)\ndef preprocess_data(config: DataProcessConfig):\n convert_subset(\"train\", config)\n convert_subset(\"test\", config)\n\n\nif __name__ == \"__main__\":\n cli()","source_hash":"9cd1c28c4b186d990b9d671f82e4697eac19ae63ac58c3c29a54c662f2da1ea4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_sudoku_dataset.preprocess_data","uri":"program://TinyRecursiveModels/function/dataset.build_sudoku_dataset.preprocess_data#L161-L163","kind":"function","name":"preprocess_data","path":"dataset/build_sudoku_dataset.py","language":"python","start_line":161,"end_line":163,"context_start_line":141,"context_end_line":167,"code":" sets=[\"all\"]\n )\n\n # Save metadata as JSON.\n save_dir = os.path.join(config.output_dir, set_name)\n os.makedirs(save_dir, exist_ok=True)\n \n with open(os.path.join(save_dir, \"dataset.json\"), \"w\") as f:\n json.dump(metadata.model_dump(), f)\n \n # Save data\n for k, v in results.items():\n np.save(os.path.join(save_dir, f\"all__{k}.npy\"), v)\n \n # Save IDs mapping (for visualization only)\n with open(os.path.join(config.output_dir, \"identifiers.json\"), \"w\") as f:\n json.dump([\"\"], f)\n\n\n@cli.command(singleton=True)\ndef preprocess_data(config: DataProcessConfig):\n convert_subset(\"train\", config)\n convert_subset(\"test\", config)\n\n\nif __name__ == \"__main__\":\n cli()","source_hash":"9cd1c28c4b186d990b9d671f82e4697eac19ae63ac58c3c29a54c662f2da1ea4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_sudoku_dataset.apply_transformation","uri":"program://TinyRecursiveModels/function/dataset.build_sudoku_dataset.apply_transformation#L48-L55","kind":"function","name":"apply_transformation","path":"dataset/build_sudoku_dataset.py","language":"python","start_line":48,"end_line":55,"context_start_line":28,"context_end_line":75,"code":" # Create a random digit mapping: a permutation of 1..9, with zero (blank) unchanged\n digit_map = np.pad(np.random.permutation(np.arange(1, 10)), (1, 0))\n \n # Randomly decide whether to transpose.\n transpose_flag = np.random.rand() < 0.5\n\n # Generate a valid row permutation:\n # - Shuffle the 3 bands (each band = 3 rows) and for each band, shuffle its 3 rows.\n bands = np.random.permutation(3)\n row_perm = np.concatenate([b * 3 + np.random.permutation(3) for b in bands])\n\n # Similarly for columns (stacks).\n stacks = np.random.permutation(3)\n col_perm = np.concatenate([s * 3 + np.random.permutation(3) for s in stacks])\n\n # Build an 81->81 mapping. For each new cell at (i, j)\n # (row index = i // 9, col index = i % 9),\n # its value comes from old row = row_perm[i//9] and old col = col_perm[i%9].\n mapping = np.array([row_perm[i // 9] * 9 + col_perm[i % 9] for i in range(81)])\n\n def apply_transformation(x: np.ndarray) -> np.ndarray:\n # Apply transpose flag\n if transpose_flag:\n x = x.T\n # Apply the position mapping.\n new_board = x.flatten()[mapping].reshape(9, 9).copy()\n # Apply digit mapping\n return digit_map[new_board]\n\n return apply_transformation(board), apply_transformation(solution)\n\n\ndef convert_subset(set_name: str, config: DataProcessConfig):\n # Read CSV\n inputs = []\n labels = []\n \n with open(hf_hub_download(config.source_repo, f\"{set_name}.csv\", repo_type=\"dataset\"), newline=\"\") as csvfile:\n reader = csv.reader(csvfile)\n next(reader) # Skip header\n for source, q, a, rating in reader:\n if (config.min_difficulty is None) or (int(rating) >= config.min_difficulty):\n assert len(q) == 81 and len(a) == 81\n \n inputs.append(np.frombuffer(q.replace('.', '0').encode(), dtype=np.uint8).reshape(9, 9) - ord('0'))\n labels.append(np.frombuffer(a.encode(), dtype=np.uint8).reshape(9, 9) - ord('0'))\n\n # If subsample_size is specified for the training set,","source_hash":"9cd1c28c4b186d990b9d671f82e4697eac19ae63ac58c3c29a54c662f2da1ea4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_sudoku_dataset._seq_to_numpy","uri":"program://TinyRecursiveModels/function/dataset.build_sudoku_dataset._seq_to_numpy#L115-L119","kind":"function","name":"_seq_to_numpy","path":"dataset/build_sudoku_dataset.py","language":"python","start_line":115,"end_line":119,"context_start_line":95,"context_end_line":139,"code":" for aug_idx in range(1 + num_augments):\n # First index is not augmented\n if aug_idx == 0:\n inp, out = orig_inp, orig_out\n else:\n inp, out = shuffle_sudoku(orig_inp, orig_out)\n\n # Push puzzle (only single example)\n results[\"inputs\"].append(inp)\n results[\"labels\"].append(out)\n example_id += 1\n puzzle_id += 1\n \n results[\"puzzle_indices\"].append(example_id)\n results[\"puzzle_identifiers\"].append(0)\n \n # Push group\n results[\"group_indices\"].append(puzzle_id)\n \n # To Numpy\n def _seq_to_numpy(seq):\n arr = np.concatenate(seq).reshape(len(seq), -1)\n \n assert np.all((arr >= 0) & (arr <= 9))\n return arr + 1\n \n results = {\n \"inputs\": _seq_to_numpy(results[\"inputs\"]),\n \"labels\": _seq_to_numpy(results[\"labels\"]),\n \n \"group_indices\": np.array(results[\"group_indices\"], dtype=np.int32),\n \"puzzle_indices\": np.array(results[\"puzzle_indices\"], dtype=np.int32),\n \"puzzle_identifiers\": np.array(results[\"puzzle_identifiers\"], dtype=np.int32),\n }\n\n # Metadata\n metadata = PuzzleDatasetMetadata(\n seq_len=81,\n vocab_size=10 + 1, # PAD + \"0\" ... \"9\"\n pad_id=0,\n ignore_label_id=0,\n blank_identifier_id=0,\n num_puzzle_identifiers=1,\n total_groups=len(results[\"group_indices\"]) - 1,\n mean_puzzle_examples=1,","source_hash":"9cd1c28c4b186d990b9d671f82e4697eac19ae63ac58c3c29a54c662f2da1ea4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset","uri":"program://TinyRecursiveModels/module/dataset.build_arc_dataset#L1-L341","kind":"module","name":"dataset.build_arc_dataset","path":"dataset/build_arc_dataset.py","language":"python","start_line":1,"end_line":341,"context_start_line":1,"context_end_line":341,"code":"from typing import List, Tuple, Dict\nfrom dataclasses import dataclass\nimport os\nimport json\nimport hashlib\nimport numpy as np\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\n\nfrom dataset.common import PuzzleDatasetMetadata, dihedral_transform, inverse_dihedral_transform\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n input_file_prefix: str\n output_dir: str\n subsets: List[str]\n test_set_name: str\n test_set_name2: str = \"your_test_set\"\n seed: int = 42\n num_aug: int = 1000\n puzzle_identifiers_start: int = 1 # start > 1 to handle multiple datasets\n \nARCMaxGridSize = 30\nARCAugmentRetriesFactor = 5\n\nPuzzleIdSeparator = \"|||\"\n \n\n@dataclass\nclass ARCPuzzle:\n id: str\n examples: List[Tuple[np.ndarray, np.ndarray]]\n\n \ndef arc_grid_to_np(grid: List[List[int]]):\n arr = np.array(grid)\n\n # Shape check\n assert arr.ndim == 2\n assert arr.shape[0] <= ARCMaxGridSize and arr.shape[1] <= ARCMaxGridSize\n # Element check\n assert np.all((arr >= 0) & (arr <= 9))\n return arr.astype(np.uint8)\n\n\ndef np_grid_to_seq_translational_augment(inp: np.ndarray, out: np.ndarray, do_translation: bool):\n # PAD: 0, : 1, digits: 2 ... 11\n # Compute random top-left pad\n if do_translation:\n pad_r = np.random.randint(0, ARCMaxGridSize - max(inp.shape[0], out.shape[0]) + 1)\n pad_c = np.random.randint(0, ARCMaxGridSize - max(inp.shape[1], out.shape[1]) + 1)\n else:\n pad_r = pad_c = 0\n\n # Pad grid\n result = []\n for grid in [inp, out]:\n nrow, ncol = grid.shape\n grid = np.pad(grid + 2, ((pad_r, ARCMaxGridSize - pad_r - nrow), (pad_c, ARCMaxGridSize - pad_c - ncol)), constant_values=0)\n\n # Add \n eos_row, eos_col = pad_r + nrow, pad_c + ncol\n if eos_row < ARCMaxGridSize:\n grid[eos_row, pad_c:eos_col] = 1\n if eos_col < ARCMaxGridSize:\n grid[pad_r:eos_row, eos_col] = 1\n\n result.append(grid.flatten())\n\n return result\n\n\ndef grid_hash(grid: np.ndarray):\n assert grid.ndim == 2\n assert grid.dtype == np.uint8\n\n buffer = [x.to_bytes(1, byteorder='big') for x in grid.shape]\n buffer.append(grid.tobytes())\n \n return hashlib.sha256(b\"\".join(buffer)).hexdigest()\n\n\ndef puzzle_hash(puzzle: dict):\n # Hash the puzzle for checking equivalence\n hashes = []\n for example_type, example in puzzle.items():\n for input, label in example.examples:\n hashes.append(f\"{grid_hash(input)}|{grid_hash(label)}\")\n \n hashes.sort()\n return hashlib.sha256(\"|\".join(hashes).encode()).hexdigest()\n\n\ndef aug(name: str):\n # Augment plan\n trans_id = np.random.randint(0, 8)\n mapping = np.concatenate([np.arange(0, 1, dtype=np.uint8), np.random.permutation(np.arange(1, 10, dtype=np.uint8))]) # Permute colors, Excluding \"0\" (black)\n \n name_with_aug_repr = f\"{name}{PuzzleIdSeparator}t{trans_id}{PuzzleIdSeparator}{''.join(str(x) for x in mapping)}\"\n\n def _map_grid(grid: np.ndarray):\n return dihedral_transform(mapping[grid], trans_id)\n \n return name_with_aug_repr, _map_grid\n\n\ndef inverse_aug(name: str):\n # Inverse the \"aug\" function\n if PuzzleIdSeparator not in name:\n return name, lambda x: x\n\n trans_id, perm = name.split(PuzzleIdSeparator)[-2:]\n trans_id = int(trans_id[1:]) # Remove \"t\" letter\n inv_perm = np.argsort(list(perm)).astype(np.uint8)\n \n def _map_grid(grid: np.ndarray):\n return inv_perm[inverse_dihedral_transform(grid, trans_id)]\n \n return name.split(PuzzleIdSeparator)[0], _map_grid\n\n\ndef convert_single_arc_puzzle(results: dict, name: str, puzzle: dict, aug_count: int, dest_mapping: Dict[str, Tuple[str, str]]):\n # Convert\n dests = set(dest_mapping.values())\n converted = {dest: ARCPuzzle(name, []) for dest in dests}\n for example_type, examples in puzzle.items():\n # Map to target split\n dest = dest_mapping[example_type]\n converted[dest].examples.extend([(arc_grid_to_np(example[\"input\"]), arc_grid_to_np(example[\"output\"])) for example in examples])\n\n group = [converted]\n \n # Augment\n if aug_count > 0:\n hashes = {puzzle_hash(converted)}\n\n for _trial in range(ARCAugmentRetriesFactor * aug_count):\n aug_name, _map_grid = aug(name)\n\n # Check duplicate\n augmented = {dest: ARCPuzzle(aug_name, [(_map_grid(input), _map_grid(label)) for (input, label) in puzzle.examples]) for dest, puzzle in converted.items()}\n h = puzzle_hash(augmented)\n if h not in hashes:\n hashes.add(h)\n group.append(augmented)\n \n if len(group) >= aug_count + 1:\n break\n \n if len(group) < aug_count + 1:\n print (f\"[Puzzle {name}] augmentation not full, only {len(group)}\")\n\n # Append\n for dest in dests:\n # Convert the examples\n dest_split, dest_set = dest\n\n results.setdefault(dest_split, {})\n results[dest_split].setdefault(dest_set, [])\n results[dest_split][dest_set].append([converted[dest] for converted in group])\n\n\ndef load_puzzles_arcagi(config: DataProcessConfig):\n train_examples_dest = (\"train\", \"all\")\n test_examples_map = {\n config.test_set_name: [(1.0, (\"test\", \"all\"))],\n config.test_set_name2: [(1.0, (\"test\", \"all\"))],\n \"_default\": [(1.0, (\"train\", \"all\"))]\n }\n \n test_puzzles = {}\n results = {}\n\n total_puzzles = 0\n for subset_name in config.subsets:\n # Load all puzzles in this subset\n with open(f\"{config.input_file_prefix}_{subset_name}_challenges.json\", \"r\") as f:\n puzzles = json.load(f)\n\n sols_filename = f\"{config.input_file_prefix}_{subset_name}_solutions.json\"\n if os.path.isfile(sols_filename):\n with open(sols_filename, \"r\") as f:\n sols = json.load(f)\n \n for puzzle_id in puzzles.keys():\n for idx, sol_grid in enumerate(sols[puzzle_id]):\n puzzles[puzzle_id][\"test\"][idx][\"output\"] = sol_grid\n else:\n # Fill with dummy\n print (f\"{subset_name} solutions not found, filling with dummy\")\n\n for puzzle_id, puzzle in puzzles.items():\n for example in puzzle[\"test\"]:\n example.setdefault(\"output\", [[0]])\n\n # Shuffle puzzles\n puzzles = list(puzzles.items())\n np.random.shuffle(puzzles)\n \n # Assign by fraction\n for idx, (name, puzzle) in enumerate(puzzles):\n fraction = idx / len(puzzles)\n test_examples_dest = None\n for f, dest in test_examples_map.get(subset_name, test_examples_map[\"_default\"]):\n if fraction < f:\n test_examples_dest = dest\n break\n \n assert test_examples_dest is not None\n \n if test_examples_dest[0] == \"test\":\n test_puzzles[name] = puzzle\n \n convert_single_arc_puzzle(results, name, puzzle, config.num_aug, {\"train\": train_examples_dest, \"test\": test_examples_dest})\n total_puzzles += 1\n\n print (f\"Total puzzles: {total_puzzles}\")\n return results, test_puzzles\n\n\ndef convert_dataset(config: DataProcessConfig):\n np.random.seed(config.seed)\n \n # Read dataset\n data, test_puzzles = load_puzzles_arcagi(config)\n \n # Map global puzzle identifiers\n num_identifiers = config.puzzle_identifiers_start # 0 is blank, start at 1\n identifier_map = {}\n for split_name, split in data.items():\n for subset_name, subset in split.items():\n for group in subset:\n for puzzle in group:\n if puzzle.id not in identifier_map:\n identifier_map[puzzle.id] = num_identifiers\n num_identifiers += 1\n print (f\"Total puzzle IDs (including ): {num_identifiers}\")\n\n # Save\n for split_name, split in data.items():\n os.makedirs(os.path.join(config.output_dir, split_name), exist_ok=True)\n \n # Translational augmentations\n enable_translational_augment = split_name == \"train\"\n\n # Statistics\n total_examples = 0\n total_puzzles = 0\n total_groups = 0\n \n for subset_name, subset in split.items(): # \"all\" is the only subset\n # Construct subset\n results = {k: [] for k in [\"inputs\", \"labels\", \"puzzle_identifiers\", \"puzzle_indices\", \"group_indices\"]}\n results[\"puzzle_indices\"].append(0)\n results[\"group_indices\"].append(0)\n \n example_id = 0\n puzzle_id = 0\n \n for group in subset:\n for puzzle in group:\n # Push puzzle\n no_aug_id = np.random.randint(0, len(puzzle.examples))\n for _idx_ex, (inp, out) in enumerate(puzzle.examples):\n inp, out = np_grid_to_seq_translational_augment(inp, out, do_translation=enable_translational_augment and _idx_ex != no_aug_id)\n \n results[\"inputs\"].append(inp)\n results[\"labels\"].append(out)\n example_id += 1\n \n total_examples += 1\n\n results[\"puzzle_indices\"].append(example_id)\n results[\"puzzle_identifiers\"].append(identifier_map[puzzle.id])\n \n puzzle_id += 1\n total_puzzles += 1\n \n # Push group\n results[\"group_indices\"].append(puzzle_id)\n total_groups += 1\n \n for k, v in results.items():\n if k in {\"inputs\", \"labels\"}:\n v = np.stack(v, 0)\n else:\n v = np.array(v, dtype=np.int32)\n \n np.save(os.path.join(config.output_dir, split_name, f\"{subset_name}__{k}.npy\"), v)\n \n # Metadata\n metadata = PuzzleDatasetMetadata(\n seq_len=ARCMaxGridSize * ARCMaxGridSize,\n vocab_size=10 + 2, # PAD + EOS + \"0\" ... \"9\"\n pad_id=0,\n ignore_label_id=0,\n blank_identifier_id=0,\n num_puzzle_identifiers=num_identifiers,\n total_groups=total_groups,\n mean_puzzle_examples=total_examples / total_puzzles,\n total_puzzles=total_puzzles,\n sets=list(split.keys())\n )\n\n # Save metadata as JSON.\n with open(os.path.join(config.output_dir, split_name, \"dataset.json\"), \"w\") as f:\n json.dump(metadata.model_dump(), f)\n \n # Save IDs mapping\n with open(os.path.join(config.output_dir, \"identifiers.json\"), \"w\") as f:\n ids_mapping = {v: k for k, v in identifier_map.items()}\n json.dump([ids_mapping.get(i, \"\") for i in range(num_identifiers)], f)\n \n # Save Test Puzzles\n with open(os.path.join(config.output_dir, \"test_puzzles.json\"), \"w\") as f:\n json.dump(test_puzzles, f)\n\n\n@cli.command(singleton=True)\ndef main(config: DataProcessConfig):\n convert_dataset(config)\n\n\nif __name__ == \"__main__\":\n cli()\n\n\n\n\n\n\n\n\n\n\n\n","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.DataProcessConfig","uri":"program://TinyRecursiveModels/class/dataset.build_arc_dataset.DataProcessConfig#L17-L25","kind":"class","name":"DataProcessConfig","path":"dataset/build_arc_dataset.py","language":"python","start_line":17,"end_line":25,"context_start_line":1,"context_end_line":45,"code":"from typing import List, Tuple, Dict\nfrom dataclasses import dataclass\nimport os\nimport json\nimport hashlib\nimport numpy as np\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\n\nfrom dataset.common import PuzzleDatasetMetadata, dihedral_transform, inverse_dihedral_transform\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n input_file_prefix: str\n output_dir: str\n subsets: List[str]\n test_set_name: str\n test_set_name2: str = \"your_test_set\"\n seed: int = 42\n num_aug: int = 1000\n puzzle_identifiers_start: int = 1 # start > 1 to handle multiple datasets\n \nARCMaxGridSize = 30\nARCAugmentRetriesFactor = 5\n\nPuzzleIdSeparator = \"|||\"\n \n\n@dataclass\nclass ARCPuzzle:\n id: str\n examples: List[Tuple[np.ndarray, np.ndarray]]\n\n \ndef arc_grid_to_np(grid: List[List[int]]):\n arr = np.array(grid)\n\n # Shape check\n assert arr.ndim == 2\n assert arr.shape[0] <= ARCMaxGridSize and arr.shape[1] <= ARCMaxGridSize\n # Element check","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.ARCPuzzle","uri":"program://TinyRecursiveModels/class/dataset.build_arc_dataset.ARCPuzzle#L34-L36","kind":"class","name":"ARCPuzzle","path":"dataset/build_arc_dataset.py","language":"python","start_line":34,"end_line":36,"context_start_line":14,"context_end_line":56,"code":"cli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n input_file_prefix: str\n output_dir: str\n subsets: List[str]\n test_set_name: str\n test_set_name2: str = \"your_test_set\"\n seed: int = 42\n num_aug: int = 1000\n puzzle_identifiers_start: int = 1 # start > 1 to handle multiple datasets\n \nARCMaxGridSize = 30\nARCAugmentRetriesFactor = 5\n\nPuzzleIdSeparator = \"|||\"\n \n\n@dataclass\nclass ARCPuzzle:\n id: str\n examples: List[Tuple[np.ndarray, np.ndarray]]\n\n \ndef arc_grid_to_np(grid: List[List[int]]):\n arr = np.array(grid)\n\n # Shape check\n assert arr.ndim == 2\n assert arr.shape[0] <= ARCMaxGridSize and arr.shape[1] <= ARCMaxGridSize\n # Element check\n assert np.all((arr >= 0) & (arr <= 9))\n return arr.astype(np.uint8)\n\n\ndef np_grid_to_seq_translational_augment(inp: np.ndarray, out: np.ndarray, do_translation: bool):\n # PAD: 0, : 1, digits: 2 ... 11\n # Compute random top-left pad\n if do_translation:\n pad_r = np.random.randint(0, ARCMaxGridSize - max(inp.shape[0], out.shape[0]) + 1)\n pad_c = np.random.randint(0, ARCMaxGridSize - max(inp.shape[1], out.shape[1]) + 1)\n else:","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.arc_grid_to_np","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.arc_grid_to_np#L39-L47","kind":"function","name":"arc_grid_to_np","path":"dataset/build_arc_dataset.py","language":"python","start_line":39,"end_line":47,"context_start_line":19,"context_end_line":67,"code":" output_dir: str\n subsets: List[str]\n test_set_name: str\n test_set_name2: str = \"your_test_set\"\n seed: int = 42\n num_aug: int = 1000\n puzzle_identifiers_start: int = 1 # start > 1 to handle multiple datasets\n \nARCMaxGridSize = 30\nARCAugmentRetriesFactor = 5\n\nPuzzleIdSeparator = \"|||\"\n \n\n@dataclass\nclass ARCPuzzle:\n id: str\n examples: List[Tuple[np.ndarray, np.ndarray]]\n\n \ndef arc_grid_to_np(grid: List[List[int]]):\n arr = np.array(grid)\n\n # Shape check\n assert arr.ndim == 2\n assert arr.shape[0] <= ARCMaxGridSize and arr.shape[1] <= ARCMaxGridSize\n # Element check\n assert np.all((arr >= 0) & (arr <= 9))\n return arr.astype(np.uint8)\n\n\ndef np_grid_to_seq_translational_augment(inp: np.ndarray, out: np.ndarray, do_translation: bool):\n # PAD: 0, : 1, digits: 2 ... 11\n # Compute random top-left pad\n if do_translation:\n pad_r = np.random.randint(0, ARCMaxGridSize - max(inp.shape[0], out.shape[0]) + 1)\n pad_c = np.random.randint(0, ARCMaxGridSize - max(inp.shape[1], out.shape[1]) + 1)\n else:\n pad_r = pad_c = 0\n\n # Pad grid\n result = []\n for grid in [inp, out]:\n nrow, ncol = grid.shape\n grid = np.pad(grid + 2, ((pad_r, ARCMaxGridSize - pad_r - nrow), (pad_c, ARCMaxGridSize - pad_c - ncol)), constant_values=0)\n\n # Add \n eos_row, eos_col = pad_r + nrow, pad_c + ncol\n if eos_row < ARCMaxGridSize:","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.np_grid_to_seq_translational_augment","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.np_grid_to_seq_translational_augment#L50-L74","kind":"function","name":"np_grid_to_seq_translational_augment","path":"dataset/build_arc_dataset.py","language":"python","start_line":50,"end_line":74,"context_start_line":30,"context_end_line":94,"code":"PuzzleIdSeparator = \"|||\"\n \n\n@dataclass\nclass ARCPuzzle:\n id: str\n examples: List[Tuple[np.ndarray, np.ndarray]]\n\n \ndef arc_grid_to_np(grid: List[List[int]]):\n arr = np.array(grid)\n\n # Shape check\n assert arr.ndim == 2\n assert arr.shape[0] <= ARCMaxGridSize and arr.shape[1] <= ARCMaxGridSize\n # Element check\n assert np.all((arr >= 0) & (arr <= 9))\n return arr.astype(np.uint8)\n\n\ndef np_grid_to_seq_translational_augment(inp: np.ndarray, out: np.ndarray, do_translation: bool):\n # PAD: 0, : 1, digits: 2 ... 11\n # Compute random top-left pad\n if do_translation:\n pad_r = np.random.randint(0, ARCMaxGridSize - max(inp.shape[0], out.shape[0]) + 1)\n pad_c = np.random.randint(0, ARCMaxGridSize - max(inp.shape[1], out.shape[1]) + 1)\n else:\n pad_r = pad_c = 0\n\n # Pad grid\n result = []\n for grid in [inp, out]:\n nrow, ncol = grid.shape\n grid = np.pad(grid + 2, ((pad_r, ARCMaxGridSize - pad_r - nrow), (pad_c, ARCMaxGridSize - pad_c - ncol)), constant_values=0)\n\n # Add \n eos_row, eos_col = pad_r + nrow, pad_c + ncol\n if eos_row < ARCMaxGridSize:\n grid[eos_row, pad_c:eos_col] = 1\n if eos_col < ARCMaxGridSize:\n grid[pad_r:eos_row, eos_col] = 1\n\n result.append(grid.flatten())\n\n return result\n\n\ndef grid_hash(grid: np.ndarray):\n assert grid.ndim == 2\n assert grid.dtype == np.uint8\n\n buffer = [x.to_bytes(1, byteorder='big') for x in grid.shape]\n buffer.append(grid.tobytes())\n \n return hashlib.sha256(b\"\".join(buffer)).hexdigest()\n\n\ndef puzzle_hash(puzzle: dict):\n # Hash the puzzle for checking equivalence\n hashes = []\n for example_type, example in puzzle.items():\n for input, label in example.examples:\n hashes.append(f\"{grid_hash(input)}|{grid_hash(label)}\")\n \n hashes.sort()","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.grid_hash","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.grid_hash#L77-L84","kind":"function","name":"grid_hash","path":"dataset/build_arc_dataset.py","language":"python","start_line":77,"end_line":84,"context_start_line":57,"context_end_line":104,"code":" pad_r = pad_c = 0\n\n # Pad grid\n result = []\n for grid in [inp, out]:\n nrow, ncol = grid.shape\n grid = np.pad(grid + 2, ((pad_r, ARCMaxGridSize - pad_r - nrow), (pad_c, ARCMaxGridSize - pad_c - ncol)), constant_values=0)\n\n # Add \n eos_row, eos_col = pad_r + nrow, pad_c + ncol\n if eos_row < ARCMaxGridSize:\n grid[eos_row, pad_c:eos_col] = 1\n if eos_col < ARCMaxGridSize:\n grid[pad_r:eos_row, eos_col] = 1\n\n result.append(grid.flatten())\n\n return result\n\n\ndef grid_hash(grid: np.ndarray):\n assert grid.ndim == 2\n assert grid.dtype == np.uint8\n\n buffer = [x.to_bytes(1, byteorder='big') for x in grid.shape]\n buffer.append(grid.tobytes())\n \n return hashlib.sha256(b\"\".join(buffer)).hexdigest()\n\n\ndef puzzle_hash(puzzle: dict):\n # Hash the puzzle for checking equivalence\n hashes = []\n for example_type, example in puzzle.items():\n for input, label in example.examples:\n hashes.append(f\"{grid_hash(input)}|{grid_hash(label)}\")\n \n hashes.sort()\n return hashlib.sha256(\"|\".join(hashes).encode()).hexdigest()\n\n\ndef aug(name: str):\n # Augment plan\n trans_id = np.random.randint(0, 8)\n mapping = np.concatenate([np.arange(0, 1, dtype=np.uint8), np.random.permutation(np.arange(1, 10, dtype=np.uint8))]) # Permute colors, Excluding \"0\" (black)\n \n name_with_aug_repr = f\"{name}{PuzzleIdSeparator}t{trans_id}{PuzzleIdSeparator}{''.join(str(x) for x in mapping)}\"\n","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.puzzle_hash","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.puzzle_hash#L87-L95","kind":"function","name":"puzzle_hash","path":"dataset/build_arc_dataset.py","language":"python","start_line":87,"end_line":95,"context_start_line":67,"context_end_line":115,"code":" if eos_row < ARCMaxGridSize:\n grid[eos_row, pad_c:eos_col] = 1\n if eos_col < ARCMaxGridSize:\n grid[pad_r:eos_row, eos_col] = 1\n\n result.append(grid.flatten())\n\n return result\n\n\ndef grid_hash(grid: np.ndarray):\n assert grid.ndim == 2\n assert grid.dtype == np.uint8\n\n buffer = [x.to_bytes(1, byteorder='big') for x in grid.shape]\n buffer.append(grid.tobytes())\n \n return hashlib.sha256(b\"\".join(buffer)).hexdigest()\n\n\ndef puzzle_hash(puzzle: dict):\n # Hash the puzzle for checking equivalence\n hashes = []\n for example_type, example in puzzle.items():\n for input, label in example.examples:\n hashes.append(f\"{grid_hash(input)}|{grid_hash(label)}\")\n \n hashes.sort()\n return hashlib.sha256(\"|\".join(hashes).encode()).hexdigest()\n\n\ndef aug(name: str):\n # Augment plan\n trans_id = np.random.randint(0, 8)\n mapping = np.concatenate([np.arange(0, 1, dtype=np.uint8), np.random.permutation(np.arange(1, 10, dtype=np.uint8))]) # Permute colors, Excluding \"0\" (black)\n \n name_with_aug_repr = f\"{name}{PuzzleIdSeparator}t{trans_id}{PuzzleIdSeparator}{''.join(str(x) for x in mapping)}\"\n\n def _map_grid(grid: np.ndarray):\n return dihedral_transform(mapping[grid], trans_id)\n \n return name_with_aug_repr, _map_grid\n\n\ndef inverse_aug(name: str):\n # Inverse the \"aug\" function\n if PuzzleIdSeparator not in name:\n return name, lambda x: x\n","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.aug","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.aug#L98-L108","kind":"function","name":"aug","path":"dataset/build_arc_dataset.py","language":"python","start_line":98,"end_line":108,"context_start_line":78,"context_end_line":128,"code":" assert grid.ndim == 2\n assert grid.dtype == np.uint8\n\n buffer = [x.to_bytes(1, byteorder='big') for x in grid.shape]\n buffer.append(grid.tobytes())\n \n return hashlib.sha256(b\"\".join(buffer)).hexdigest()\n\n\ndef puzzle_hash(puzzle: dict):\n # Hash the puzzle for checking equivalence\n hashes = []\n for example_type, example in puzzle.items():\n for input, label in example.examples:\n hashes.append(f\"{grid_hash(input)}|{grid_hash(label)}\")\n \n hashes.sort()\n return hashlib.sha256(\"|\".join(hashes).encode()).hexdigest()\n\n\ndef aug(name: str):\n # Augment plan\n trans_id = np.random.randint(0, 8)\n mapping = np.concatenate([np.arange(0, 1, dtype=np.uint8), np.random.permutation(np.arange(1, 10, dtype=np.uint8))]) # Permute colors, Excluding \"0\" (black)\n \n name_with_aug_repr = f\"{name}{PuzzleIdSeparator}t{trans_id}{PuzzleIdSeparator}{''.join(str(x) for x in mapping)}\"\n\n def _map_grid(grid: np.ndarray):\n return dihedral_transform(mapping[grid], trans_id)\n \n return name_with_aug_repr, _map_grid\n\n\ndef inverse_aug(name: str):\n # Inverse the \"aug\" function\n if PuzzleIdSeparator not in name:\n return name, lambda x: x\n\n trans_id, perm = name.split(PuzzleIdSeparator)[-2:]\n trans_id = int(trans_id[1:]) # Remove \"t\" letter\n inv_perm = np.argsort(list(perm)).astype(np.uint8)\n \n def _map_grid(grid: np.ndarray):\n return inv_perm[inverse_dihedral_transform(grid, trans_id)]\n \n return name.split(PuzzleIdSeparator)[0], _map_grid\n\n\ndef convert_single_arc_puzzle(results: dict, name: str, puzzle: dict, aug_count: int, dest_mapping: Dict[str, Tuple[str, str]]):\n # Convert\n dests = set(dest_mapping.values())","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.inverse_aug","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.inverse_aug#L111-L123","kind":"function","name":"inverse_aug","path":"dataset/build_arc_dataset.py","language":"python","start_line":111,"end_line":123,"context_start_line":91,"context_end_line":143,"code":" for input, label in example.examples:\n hashes.append(f\"{grid_hash(input)}|{grid_hash(label)}\")\n \n hashes.sort()\n return hashlib.sha256(\"|\".join(hashes).encode()).hexdigest()\n\n\ndef aug(name: str):\n # Augment plan\n trans_id = np.random.randint(0, 8)\n mapping = np.concatenate([np.arange(0, 1, dtype=np.uint8), np.random.permutation(np.arange(1, 10, dtype=np.uint8))]) # Permute colors, Excluding \"0\" (black)\n \n name_with_aug_repr = f\"{name}{PuzzleIdSeparator}t{trans_id}{PuzzleIdSeparator}{''.join(str(x) for x in mapping)}\"\n\n def _map_grid(grid: np.ndarray):\n return dihedral_transform(mapping[grid], trans_id)\n \n return name_with_aug_repr, _map_grid\n\n\ndef inverse_aug(name: str):\n # Inverse the \"aug\" function\n if PuzzleIdSeparator not in name:\n return name, lambda x: x\n\n trans_id, perm = name.split(PuzzleIdSeparator)[-2:]\n trans_id = int(trans_id[1:]) # Remove \"t\" letter\n inv_perm = np.argsort(list(perm)).astype(np.uint8)\n \n def _map_grid(grid: np.ndarray):\n return inv_perm[inverse_dihedral_transform(grid, trans_id)]\n \n return name.split(PuzzleIdSeparator)[0], _map_grid\n\n\ndef convert_single_arc_puzzle(results: dict, name: str, puzzle: dict, aug_count: int, dest_mapping: Dict[str, Tuple[str, str]]):\n # Convert\n dests = set(dest_mapping.values())\n converted = {dest: ARCPuzzle(name, []) for dest in dests}\n for example_type, examples in puzzle.items():\n # Map to target split\n dest = dest_mapping[example_type]\n converted[dest].examples.extend([(arc_grid_to_np(example[\"input\"]), arc_grid_to_np(example[\"output\"])) for example in examples])\n\n group = [converted]\n \n # Augment\n if aug_count > 0:\n hashes = {puzzle_hash(converted)}\n\n for _trial in range(ARCAugmentRetriesFactor * aug_count):\n aug_name, _map_grid = aug(name)\n","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.convert_single_arc_puzzle","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.convert_single_arc_puzzle#L126-L164","kind":"function","name":"convert_single_arc_puzzle","path":"dataset/build_arc_dataset.py","language":"python","start_line":126,"end_line":164,"context_start_line":106,"context_end_line":184,"code":" return dihedral_transform(mapping[grid], trans_id)\n \n return name_with_aug_repr, _map_grid\n\n\ndef inverse_aug(name: str):\n # Inverse the \"aug\" function\n if PuzzleIdSeparator not in name:\n return name, lambda x: x\n\n trans_id, perm = name.split(PuzzleIdSeparator)[-2:]\n trans_id = int(trans_id[1:]) # Remove \"t\" letter\n inv_perm = np.argsort(list(perm)).astype(np.uint8)\n \n def _map_grid(grid: np.ndarray):\n return inv_perm[inverse_dihedral_transform(grid, trans_id)]\n \n return name.split(PuzzleIdSeparator)[0], _map_grid\n\n\ndef convert_single_arc_puzzle(results: dict, name: str, puzzle: dict, aug_count: int, dest_mapping: Dict[str, Tuple[str, str]]):\n # Convert\n dests = set(dest_mapping.values())\n converted = {dest: ARCPuzzle(name, []) for dest in dests}\n for example_type, examples in puzzle.items():\n # Map to target split\n dest = dest_mapping[example_type]\n converted[dest].examples.extend([(arc_grid_to_np(example[\"input\"]), arc_grid_to_np(example[\"output\"])) for example in examples])\n\n group = [converted]\n \n # Augment\n if aug_count > 0:\n hashes = {puzzle_hash(converted)}\n\n for _trial in range(ARCAugmentRetriesFactor * aug_count):\n aug_name, _map_grid = aug(name)\n\n # Check duplicate\n augmented = {dest: ARCPuzzle(aug_name, [(_map_grid(input), _map_grid(label)) for (input, label) in puzzle.examples]) for dest, puzzle in converted.items()}\n h = puzzle_hash(augmented)\n if h not in hashes:\n hashes.add(h)\n group.append(augmented)\n \n if len(group) >= aug_count + 1:\n break\n \n if len(group) < aug_count + 1:\n print (f\"[Puzzle {name}] augmentation not full, only {len(group)}\")\n\n # Append\n for dest in dests:\n # Convert the examples\n dest_split, dest_set = dest\n\n results.setdefault(dest_split, {})\n results[dest_split].setdefault(dest_set, [])\n results[dest_split][dest_set].append([converted[dest] for converted in group])\n\n\ndef load_puzzles_arcagi(config: DataProcessConfig):\n train_examples_dest = (\"train\", \"all\")\n test_examples_map = {\n config.test_set_name: [(1.0, (\"test\", \"all\"))],\n config.test_set_name2: [(1.0, (\"test\", \"all\"))],\n \"_default\": [(1.0, (\"train\", \"all\"))]\n }\n \n test_puzzles = {}\n results = {}\n\n total_puzzles = 0\n for subset_name in config.subsets:\n # Load all puzzles in this subset\n with open(f\"{config.input_file_prefix}_{subset_name}_challenges.json\", \"r\") as f:\n puzzles = json.load(f)\n\n sols_filename = f\"{config.input_file_prefix}_{subset_name}_solutions.json\"","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.load_puzzles_arcagi","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.load_puzzles_arcagi#L167-L222","kind":"function","name":"load_puzzles_arcagi","path":"dataset/build_arc_dataset.py","language":"python","start_line":167,"end_line":222,"context_start_line":147,"context_end_line":242,"code":" if h not in hashes:\n hashes.add(h)\n group.append(augmented)\n \n if len(group) >= aug_count + 1:\n break\n \n if len(group) < aug_count + 1:\n print (f\"[Puzzle {name}] augmentation not full, only {len(group)}\")\n\n # Append\n for dest in dests:\n # Convert the examples\n dest_split, dest_set = dest\n\n results.setdefault(dest_split, {})\n results[dest_split].setdefault(dest_set, [])\n results[dest_split][dest_set].append([converted[dest] for converted in group])\n\n\ndef load_puzzles_arcagi(config: DataProcessConfig):\n train_examples_dest = (\"train\", \"all\")\n test_examples_map = {\n config.test_set_name: [(1.0, (\"test\", \"all\"))],\n config.test_set_name2: [(1.0, (\"test\", \"all\"))],\n \"_default\": [(1.0, (\"train\", \"all\"))]\n }\n \n test_puzzles = {}\n results = {}\n\n total_puzzles = 0\n for subset_name in config.subsets:\n # Load all puzzles in this subset\n with open(f\"{config.input_file_prefix}_{subset_name}_challenges.json\", \"r\") as f:\n puzzles = json.load(f)\n\n sols_filename = f\"{config.input_file_prefix}_{subset_name}_solutions.json\"\n if os.path.isfile(sols_filename):\n with open(sols_filename, \"r\") as f:\n sols = json.load(f)\n \n for puzzle_id in puzzles.keys():\n for idx, sol_grid in enumerate(sols[puzzle_id]):\n puzzles[puzzle_id][\"test\"][idx][\"output\"] = sol_grid\n else:\n # Fill with dummy\n print (f\"{subset_name} solutions not found, filling with dummy\")\n\n for puzzle_id, puzzle in puzzles.items():\n for example in puzzle[\"test\"]:\n example.setdefault(\"output\", [[0]])\n\n # Shuffle puzzles\n puzzles = list(puzzles.items())\n np.random.shuffle(puzzles)\n \n # Assign by fraction\n for idx, (name, puzzle) in enumerate(puzzles):\n fraction = idx / len(puzzles)\n test_examples_dest = None\n for f, dest in test_examples_map.get(subset_name, test_examples_map[\"_default\"]):\n if fraction < f:\n test_examples_dest = dest\n break\n \n assert test_examples_dest is not None\n \n if test_examples_dest[0] == \"test\":\n test_puzzles[name] = puzzle\n \n convert_single_arc_puzzle(results, name, puzzle, config.num_aug, {\"train\": train_examples_dest, \"test\": test_examples_dest})\n total_puzzles += 1\n\n print (f\"Total puzzles: {total_puzzles}\")\n return results, test_puzzles\n\n\ndef convert_dataset(config: DataProcessConfig):\n np.random.seed(config.seed)\n \n # Read dataset\n data, test_puzzles = load_puzzles_arcagi(config)\n \n # Map global puzzle identifiers\n num_identifiers = config.puzzle_identifiers_start # 0 is blank, start at 1\n identifier_map = {}\n for split_name, split in data.items():\n for subset_name, subset in split.items():\n for group in subset:\n for puzzle in group:\n if puzzle.id not in identifier_map:\n identifier_map[puzzle.id] = num_identifiers\n num_identifiers += 1\n print (f\"Total puzzle IDs (including ): {num_identifiers}\")\n","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.convert_dataset","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.convert_dataset#L225-L320","kind":"function","name":"convert_dataset","path":"dataset/build_arc_dataset.py","language":"python","start_line":225,"end_line":320,"context_start_line":205,"context_end_line":340,"code":" for idx, (name, puzzle) in enumerate(puzzles):\n fraction = idx / len(puzzles)\n test_examples_dest = None\n for f, dest in test_examples_map.get(subset_name, test_examples_map[\"_default\"]):\n if fraction < f:\n test_examples_dest = dest\n break\n \n assert test_examples_dest is not None\n \n if test_examples_dest[0] == \"test\":\n test_puzzles[name] = puzzle\n \n convert_single_arc_puzzle(results, name, puzzle, config.num_aug, {\"train\": train_examples_dest, \"test\": test_examples_dest})\n total_puzzles += 1\n\n print (f\"Total puzzles: {total_puzzles}\")\n return results, test_puzzles\n\n\ndef convert_dataset(config: DataProcessConfig):\n np.random.seed(config.seed)\n \n # Read dataset\n data, test_puzzles = load_puzzles_arcagi(config)\n \n # Map global puzzle identifiers\n num_identifiers = config.puzzle_identifiers_start # 0 is blank, start at 1\n identifier_map = {}\n for split_name, split in data.items():\n for subset_name, subset in split.items():\n for group in subset:\n for puzzle in group:\n if puzzle.id not in identifier_map:\n identifier_map[puzzle.id] = num_identifiers\n num_identifiers += 1\n print (f\"Total puzzle IDs (including ): {num_identifiers}\")\n\n # Save\n for split_name, split in data.items():\n os.makedirs(os.path.join(config.output_dir, split_name), exist_ok=True)\n \n # Translational augmentations\n enable_translational_augment = split_name == \"train\"\n\n # Statistics\n total_examples = 0\n total_puzzles = 0\n total_groups = 0\n \n for subset_name, subset in split.items(): # \"all\" is the only subset\n # Construct subset\n results = {k: [] for k in [\"inputs\", \"labels\", \"puzzle_identifiers\", \"puzzle_indices\", \"group_indices\"]}\n results[\"puzzle_indices\"].append(0)\n results[\"group_indices\"].append(0)\n \n example_id = 0\n puzzle_id = 0\n \n for group in subset:\n for puzzle in group:\n # Push puzzle\n no_aug_id = np.random.randint(0, len(puzzle.examples))\n for _idx_ex, (inp, out) in enumerate(puzzle.examples):\n inp, out = np_grid_to_seq_translational_augment(inp, out, do_translation=enable_translational_augment and _idx_ex != no_aug_id)\n \n results[\"inputs\"].append(inp)\n results[\"labels\"].append(out)\n example_id += 1\n \n total_examples += 1\n\n results[\"puzzle_indices\"].append(example_id)\n results[\"puzzle_identifiers\"].append(identifier_map[puzzle.id])\n \n puzzle_id += 1\n total_puzzles += 1\n \n # Push group\n results[\"group_indices\"].append(puzzle_id)\n total_groups += 1\n \n for k, v in results.items():\n if k in {\"inputs\", \"labels\"}:\n v = np.stack(v, 0)\n else:\n v = np.array(v, dtype=np.int32)\n \n np.save(os.path.join(config.output_dir, split_name, f\"{subset_name}__{k}.npy\"), v)\n \n # Metadata\n metadata = PuzzleDatasetMetadata(\n seq_len=ARCMaxGridSize * ARCMaxGridSize,\n vocab_size=10 + 2, # PAD + EOS + \"0\" ... \"9\"\n pad_id=0,\n ignore_label_id=0,\n blank_identifier_id=0,\n num_puzzle_identifiers=num_identifiers,\n total_groups=total_groups,\n mean_puzzle_examples=total_examples / total_puzzles,\n total_puzzles=total_puzzles,\n sets=list(split.keys())\n )\n\n # Save metadata as JSON.\n with open(os.path.join(config.output_dir, split_name, \"dataset.json\"), \"w\") as f:\n json.dump(metadata.model_dump(), f)\n \n # Save IDs mapping\n with open(os.path.join(config.output_dir, \"identifiers.json\"), \"w\") as f:\n ids_mapping = {v: k for k, v in identifier_map.items()}\n json.dump([ids_mapping.get(i, \"\") for i in range(num_identifiers)], f)\n \n # Save Test Puzzles\n with open(os.path.join(config.output_dir, \"test_puzzles.json\"), \"w\") as f:\n json.dump(test_puzzles, f)\n\n\n@cli.command(singleton=True)\ndef main(config: DataProcessConfig):\n convert_dataset(config)\n\n\nif __name__ == \"__main__\":\n cli()\n\n\n\n\n\n\n\n\n\n\n","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset.main","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset.main#L324-L325","kind":"function","name":"main","path":"dataset/build_arc_dataset.py","language":"python","start_line":324,"end_line":325,"context_start_line":304,"context_end_line":341,"code":" mean_puzzle_examples=total_examples / total_puzzles,\n total_puzzles=total_puzzles,\n sets=list(split.keys())\n )\n\n # Save metadata as JSON.\n with open(os.path.join(config.output_dir, split_name, \"dataset.json\"), \"w\") as f:\n json.dump(metadata.model_dump(), f)\n \n # Save IDs mapping\n with open(os.path.join(config.output_dir, \"identifiers.json\"), \"w\") as f:\n ids_mapping = {v: k for k, v in identifier_map.items()}\n json.dump([ids_mapping.get(i, \"\") for i in range(num_identifiers)], f)\n \n # Save Test Puzzles\n with open(os.path.join(config.output_dir, \"test_puzzles.json\"), \"w\") as f:\n json.dump(test_puzzles, f)\n\n\n@cli.command(singleton=True)\ndef main(config: DataProcessConfig):\n convert_dataset(config)\n\n\nif __name__ == \"__main__\":\n cli()\n\n\n\n\n\n\n\n\n\n\n\n","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:dataset.build_arc_dataset._map_grid","uri":"program://TinyRecursiveModels/function/dataset.build_arc_dataset._map_grid#L120-L121","kind":"function","name":"_map_grid","path":"dataset/build_arc_dataset.py","language":"python","start_line":120,"end_line":121,"context_start_line":100,"context_end_line":141,"code":" trans_id = np.random.randint(0, 8)\n mapping = np.concatenate([np.arange(0, 1, dtype=np.uint8), np.random.permutation(np.arange(1, 10, dtype=np.uint8))]) # Permute colors, Excluding \"0\" (black)\n \n name_with_aug_repr = f\"{name}{PuzzleIdSeparator}t{trans_id}{PuzzleIdSeparator}{''.join(str(x) for x in mapping)}\"\n\n def _map_grid(grid: np.ndarray):\n return dihedral_transform(mapping[grid], trans_id)\n \n return name_with_aug_repr, _map_grid\n\n\ndef inverse_aug(name: str):\n # Inverse the \"aug\" function\n if PuzzleIdSeparator not in name:\n return name, lambda x: x\n\n trans_id, perm = name.split(PuzzleIdSeparator)[-2:]\n trans_id = int(trans_id[1:]) # Remove \"t\" letter\n inv_perm = np.argsort(list(perm)).astype(np.uint8)\n \n def _map_grid(grid: np.ndarray):\n return inv_perm[inverse_dihedral_transform(grid, trans_id)]\n \n return name.split(PuzzleIdSeparator)[0], _map_grid\n\n\ndef convert_single_arc_puzzle(results: dict, name: str, puzzle: dict, aug_count: int, dest_mapping: Dict[str, Tuple[str, str]]):\n # Convert\n dests = set(dest_mapping.values())\n converted = {dest: ARCPuzzle(name, []) for dest in dests}\n for example_type, examples in puzzle.items():\n # Map to target split\n dest = dest_mapping[example_type]\n converted[dest].examples.extend([(arc_grid_to_np(example[\"input\"]), arc_grid_to_np(example[\"output\"])) for example in examples])\n\n group = [converted]\n \n # Augment\n if aug_count > 0:\n hashes = {puzzle_hash(converted)}\n\n for _trial in range(ARCAugmentRetriesFactor * aug_count):","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:evaluators.arc","uri":"program://TinyRecursiveModels/module/evaluators.arc#L1-L177","kind":"module","name":"evaluators.arc","path":"evaluators/arc.py","language":"python","start_line":1,"end_line":177,"context_start_line":1,"context_end_line":177,"code":"from typing import Dict, Sequence, Optional\nimport os\nimport json\n\nimport torch\nimport numpy as np\nfrom numba import njit\nimport torch.distributed as dist\n\nfrom dataset.build_arc_dataset import inverse_aug, grid_hash, arc_grid_to_np\nfrom dataset.common import PuzzleDatasetMetadata\n\n@njit\ndef _crop(grid: np.ndarray):\n \"\"\"Find maximum-sized rectangle without any EOS token inside. \"\"\"\n grid = grid.reshape(30, 30)\n\n max_area = 0\n max_size = (0, 0)\n nr, nc = grid.shape\n \n num_c = nc\n for num_r in range(1, nr + 1):\n # Scan for maximum c\n for c in range(1, num_c + 1):\n x = grid[num_r - 1, c - 1]\n if (x < 2) | (x > 11):\n num_c = c - 1\n break\n \n area = num_r * num_c\n if area > max_area:\n max_area = area\n max_size = (num_r, num_c)\n\n return (grid[:max_size[0], :max_size[1]] - 2).astype(np.uint8)\n\n\nclass ARC:\n required_outputs = {\"inputs\", \"puzzle_identifiers\", \"q_halt_logits\", \"preds\"}\n \n def __init__(self, data_path: str, \n eval_metadata: PuzzleDatasetMetadata, \n submission_K: int = 2, \n pass_Ks: Sequence[int] = (1, 2, 5, 10, 100, 1000), \n aggregated_voting: bool = True):\n super().__init__()\n self.pass_Ks = pass_Ks\n self.submission_K = submission_K\n self.aggregated_voting = aggregated_voting\n self.blank_identifier_id = eval_metadata.blank_identifier_id\n\n # Load identifiers and test puzzles\n with open(os.path.join(data_path, \"identifiers.json\"), \"r\") as f:\n self.identifier_map = json.load(f)\n with open(os.path.join(data_path, \"test_puzzles.json\"), \"r\") as f:\n self.test_puzzles = json.load(f)\n \n # States\n self._local_hmap = {}\n self._local_preds = {}\n \n def begin_eval(self):\n if not self.aggregated_voting:\n # Clear previous predictions\n self._local_hmap = {}\n self._local_preds = {}\n \n def update_batch(self, batch: Dict[str, torch.Tensor], preds: Dict[str, torch.Tensor]):\n # Collect required outputs to CPU\n outputs = {}\n q_values = None\n\n for collection in (batch, preds):\n for k, v in collection.items():\n if k in self.required_outputs:\n if k == \"q_halt_logits\":\n q_values = v.to(torch.float64).sigmoid().cpu()\n else:\n outputs[k] = v.cpu()\n \n assert q_values is not None\n\n # Remove padding from outputs\n mask = outputs[\"puzzle_identifiers\"] != self.blank_identifier_id\n outputs = {k: v[mask] for k, v in outputs.items()}\n\n # Get predictions\n for identifier, input, pred, q in zip(outputs[\"puzzle_identifiers\"].numpy(), outputs[\"inputs\"].numpy(), outputs[\"preds\"].numpy(), q_values.numpy()):\n name = self.identifier_map[identifier]\n orig_name, _inverse_fn = inverse_aug(name)\n \n input_hash = grid_hash(_inverse_fn(_crop(input)))\n \n pred = _inverse_fn(_crop(pred))\n assert np.all((pred >= 0) & (pred <= 9)), f\"Puzzle {name}'s prediction out of 0-9 range.\" # Sanity check\n\n # Store into local state\n pred_hash = grid_hash(pred)\n\n self._local_hmap[pred_hash] = pred\n \n self._local_preds.setdefault(orig_name, {})\n self._local_preds[orig_name].setdefault(input_hash, [])\n self._local_preds[orig_name][input_hash].append((pred_hash, float(q)))\n \n def result(self, save_path: Optional[str], rank: int, world_size: int, group: Optional[torch.distributed.ProcessGroup] = None) -> Optional[Dict[str, float]]:\n # Gather predictions to rank 0 for voting\n global_hmap_preds = [None for _ in range(world_size)] if rank == 0 else None\n dist.gather_object((self._local_hmap, self._local_preds), global_hmap_preds, dst=0, group=group)\n \n # Rank 0 logic\n if rank != 0:\n return\n\n submission = {}\n correct = [0.0 for _ in range(len(self.pass_Ks))]\n\n for name, puzzle in self.test_puzzles.items():\n # Process test examples in this puzzle\n submission[name] = []\n num_test_correct = [0 for _ in range(len(self.pass_Ks))]\n for pair in puzzle[\"test\"]:\n input_hash = grid_hash(arc_grid_to_np(pair[\"input\"]))\n label_hash = grid_hash(arc_grid_to_np(pair[\"output\"]))\n \n p_map = {}\n for hmap, preds in global_hmap_preds: # type: ignore\n for h, q in preds.get(name, {}).get(input_hash, {}):\n p_map.setdefault(h, [0, 0])\n p_map[h][0] += 1\n p_map[h][1] += q\n \n if not len(p_map):\n print (f\"Puzzle {name} has no predictions.\")\n continue\n\n for h, stats in p_map.items():\n stats[1] /= stats[0]\n \n p_map = sorted(p_map.items(), key=lambda kv: kv[1], reverse=True)\n\n # vote for different Ks\n for i, k in enumerate(self.pass_Ks):\n ok = False\n for h, stats in p_map[:k]:\n ok |= h == label_hash\n \n num_test_correct[i] += ok\n \n # Query grids\n pred_grids = []\n for h, stats in p_map[:self.submission_K]:\n for hmap, preds in global_hmap_preds: # type: ignore\n if h in hmap:\n pred_grids.append(hmap[h])\n break\n \n # Pad to K\n while len(pred_grids) < self.submission_K:\n pred_grids.append(pred_grids[0])\n \n submission[name].append({f\"attempt_{i + 1}\": grid.tolist() for i, grid in enumerate(pred_grids)})\n\n # Total correctness\n for i in range(len(self.pass_Ks)):\n correct[i] += num_test_correct[i] / len(puzzle[\"test\"])\n\n # Save submission\n if save_path is not None:\n with open(os.path.join(save_path, \"submission.json\"), \"w\") as f:\n json.dump(submission, f)\n\n # Final result\n all_results = {f\"ARC/pass@{k}\": correct[i] / len(self.test_puzzles) for i, k in enumerate(self.pass_Ks)}\n\n return all_results","source_hash":"d776f96f68091658c24b87aff80b43e54664216a883c1bd99614f008a6dd87d4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:evaluators.arc._crop","uri":"program://TinyRecursiveModels/function/evaluators.arc._crop#L14-L36","kind":"function","name":"_crop","path":"evaluators/arc.py","language":"python","start_line":14,"end_line":36,"context_start_line":1,"context_end_line":56,"code":"from typing import Dict, Sequence, Optional\nimport os\nimport json\n\nimport torch\nimport numpy as np\nfrom numba import njit\nimport torch.distributed as dist\n\nfrom dataset.build_arc_dataset import inverse_aug, grid_hash, arc_grid_to_np\nfrom dataset.common import PuzzleDatasetMetadata\n\n@njit\ndef _crop(grid: np.ndarray):\n \"\"\"Find maximum-sized rectangle without any EOS token inside. \"\"\"\n grid = grid.reshape(30, 30)\n\n max_area = 0\n max_size = (0, 0)\n nr, nc = grid.shape\n \n num_c = nc\n for num_r in range(1, nr + 1):\n # Scan for maximum c\n for c in range(1, num_c + 1):\n x = grid[num_r - 1, c - 1]\n if (x < 2) | (x > 11):\n num_c = c - 1\n break\n \n area = num_r * num_c\n if area > max_area:\n max_area = area\n max_size = (num_r, num_c)\n\n return (grid[:max_size[0], :max_size[1]] - 2).astype(np.uint8)\n\n\nclass ARC:\n required_outputs = {\"inputs\", \"puzzle_identifiers\", \"q_halt_logits\", \"preds\"}\n \n def __init__(self, data_path: str, \n eval_metadata: PuzzleDatasetMetadata, \n submission_K: int = 2, \n pass_Ks: Sequence[int] = (1, 2, 5, 10, 100, 1000), \n aggregated_voting: bool = True):\n super().__init__()\n self.pass_Ks = pass_Ks\n self.submission_K = submission_K\n self.aggregated_voting = aggregated_voting\n self.blank_identifier_id = eval_metadata.blank_identifier_id\n\n # Load identifiers and test puzzles\n with open(os.path.join(data_path, \"identifiers.json\"), \"r\") as f:\n self.identifier_map = json.load(f)\n with open(os.path.join(data_path, \"test_puzzles.json\"), \"r\") as f:","source_hash":"d776f96f68091658c24b87aff80b43e54664216a883c1bd99614f008a6dd87d4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:evaluators.arc.ARC","uri":"program://TinyRecursiveModels/class/evaluators.arc.ARC#L39-L177","kind":"class","name":"ARC","path":"evaluators/arc.py","language":"python","start_line":39,"end_line":177,"context_start_line":19,"context_end_line":177,"code":" max_size = (0, 0)\n nr, nc = grid.shape\n \n num_c = nc\n for num_r in range(1, nr + 1):\n # Scan for maximum c\n for c in range(1, num_c + 1):\n x = grid[num_r - 1, c - 1]\n if (x < 2) | (x > 11):\n num_c = c - 1\n break\n \n area = num_r * num_c\n if area > max_area:\n max_area = area\n max_size = (num_r, num_c)\n\n return (grid[:max_size[0], :max_size[1]] - 2).astype(np.uint8)\n\n\nclass ARC:\n required_outputs = {\"inputs\", \"puzzle_identifiers\", \"q_halt_logits\", \"preds\"}\n \n def __init__(self, data_path: str, \n eval_metadata: PuzzleDatasetMetadata, \n submission_K: int = 2, \n pass_Ks: Sequence[int] = (1, 2, 5, 10, 100, 1000), \n aggregated_voting: bool = True):\n super().__init__()\n self.pass_Ks = pass_Ks\n self.submission_K = submission_K\n self.aggregated_voting = aggregated_voting\n self.blank_identifier_id = eval_metadata.blank_identifier_id\n\n # Load identifiers and test puzzles\n with open(os.path.join(data_path, \"identifiers.json\"), \"r\") as f:\n self.identifier_map = json.load(f)\n with open(os.path.join(data_path, \"test_puzzles.json\"), \"r\") as f:\n self.test_puzzles = json.load(f)\n \n # States\n self._local_hmap = {}\n self._local_preds = {}\n \n def begin_eval(self):\n if not self.aggregated_voting:\n # Clear previous predictions\n self._local_hmap = {}\n self._local_preds = {}\n \n def update_batch(self, batch: Dict[str, torch.Tensor], preds: Dict[str, torch.Tensor]):\n # Collect required outputs to CPU\n outputs = {}\n q_values = None\n\n for collection in (batch, preds):\n for k, v in collection.items():\n if k in self.required_outputs:\n if k == \"q_halt_logits\":\n q_values = v.to(torch.float64).sigmoid().cpu()\n else:\n outputs[k] = v.cpu()\n \n assert q_values is not None\n\n # Remove padding from outputs\n mask = outputs[\"puzzle_identifiers\"] != self.blank_identifier_id\n outputs = {k: v[mask] for k, v in outputs.items()}\n\n # Get predictions\n for identifier, input, pred, q in zip(outputs[\"puzzle_identifiers\"].numpy(), outputs[\"inputs\"].numpy(), outputs[\"preds\"].numpy(), q_values.numpy()):\n name = self.identifier_map[identifier]\n orig_name, _inverse_fn = inverse_aug(name)\n \n input_hash = grid_hash(_inverse_fn(_crop(input)))\n \n pred = _inverse_fn(_crop(pred))\n assert np.all((pred >= 0) & (pred <= 9)), f\"Puzzle {name}'s prediction out of 0-9 range.\" # Sanity check\n\n # Store into local state\n pred_hash = grid_hash(pred)\n\n self._local_hmap[pred_hash] = pred\n \n self._local_preds.setdefault(orig_name, {})\n self._local_preds[orig_name].setdefault(input_hash, [])\n self._local_preds[orig_name][input_hash].append((pred_hash, float(q)))\n \n def result(self, save_path: Optional[str], rank: int, world_size: int, group: Optional[torch.distributed.ProcessGroup] = None) -> Optional[Dict[str, float]]:\n # Gather predictions to rank 0 for voting\n global_hmap_preds = [None for _ in range(world_size)] if rank == 0 else None\n dist.gather_object((self._local_hmap, self._local_preds), global_hmap_preds, dst=0, group=group)\n \n # Rank 0 logic\n if rank != 0:\n return\n\n submission = {}\n correct = [0.0 for _ in range(len(self.pass_Ks))]\n\n for name, puzzle in self.test_puzzles.items():\n # Process test examples in this puzzle\n submission[name] = []\n num_test_correct = [0 for _ in range(len(self.pass_Ks))]\n for pair in puzzle[\"test\"]:\n input_hash = grid_hash(arc_grid_to_np(pair[\"input\"]))\n label_hash = grid_hash(arc_grid_to_np(pair[\"output\"]))\n \n p_map = {}\n for hmap, preds in global_hmap_preds: # type: ignore\n for h, q in preds.get(name, {}).get(input_hash, {}):\n p_map.setdefault(h, [0, 0])\n p_map[h][0] += 1\n p_map[h][1] += q\n \n if not len(p_map):\n print (f\"Puzzle {name} has no predictions.\")\n continue\n\n for h, stats in p_map.items():\n stats[1] /= stats[0]\n \n p_map = sorted(p_map.items(), key=lambda kv: kv[1], reverse=True)\n\n # vote for different Ks\n for i, k in enumerate(self.pass_Ks):\n ok = False\n for h, stats in p_map[:k]:\n ok |= h == label_hash\n \n num_test_correct[i] += ok\n \n # Query grids\n pred_grids = []\n for h, stats in p_map[:self.submission_K]:\n for hmap, preds in global_hmap_preds: # type: ignore\n if h in hmap:\n pred_grids.append(hmap[h])\n break\n \n # Pad to K\n while len(pred_grids) < self.submission_K:\n pred_grids.append(pred_grids[0])\n \n submission[name].append({f\"attempt_{i + 1}\": grid.tolist() for i, grid in enumerate(pred_grids)})\n\n # Total correctness\n for i in range(len(self.pass_Ks)):\n correct[i] += num_test_correct[i] / len(puzzle[\"test\"])\n\n # Save submission\n if save_path is not None:\n with open(os.path.join(save_path, \"submission.json\"), \"w\") as f:\n json.dump(submission, f)\n\n # Final result\n all_results = {f\"ARC/pass@{k}\": correct[i] / len(self.test_puzzles) for i, k in enumerate(self.pass_Ks)}\n\n return all_results","source_hash":"d776f96f68091658c24b87aff80b43e54664216a883c1bd99614f008a6dd87d4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:evaluators.arc.__init__","uri":"program://TinyRecursiveModels/function/evaluators.arc.__init__#L42-L61","kind":"function","name":"__init__","path":"evaluators/arc.py","language":"python","start_line":42,"end_line":61,"context_start_line":22,"context_end_line":81,"code":" num_c = nc\n for num_r in range(1, nr + 1):\n # Scan for maximum c\n for c in range(1, num_c + 1):\n x = grid[num_r - 1, c - 1]\n if (x < 2) | (x > 11):\n num_c = c - 1\n break\n \n area = num_r * num_c\n if area > max_area:\n max_area = area\n max_size = (num_r, num_c)\n\n return (grid[:max_size[0], :max_size[1]] - 2).astype(np.uint8)\n\n\nclass ARC:\n required_outputs = {\"inputs\", \"puzzle_identifiers\", \"q_halt_logits\", \"preds\"}\n \n def __init__(self, data_path: str, \n eval_metadata: PuzzleDatasetMetadata, \n submission_K: int = 2, \n pass_Ks: Sequence[int] = (1, 2, 5, 10, 100, 1000), \n aggregated_voting: bool = True):\n super().__init__()\n self.pass_Ks = pass_Ks\n self.submission_K = submission_K\n self.aggregated_voting = aggregated_voting\n self.blank_identifier_id = eval_metadata.blank_identifier_id\n\n # Load identifiers and test puzzles\n with open(os.path.join(data_path, \"identifiers.json\"), \"r\") as f:\n self.identifier_map = json.load(f)\n with open(os.path.join(data_path, \"test_puzzles.json\"), \"r\") as f:\n self.test_puzzles = json.load(f)\n \n # States\n self._local_hmap = {}\n self._local_preds = {}\n \n def begin_eval(self):\n if not self.aggregated_voting:\n # Clear previous predictions\n self._local_hmap = {}\n self._local_preds = {}\n \n def update_batch(self, batch: Dict[str, torch.Tensor], preds: Dict[str, torch.Tensor]):\n # Collect required outputs to CPU\n outputs = {}\n q_values = None\n\n for collection in (batch, preds):\n for k, v in collection.items():\n if k in self.required_outputs:\n if k == \"q_halt_logits\":\n q_values = v.to(torch.float64).sigmoid().cpu()\n else:\n outputs[k] = v.cpu()\n ","source_hash":"d776f96f68091658c24b87aff80b43e54664216a883c1bd99614f008a6dd87d4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:evaluators.arc.begin_eval","uri":"program://TinyRecursiveModels/function/evaluators.arc.begin_eval#L63-L67","kind":"function","name":"begin_eval","path":"evaluators/arc.py","language":"python","start_line":63,"end_line":67,"context_start_line":43,"context_end_line":87,"code":" eval_metadata: PuzzleDatasetMetadata, \n submission_K: int = 2, \n pass_Ks: Sequence[int] = (1, 2, 5, 10, 100, 1000), \n aggregated_voting: bool = True):\n super().__init__()\n self.pass_Ks = pass_Ks\n self.submission_K = submission_K\n self.aggregated_voting = aggregated_voting\n self.blank_identifier_id = eval_metadata.blank_identifier_id\n\n # Load identifiers and test puzzles\n with open(os.path.join(data_path, \"identifiers.json\"), \"r\") as f:\n self.identifier_map = json.load(f)\n with open(os.path.join(data_path, \"test_puzzles.json\"), \"r\") as f:\n self.test_puzzles = json.load(f)\n \n # States\n self._local_hmap = {}\n self._local_preds = {}\n \n def begin_eval(self):\n if not self.aggregated_voting:\n # Clear previous predictions\n self._local_hmap = {}\n self._local_preds = {}\n \n def update_batch(self, batch: Dict[str, torch.Tensor], preds: Dict[str, torch.Tensor]):\n # Collect required outputs to CPU\n outputs = {}\n q_values = None\n\n for collection in (batch, preds):\n for k, v in collection.items():\n if k in self.required_outputs:\n if k == \"q_halt_logits\":\n q_values = v.to(torch.float64).sigmoid().cpu()\n else:\n outputs[k] = v.cpu()\n \n assert q_values is not None\n\n # Remove padding from outputs\n mask = outputs[\"puzzle_identifiers\"] != self.blank_identifier_id\n outputs = {k: v[mask] for k, v in outputs.items()}\n","source_hash":"d776f96f68091658c24b87aff80b43e54664216a883c1bd99614f008a6dd87d4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:evaluators.arc.update_batch","uri":"program://TinyRecursiveModels/function/evaluators.arc.update_batch#L69-L105","kind":"function","name":"update_batch","path":"evaluators/arc.py","language":"python","start_line":69,"end_line":105,"context_start_line":49,"context_end_line":125,"code":" self.submission_K = submission_K\n self.aggregated_voting = aggregated_voting\n self.blank_identifier_id = eval_metadata.blank_identifier_id\n\n # Load identifiers and test puzzles\n with open(os.path.join(data_path, \"identifiers.json\"), \"r\") as f:\n self.identifier_map = json.load(f)\n with open(os.path.join(data_path, \"test_puzzles.json\"), \"r\") as f:\n self.test_puzzles = json.load(f)\n \n # States\n self._local_hmap = {}\n self._local_preds = {}\n \n def begin_eval(self):\n if not self.aggregated_voting:\n # Clear previous predictions\n self._local_hmap = {}\n self._local_preds = {}\n \n def update_batch(self, batch: Dict[str, torch.Tensor], preds: Dict[str, torch.Tensor]):\n # Collect required outputs to CPU\n outputs = {}\n q_values = None\n\n for collection in (batch, preds):\n for k, v in collection.items():\n if k in self.required_outputs:\n if k == \"q_halt_logits\":\n q_values = v.to(torch.float64).sigmoid().cpu()\n else:\n outputs[k] = v.cpu()\n \n assert q_values is not None\n\n # Remove padding from outputs\n mask = outputs[\"puzzle_identifiers\"] != self.blank_identifier_id\n outputs = {k: v[mask] for k, v in outputs.items()}\n\n # Get predictions\n for identifier, input, pred, q in zip(outputs[\"puzzle_identifiers\"].numpy(), outputs[\"inputs\"].numpy(), outputs[\"preds\"].numpy(), q_values.numpy()):\n name = self.identifier_map[identifier]\n orig_name, _inverse_fn = inverse_aug(name)\n \n input_hash = grid_hash(_inverse_fn(_crop(input)))\n \n pred = _inverse_fn(_crop(pred))\n assert np.all((pred >= 0) & (pred <= 9)), f\"Puzzle {name}'s prediction out of 0-9 range.\" # Sanity check\n\n # Store into local state\n pred_hash = grid_hash(pred)\n\n self._local_hmap[pred_hash] = pred\n \n self._local_preds.setdefault(orig_name, {})\n self._local_preds[orig_name].setdefault(input_hash, [])\n self._local_preds[orig_name][input_hash].append((pred_hash, float(q)))\n \n def result(self, save_path: Optional[str], rank: int, world_size: int, group: Optional[torch.distributed.ProcessGroup] = None) -> Optional[Dict[str, float]]:\n # Gather predictions to rank 0 for voting\n global_hmap_preds = [None for _ in range(world_size)] if rank == 0 else None\n dist.gather_object((self._local_hmap, self._local_preds), global_hmap_preds, dst=0, group=group)\n \n # Rank 0 logic\n if rank != 0:\n return\n\n submission = {}\n correct = [0.0 for _ in range(len(self.pass_Ks))]\n\n for name, puzzle in self.test_puzzles.items():\n # Process test examples in this puzzle\n submission[name] = []\n num_test_correct = [0 for _ in range(len(self.pass_Ks))]\n for pair in puzzle[\"test\"]:\n input_hash = grid_hash(arc_grid_to_np(pair[\"input\"]))\n label_hash = grid_hash(arc_grid_to_np(pair[\"output\"]))","source_hash":"d776f96f68091658c24b87aff80b43e54664216a883c1bd99614f008a6dd87d4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"py:evaluators.arc.result","uri":"program://TinyRecursiveModels/function/evaluators.arc.result#L107-L177","kind":"function","name":"result","path":"evaluators/arc.py","language":"python","start_line":107,"end_line":177,"context_start_line":87,"context_end_line":177,"code":"\n # Get predictions\n for identifier, input, pred, q in zip(outputs[\"puzzle_identifiers\"].numpy(), outputs[\"inputs\"].numpy(), outputs[\"preds\"].numpy(), q_values.numpy()):\n name = self.identifier_map[identifier]\n orig_name, _inverse_fn = inverse_aug(name)\n \n input_hash = grid_hash(_inverse_fn(_crop(input)))\n \n pred = _inverse_fn(_crop(pred))\n assert np.all((pred >= 0) & (pred <= 9)), f\"Puzzle {name}'s prediction out of 0-9 range.\" # Sanity check\n\n # Store into local state\n pred_hash = grid_hash(pred)\n\n self._local_hmap[pred_hash] = pred\n \n self._local_preds.setdefault(orig_name, {})\n self._local_preds[orig_name].setdefault(input_hash, [])\n self._local_preds[orig_name][input_hash].append((pred_hash, float(q)))\n \n def result(self, save_path: Optional[str], rank: int, world_size: int, group: Optional[torch.distributed.ProcessGroup] = None) -> Optional[Dict[str, float]]:\n # Gather predictions to rank 0 for voting\n global_hmap_preds = [None for _ in range(world_size)] if rank == 0 else None\n dist.gather_object((self._local_hmap, self._local_preds), global_hmap_preds, dst=0, group=group)\n \n # Rank 0 logic\n if rank != 0:\n return\n\n submission = {}\n correct = [0.0 for _ in range(len(self.pass_Ks))]\n\n for name, puzzle in self.test_puzzles.items():\n # Process test examples in this puzzle\n submission[name] = []\n num_test_correct = [0 for _ in range(len(self.pass_Ks))]\n for pair in puzzle[\"test\"]:\n input_hash = grid_hash(arc_grid_to_np(pair[\"input\"]))\n label_hash = grid_hash(arc_grid_to_np(pair[\"output\"]))\n \n p_map = {}\n for hmap, preds in global_hmap_preds: # type: ignore\n for h, q in preds.get(name, {}).get(input_hash, {}):\n p_map.setdefault(h, [0, 0])\n p_map[h][0] += 1\n p_map[h][1] += q\n \n if not len(p_map):\n print (f\"Puzzle {name} has no predictions.\")\n continue\n\n for h, stats in p_map.items():\n stats[1] /= stats[0]\n \n p_map = sorted(p_map.items(), key=lambda kv: kv[1], reverse=True)\n\n # vote for different Ks\n for i, k in enumerate(self.pass_Ks):\n ok = False\n for h, stats in p_map[:k]:\n ok |= h == label_hash\n \n num_test_correct[i] += ok\n \n # Query grids\n pred_grids = []\n for h, stats in p_map[:self.submission_K]:\n for hmap, preds in global_hmap_preds: # type: ignore\n if h in hmap:\n pred_grids.append(hmap[h])\n break\n \n # Pad to K\n while len(pred_grids) < self.submission_K:\n pred_grids.append(pred_grids[0])\n \n submission[name].append({f\"attempt_{i + 1}\": grid.tolist() for i, grid in enumerate(pred_grids)})\n\n # Total correctness\n for i in range(len(self.pass_Ks)):\n correct[i] += num_test_correct[i] / len(puzzle[\"test\"])\n\n # Save submission\n if save_path is not None:\n with open(os.path.join(save_path, \"submission.json\"), \"w\") as f:\n json.dump(submission, f)\n\n # Final result\n all_results = {f\"ARC/pass@{k}\": correct[i] / len(self.test_puzzles) for i, k in enumerate(self.pass_Ks)}\n\n return all_results","source_hash":"d776f96f68091658c24b87aff80b43e54664216a883c1bd99614f008a6dd87d4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:pretrain.py","uri":"program://TinyRecursiveModels/file/pretrain.py","kind":"file","name":"pretrain.py","path":"pretrain.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Optional, Any, Sequence, List\nfrom dataclasses import dataclass\nimport os\nimport math\nimport yaml\nimport shutil\nimport copy\n\nimport torch\nimport torch.distributed as dist\nfrom torch import nn\nfrom torch.utils.data import DataLoader\n\nimport tqdm\nimport wandb\nimport coolname\nimport hydra\nimport pydantic\nfrom omegaconf import DictConfig\nfrom adam_atan2 import AdamATan2\n","source_hash":"5184b37a979e16bc65f60016eb2b084f71d966673451176a9155db866955244d","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:puzzle_dataset.py","uri":"program://TinyRecursiveModels/file/puzzle_dataset.py","kind":"file","name":"puzzle_dataset.py","path":"puzzle_dataset.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import os\nimport json\nfrom typing import Tuple, List, Dict, Optional\nimport numpy as np\nimport pydantic\n\nimport torch\nfrom torch.utils.data import IterableDataset, get_worker_info\n\nfrom models.losses import IGNORE_LABEL_ID\nfrom dataset.common import PuzzleDatasetMetadata\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\n\ndef _sample_batch(rng: np.random.Generator, group_order: np.ndarray, puzzle_indices: np.ndarray, group_indices: np.ndarray, start_index: int, global_batch_size: int):\n # Pack examples into a full batch\n batch = []\n batch_puzzle_indices = []\n current_size = 0\n","source_hash":"2da1c939f424abcf06aa11a989373adf01529755ce63a5bb31402173704341ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/common.py","uri":"program://TinyRecursiveModels/file/models/common.py","kind":"file","name":"models/common.py","path":"models/common.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import math\n\nimport torch\nfrom torch import nn\n\n\ndef trunc_normal_init_(tensor: torch.Tensor, std: float = 1.0, lower: float = -2.0, upper: float = 2.0):\n # NOTE: PyTorch nn.init.trunc_normal_ is not mathematically correct, the std dev is not actually the std dev of initialized tensor\n # This function is a PyTorch version of jax truncated normal init (default init method in flax)\n # https://github.com/jax-ml/jax/blob/main/jax/_src/random.py#L807-L848\n # https://github.com/jax-ml/jax/blob/main/jax/_src/nn/initializers.py#L162-L199\n\n with torch.no_grad():\n if std == 0:\n tensor.zero_()\n else:\n sqrt2 = math.sqrt(2)\n a = math.erf(lower / sqrt2)\n b = math.erf(upper / sqrt2)\n z = (b - a) / 2\n","source_hash":"fa749ad9b68ac0852f9cda157baa3a9c2ff8abaee973751b32b7cd010a4cf859","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/losses.py","uri":"program://TinyRecursiveModels/file/models/losses.py","kind":"file","name":"models/losses.py","path":"models/losses.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Any, Tuple, Dict, Sequence, Optional\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nimport math\n\nIGNORE_LABEL_ID = -100\n\n\ndef s(x, epsilon=1e-30):\n return torch.where(\n x<0,\n 1/(1-x+ epsilon),\n x + 1\n )\n\n\ndef log_stablemax(x, dim=-1):\n s_x = s(x)\n return torch.log(s_x/torch.sum(s_x, dim=dim, keepdim=True))","source_hash":"1fa6d4af0f4554a3fb2009d1a11d80c50abab9710453995785093b5c355596c3","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/layers.py","uri":"program://TinyRecursiveModels/file/models/layers.py","kind":"file","name":"models/layers.py","path":"models/layers.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Tuple\nimport einops\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\n\n#try:\n# from flash_attn_interface import flash_attn_func # type: ignore[import]\n#except ImportError:\n# # Fallback to FlashAttention 2\n# from flash_attn import flash_attn_func # type: ignore[import]\nfrom torch.nn.functional import scaled_dot_product_attention\n\nfrom models.common import trunc_normal_init_\n\n\nCosSin = Tuple[torch.Tensor, torch.Tensor]\n\n\ndef _find_multiple(a, b):\n return (-(a // -b)) * b","source_hash":"e206dca55cc9f864e059b79941805fef73d620bed69b410ac2b1cfb3a963232c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/ema.py","uri":"program://TinyRecursiveModels/file/models/ema.py","kind":"file","name":"models/ema.py","path":"models/ema.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import copy\nimport torch.nn as nn\n\nclass EMAHelper(object):\n def __init__(self, mu=0.999):\n self.mu = mu\n self.shadow = {}\n\n def register(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name] = param.data.clone()\n\n def update(self, module):\n if isinstance(module, nn.DataParallel):\n module = module.module\n for name, param in module.named_parameters():\n if param.requires_grad:\n self.shadow[name].data = (1. - self.mu) * param.data + self.mu * self.shadow[name].data","source_hash":"10f4dcbcda44dc044e51aeefa1344cc06e89b42c9d782d012dc018310e98c609","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/sparse_embedding.py","uri":"program://TinyRecursiveModels/file/models/sparse_embedding.py","kind":"file","name":"models/sparse_embedding.py","path":"models/sparse_embedding.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Union\n\nimport torch\nfrom torch import nn\nimport torch.distributed as dist\nfrom torch.optim.optimizer import Optimizer, ParamsT\n\nfrom models.common import trunc_normal_init_\n\n\nclass CastedSparseEmbedding(nn.Module):\n def __init__(self, num_embeddings: int, embedding_dim: int, batch_size: int, init_std: float, cast_to: torch.dtype):\n super().__init__()\n self.cast_to = cast_to\n\n # Real Weights\n # Truncated LeCun normal init\n self.weights = nn.Buffer(\n trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std), persistent=True\n )\n","source_hash":"9429742ce022918751331acf92c1a9b8d0f2f364e9acef5d71fb81b886c7a2d0","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/recursive_reasoning/trm.py","uri":"program://TinyRecursiveModels/file/models/recursive_reasoning/trm.py","kind":"file","name":"models/recursive_reasoning/trm.py","path":"models/recursive_reasoning/trm.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n","source_hash":"3454818b64a1abb45c062782d380aa4bb560e2cb35db9cc309cf367ca3ac262c","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/recursive_reasoning/trm_hier6.py","uri":"program://TinyRecursiveModels/file/models/recursive_reasoning/trm_hier6.py","kind":"file","name":"models/recursive_reasoning/trm_hier6.py","path":"models/recursive_reasoning/trm_hier6.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L1: torch.Tensor\n z_L2: torch.Tensor\n z_L3: torch.Tensor","source_hash":"a39e104baa45f9519b281e6aea10c70f1b8f2578af6657ed0aa0664fb8e1d4ca","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/recursive_reasoning/hrm.py","uri":"program://TinyRecursiveModels/file/models/recursive_reasoning/hrm.py","kind":"file","name":"models/recursive_reasoning/hrm.py","path":"models/recursive_reasoning/hrm.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\n\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1InnerCarry:\n z_H: torch.Tensor\n z_L: torch.Tensor\n\n\n@dataclass\nclass HierarchicalReasoningModel_ACTV1Carry:\n inner_carry: HierarchicalReasoningModel_ACTV1InnerCarry","source_hash":"eb9e27416b95de989a52bf766230c090506b60cca2517e452fdc7db5d95af459","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/recursive_reasoning/transformers_baseline.py","uri":"program://TinyRecursiveModels/file/models/recursive_reasoning/transformers_baseline.py","kind":"file","name":"models/recursive_reasoning/transformers_baseline.py","path":"models/recursive_reasoning/transformers_baseline.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"\"\"\"\nHRM ACT V2: Transformer Baseline for Architecture Ablation\n\nThis is an architecture ablation of the Hierarchical Reasoning Model (HRM).\nKey changes from V1:\n1. REMOVED hierarchical split (no separate H and L levels)\n2. REMOVED inner cycles (no H_cycles/L_cycles loops within reasoning)\n3. KEPT ACT outer loop structure intact\n4. KEPT all data preprocessing, embeddings, and evaluation infrastructure\n\nArchitecture: Single-level transformer that processes the full 30x30 grid as a\n900-token sequence, with the same positional encodings and sparse embeddings as V1.\n\n\"\"\"\n\nfrom typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\n\nimport torch\nimport torch.nn.functional as F","source_hash":"b720059b622ffd55ddb68b7120ae8dc3738a2129819c149e989ee14b441c45f9","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:models/recursive_reasoning/trm_singlez.py","uri":"program://TinyRecursiveModels/file/models/recursive_reasoning/trm_singlez.py","kind":"file","name":"models/recursive_reasoning/trm_singlez.py","path":"models/recursive_reasoning/trm_singlez.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Tuple, List, Dict, Optional\nfrom dataclasses import dataclass\nimport math\nimport torch\nimport copy\nimport torch.nn.functional as F\nfrom torch import nn\nfrom pydantic import BaseModel\nimport random\nfrom models.common import trunc_normal_init_\nfrom models.layers import rms_norm, LinearSwish, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear\nfrom models.sparse_embedding import CastedSparseEmbedding\n\nIGNORE_LABEL_ID = -100\n\n@dataclass\nclass TinyRecursiveReasoningModel_ACTV1InnerCarry:\n z_L: torch.Tensor\n\n\n","source_hash":"5f52e879b7b9fa84e52fc4b3100805f044132654a934d6b860fc5dc111dbda85","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:utils/functions.py","uri":"program://TinyRecursiveModels/file/utils/functions.py","kind":"file","name":"utils/functions.py","path":"utils/functions.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":19,"code":"import importlib\nimport inspect\n\n\ndef load_model_class(identifier: str, prefix: str = \"models.\"):\n module_path, class_name = identifier.split('@')\n\n # Import the module\n module = importlib.import_module(prefix + module_path)\n cls = getattr(module, class_name)\n \n return cls\n\n\ndef get_model_source_path(identifier: str, prefix: str = \"models.\"):\n module_path, class_name = identifier.split('@')\n\n module = importlib.import_module(prefix + module_path)\n return inspect.getsourcefile(module)","source_hash":"a7c54723be9ade0317afd1fe42d42da5e7a33e1b5cffbf9bdfc66f3791a3caef","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:dataset/common.py","uri":"program://TinyRecursiveModels/file/dataset/common.py","kind":"file","name":"dataset/common.py","path":"dataset/common.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import List, Optional\n\nimport pydantic\nimport numpy as np\n\n\n# Global list mapping each dihedral transform id to its inverse.\n# Index corresponds to the original tid, and the value is its inverse.\nDIHEDRAL_INVERSE = [0, 3, 2, 1, 4, 5, 6, 7]\n\n\nclass PuzzleDatasetMetadata(pydantic.BaseModel):\n pad_id: int\n ignore_label_id: Optional[int]\n blank_identifier_id: int\n vocab_size: int\n seq_len: int\n num_puzzle_identifiers: int\n total_groups: int\n mean_puzzle_examples: float\n total_puzzles: int","source_hash":"be9d442d6a72a9351fda551ac1aeb05328512417faf6e8b7ed481915470f24d6","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:dataset/build_maze_dataset.py","uri":"program://TinyRecursiveModels/file/dataset/build_maze_dataset.py","kind":"file","name":"dataset/build_maze_dataset.py","path":"dataset/build_maze_dataset.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Optional\nimport math\nimport os\nimport csv\nimport json\nimport numpy as np\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\nfrom tqdm import tqdm\nfrom huggingface_hub import hf_hub_download\n\nfrom common import PuzzleDatasetMetadata, dihedral_transform\n\n\nCHARSET = \"# SGo\"\n\n\ncli = ArgParser()\n\n","source_hash":"839f29bf5f9fa98f3620572691bc7b869d818b4d38907c4a7b3bdaec6931965b","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:dataset/build_sudoku_dataset.py","uri":"program://TinyRecursiveModels/file/dataset/build_sudoku_dataset.py","kind":"file","name":"dataset/build_sudoku_dataset.py","path":"dataset/build_sudoku_dataset.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Optional\nimport os\nimport csv\nimport json\nimport numpy as np\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\nfrom tqdm import tqdm\nfrom huggingface_hub import hf_hub_download\n\nfrom common import PuzzleDatasetMetadata\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n source_repo: str = \"sapientinc/sudoku-extreme\"\n output_dir: str = \"data/sudoku-extreme-full\"\n","source_hash":"9cd1c28c4b186d990b9d671f82e4697eac19ae63ac58c3c29a54c662f2da1ea4","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:dataset/build_arc_dataset.py","uri":"program://TinyRecursiveModels/file/dataset/build_arc_dataset.py","kind":"file","name":"dataset/build_arc_dataset.py","path":"dataset/build_arc_dataset.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import List, Tuple, Dict\nfrom dataclasses import dataclass\nimport os\nimport json\nimport hashlib\nimport numpy as np\n\nfrom argdantic import ArgParser\nfrom pydantic import BaseModel\n\nfrom dataset.common import PuzzleDatasetMetadata, dihedral_transform, inverse_dihedral_transform\n\n\ncli = ArgParser()\n\n\nclass DataProcessConfig(BaseModel):\n input_file_prefix: str\n output_dir: str\n subsets: List[str]\n test_set_name: str","source_hash":"c6ccf29d2c0391f710a36b4b2ee8a1ea039e6624d64eb1a725d504f838440b09","truncated":false} {"repo_id":"TinyRecursiveModels","entity_id":"file:evaluators/arc.py","uri":"program://TinyRecursiveModels/file/evaluators/arc.py","kind":"file","name":"evaluators/arc.py","path":"evaluators/arc.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from typing import Dict, Sequence, Optional\nimport os\nimport json\n\nimport torch\nimport numpy as np\nfrom numba import njit\nimport torch.distributed as dist\n\nfrom dataset.build_arc_dataset import inverse_aug, grid_hash, arc_grid_to_np\nfrom dataset.common import PuzzleDatasetMetadata\n\n@njit\ndef _crop(grid: np.ndarray):\n \"\"\"Find maximum-sized rectangle without any EOS token inside. \"\"\"\n grid = grid.reshape(30, 30)\n\n max_area = 0\n max_size = (0, 0)\n nr, nc = grid.shape\n ","source_hash":"d776f96f68091658c24b87aff80b43e54664216a883c1bd99614f008a6dd87d4","truncated":false}