add arc1 fptrm singlez checkpoints

.gitattributes

@@ -69,3 +69,13 @@ maze/step_6510 filter=lfs diff=lfs merge=lfs -text
 maze/step_65100 filter=lfs diff=lfs merge=lfs -text
 maze/step_71610 filter=lfs diff=lfs merge=lfs -text
 maze/step_78120 filter=lfs diff=lfs merge=lfs -text
+arc1/step_103614 filter=lfs diff=lfs merge=lfs -text
+arc1/step_155422 filter=lfs diff=lfs merge=lfs -text
+arc1/step_207229 filter=lfs diff=lfs merge=lfs -text
+arc1/step_259036 filter=lfs diff=lfs merge=lfs -text
+arc1/step_310843 filter=lfs diff=lfs merge=lfs -text
+arc1/step_362650 filter=lfs diff=lfs merge=lfs -text
+arc1/step_414457 filter=lfs diff=lfs merge=lfs -text
+arc1/step_466264 filter=lfs diff=lfs merge=lfs -text
+arc1/step_51807 filter=lfs diff=lfs merge=lfs -text
+arc1/step_518071 filter=lfs diff=lfs merge=lfs -text

arc1/all_config.yaml

@@ -0,0 +1,84 @@
+arch:
+  H_cycles: 3
+  H_layers: 0
+  L_cycles: 6
+  L_layers: 2
+  alpha_1_init: 0.75
+  alpha_2_init: 0.25
+  conv_bias: false
+  conv_kernel_size: 4
+  conv_type: conv1d
+  decay_patience: 5
+  disable_conv_weight_decay: false
+  disable_q_head: false
+  eps: 1.0e-08
+  expansion: 4
+  expon_scale: 72.1347520444
+  forward_dtype: bfloat16
+  fp_thresh: 0.1
+  gamma_alpha: 4.0
+  gamma_scale: 16.6666666667
+  hidden_size: 512
+  loss:
+    deep_supervision: true
+    loss_type: stablemax_cross_entropy
+    name: losses@ACTLossHead
+    q_loss_coeff: 0.5
+  max_iter: 8
+  max_iter_dist: det
+  max_iter_eval: 1000
+  mlp_t: false
+  n_backwards_L: 6
+  n_decode_steps: 0
+  name: fixed_point_reasoning.fp_trm_singlez@FPTinyRecursiveReasoningModelSingleZ_ACTV1
+  no_ACT_continue: true
+  norm_placement: none
+  norm_type: pre-norm
+  normalize_input_injection: false
+  num_heads: 8
+  outer_only: false
+  outlier_quantile: 0.25
+  pos_encodings: rope
+  puzzle_emb_len: 16
+  puzzle_emb_ndim: 512
+  residual_scale: input-independent
+  scale_init: 2.0
+  softmax_temp: 1.0
+  stepsize: 1.0
+  stepsize_decay: 0.9
+  use_spec_norm_linear: false
+beta1: 0.9
+beta2: 0.95
+checkpoint_every_eval: true
+checkpoint_every_n_steps: null
+checkpoint_path: /fast/vmilovanovic/reasoning-model-ablation/new_runs/arc1/fptrm_singlez_arc1_lr1e-3_wd0.01_det_a0.75_0.25_iter8
+data_paths:
+- /home/vmilovanovic/datasets/arc/arc1concept-aug-1000
+data_paths_test: []
+ema: true
+ema_rate: 0.999
+epochs: 100000
+eval_interval: 10000
+eval_save_outputs: []
+evaluators: []
+freeze_weights: false
+global_batch_size: 768
+grad_clip_norm: null
+k_eval_max: null
+k_eval_min: null
+k_eval_step: 1
+load_checkpoint: null
+lr: 0.001
+lr_min_ratio: 1.0
+lr_warmup_steps: 0
+metrics_out: null
+min_eval_interval: 0
+optimizer: adam_atan2
+profile_flops: false
+project_name: reasoning-model-ablation
+puzzle_emb_lr: 0.01
+puzzle_emb_weight_decay: 1.0
+resume_from: null
+run_name: fptrm_singlez_arc1_lr1e-3_wd0.01_det_a0.75_0.25_iter8
+seed: 0
+weight_decay: 0.01

arc1/fp_trm_singlez.py

@@ -0,0 +1,273 @@
+from dataclasses import dataclass
+from typing import Tuple, Dict, Generator, Union
+import math
+import random
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from scipy.stats import gamma, expon
+
+from ..layers import (
+    RotaryEmbedding,
+    CastedEmbedding,
+    CastedLinear,
+)
+from ..sparse_embedding import CastedSparseEmbedding
+from ..transformer import FixedPointTransformer
+
+from .fp_trm_config import FPTRMConfig
+from .model_utils import FixedPointOptimizer
+
+IGNORE_LABEL_ID = -100
+
+
+@dataclass
+class FPTinyRecursiveReasoningModelSingleZ_ACTV1InnerCarry:
+    z_L_state: dict
+
+
+@dataclass
+class FPTinyRecursiveReasoningModelSingleZ_ACTV1Carry:
+    inner_carry: FPTinyRecursiveReasoningModelSingleZ_ACTV1InnerCarry
+    
+    steps: torch.Tensor
+    halted: torch.Tensor
+    
+    current_data: Dict[str, torch.Tensor]
+
+
+class FixedPointTinyRecursiveReasoningModel_SingleZ_Inner(nn.Module):
+    def __init__(self, config: FPTRMConfig) -> None:
+        super().__init__()
+        self.config = config
+        self.forward_dtype = getattr(torch, self.config.forward_dtype)
+
+        # I/O
+
+        self.embed_scale = math.sqrt(self.config.hidden_size)
+        embed_init_std = 1.0 / self.embed_scale
+
+        self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype)
+        self.lm_head      = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False)
+        if not self.config.disable_q_head:
+            self.q_head   = CastedLinear(self.config.hidden_size, 2, bias=True)
+
+        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
+        if self.config.puzzle_emb_ndim > 0:
+            # Zero init puzzle embeddings
+            self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim,
+                                                    batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype)
+
+        # LM Blocks
+        if self.config.pos_encodings == "rope":
+            self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads,
+                                              max_position_embeddings=self.config.seq_len + self.puzzle_emb_len,
+                                              base=self.config.rope_theta)
+        elif self.config.pos_encodings == "learned":
+            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)
+        else:
+            pass
+
+        # Reasoning Layers
+        self.L_level = FixedPointTransformer(self.config, self.config.L_layers)
+
+        self.L_optimizer = FixedPointOptimizer(self.config)
+
+        # Q head special init
+        # Init Q to (almost) zero for faster learning during bootstrapping
+        if not self.config.disable_q_head:
+            with torch.no_grad():
+                self.q_head.weight.zero_()
+                self.q_head.bias.fill_(-5)  # type: ignore
+
+    def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor):
+        # Token embedding
+        embedding = self.embed_tokens(input.to(torch.int32))
+
+        # Puzzle embeddings
+        if self.config.puzzle_emb_ndim > 0:
+            puzzle_embedding = self.puzzle_emb(puzzle_identifiers)
+            
+            pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1]
+            if pad_count > 0:
+                puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count))
+
+            embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2)
+
+        # Position embeddings
+        if self.config.pos_encodings == "learned":
+            # scale by 1/sqrt(2) to maintain forward variance
+            embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype))
+
+        # Scale
+        return self.embed_scale * embedding
+
+    def empty_carry(self, batch_size: int):
+        return FPTinyRecursiveReasoningModelSingleZ_ACTV1InnerCarry(
+            z_L_state = None,
+        )
+
+    def reset_carry(self, 
+                    reset_flag: torch.Tensor, 
+                    batch: torch.Tensor,
+                    carry: FPTinyRecursiveReasoningModelSingleZ_ACTV1InnerCarry):        
+        shape = (batch.shape[0], batch.shape[1] + self.puzzle_emb_len, self.config.hidden_size)
+        device = batch.device
+        dtype = self.forward_dtype
+        return FPTinyRecursiveReasoningModelSingleZ_ACTV1InnerCarry(
+            z_L_state = self.L_optimizer.reset(reset_flag, shape, dtype, device, carry.z_L_state),
+        )
+
+    def _z_step(self, state: Dict[str, torch.Tensor], input_embeddings: torch.Tensor, seq_info: Dict[str, any]):
+        z_new = self.L_level(state["y"], input_embeddings, **seq_info)
+        return self.L_optimizer.step(state, z_new)
+
+    def forward(self, 
+                carry: FPTinyRecursiveReasoningModelSingleZ_ACTV1InnerCarry, 
+                batch: Dict[str, torch.Tensor],
+                force_grad: bool,
+                n_steps: int) -> Tuple[
+        Tuple[FPTinyRecursiveReasoningModelSingleZ_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]
+    ]:
+        input_embeddings = self._input_embeddings(batch["inputs"], batch["puzzle_identifiers"])
+
+        # Slice rotary cache to the actual input length so the same model
+        # can be evaluated at sequence lengths shorter than config.seq_len
+        # (length-generalisation for state tracking).
+        cos_sin = None
+        if hasattr(self, "rotary_emb"):
+            cos, sin = self.rotary_emb()
+            s = input_embeddings.shape[1]
+            cos_sin = (cos[:s], sin[:s])
+        seq_info = dict(cos_sin=cos_sin, puzzle_emb_len=self.puzzle_emb_len)
+        z_state = carry.z_L_state
+        
+        with torch.set_grad_enabled(force_grad):
+            for _ in range(n_steps):
+                z_state = self._z_step(z_state, input_embeddings, seq_info)
+
+        output = self.lm_head(z_state['y'])[:, self.puzzle_emb_len:]
+        if self.config.disable_q_head:
+            q_logits = torch.zeros(z_state['y'].shape[0], 2, dtype=torch.float32, device=z_state['y'].device)
+        else:
+            q_logits = self.q_head(z_state['y'][:, 0]).to(torch.float32) # Q-head; uses the first puzzle_emb position
+        new_carry = FPTinyRecursiveReasoningModelSingleZ_ACTV1InnerCarry(z_L_state=self.L_optimizer.detach_state(z_state))  # New carry no grad
+        return new_carry, output, (q_logits[..., 0], q_logits[..., 1])
+
+
+class FPTinyRecursiveReasoningModelSingleZ_ACTV1(nn.Module):
+    """Single-state FPTRM wrapper."""
+
+    def __init__(self, config_dict: dict):
+        super().__init__()
+        self.config = FPTRMConfig(**config_dict)
+        self.inner = FixedPointTinyRecursiveReasoningModel_SingleZ_Inner(self.config)
+
+    @property
+    def puzzle_emb(self):
+        return self.inner.puzzle_emb
+    
+    def initial_carry(self, batch: Dict[str, torch.Tensor]):
+        batch_size = batch["inputs"].shape[0]
+
+        return FPTinyRecursiveReasoningModelSingleZ_ACTV1Carry(
+            inner_carry=self.inner.empty_carry(batch_size),  # Empty is expected, it will be reseted in first pass as all sequences are halted.
+            
+            steps=torch.zeros((batch_size, ), dtype=torch.int32),
+            halted=torch.ones((batch_size, ), dtype=torch.bool),  # Default to halted
+            
+            current_data={k: torch.empty_like(v) for k, v in batch.items()}
+        )
+    
+    def set_num_iters(self):
+        if self.training:
+            if self.config.max_iter_dist == 'gamma':
+                sampled_max_iter = gamma.rvs(a=self.config.gamma_alpha, scale=self.config.gamma_scale)
+            elif self.config.max_iter_dist == 'expon':
+                sampled_max_iter = expon.rvs(scale=self.config.expon_scale)
+            elif self.config.max_iter_dist == 'det':
+                sampled_max_iter = self.config.max_iter
+
+            if self.config.max_iter_dist == 'det':
+                self.max_iter = max(0, int(sampled_max_iter))
+            else:
+                self.max_iter = max(1, int(sampled_max_iter))
+        else:
+            self.max_iter = self.config.max_iter_eval if self.config.max_iter_eval is not None else self.config.max_iter
+
+    def forward(
+        self,
+        carry: FPTinyRecursiveReasoningModelSingleZ_ACTV1Carry,
+        batch: Dict[str, torch.Tensor],
+    ):
+        # Update data, carry (removing halted sequences)
+        # Handled inside the optimizer
+        new_inner_carry = self.inner.reset_carry(carry.halted, batch['inputs'], carry.inner_carry)
+        
+        new_steps = torch.where(carry.halted, 0, carry.steps)
+
+        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()}
+
+        # Forward-backward inner model
+        n_steps = self.config.n_backwards_L if self.training else 1
+        new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data, 
+                                                                                 force_grad=self.training, n_steps=n_steps)
+
+        outputs = {
+            "logits": logits,
+            "q_halt_logits": q_halt_logits,
+            "q_continue_logits": q_continue_logits
+        }
+
+        with torch.no_grad():
+            # Step
+            new_steps = new_steps + 1
+
+            if self.config.halting_mechanism == 'act':
+                is_last_step = new_steps >= self.config.halt_max_steps
+            else:
+                is_last_step = new_steps >= self.max_iter
+            
+            halted = is_last_step
+
+            # if testing, use fixed-points
+            if not self.training:
+                # during inference we only halt for the entire sequence
+                halted = halted | (new_inner_carry.z_L_state['residues'].max() < self.config.fp_thresh) \
+                                | (new_inner_carry.z_L_state['stepsize'].max() < 1e-3)
+
+            # if training, and ACT is enabled
+            cap = self.config.halt_max_steps if self.config.halting_mechanism == 'act' else self.max_iter            
+            if self.training and (cap > 1):
+                
+                if self.config.halting_mechanism == 'act':
+                    if self.config.no_ACT_continue:
+                        halted = halted | (q_halt_logits > 0)
+                    else:
+                        halted = halted | (q_halt_logits > q_continue_logits)
+                
+                    # Exploration
+                    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)
+                    halted = halted & (new_steps >= min_halt_steps)
+
+                elif self.config.halting_mechanism == 'fixed_point':
+                    # Exploration is implemented by self.max_iter if we choose to use it
+                    halted = halted | (new_inner_carry.z_L_state['residues'] < self.config.fp_thresh) \
+                                    | (new_inner_carry.z_L_state['stepsize'].view(-1) < 1e-3) 
+                
+                elif self.config.halting_mechanism == 'fixed_iterations':
+                    pass
+
+                else:
+                    raise ValueError("FPTRM with singleZ looping only accepts ACT, Fixed_point, and Fixed_iterations as its halting mechanism.")                
+
+                if not self.config.no_ACT_continue:
+                    # Compute target Q
+                    # NOTE: No replay buffer and target networks for computing target Q-value.
+                    # As batch_size is large, there're many parallel envs.
+                    # Similar concept as PQN https://arxiv.org/abs/2407.04811
+                    _, _, (next_q_halt_logits, next_q_continue_logits) = self.inner(new_inner_carry, new_current_data, force_grad=False, n_steps=1)
+                    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)))
+
+        return FPTinyRecursiveReasoningModelSingleZ_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs

arc1/losses.py

@@ -0,0 +1,120 @@
+from typing import Any, Tuple, Dict, Sequence, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+import math
+
+IGNORE_LABEL_ID = -100
+
+
+def s(x, epsilon=1e-30):
+    return torch.where(
+        x<0,
+        1/(1-x+ epsilon),
+        x + 1
+    )
+
+
+def log_stablemax(x, dim=-1):
+    s_x = s(x)
+    return torch.log(s_x/torch.sum(s_x, dim=dim, keepdim=True))
+
+
+def stablemax_cross_entropy(logits, labels, ignore_index: int = -100, valid_mask=None):
+    logprobs = log_stablemax(logits.to(torch.float64), dim=-1)
+
+    if valid_mask is None:
+        valid_mask = (labels != ignore_index)
+    transformed_labels = torch.where(valid_mask, labels, 0)
+    prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1)
+
+    return -torch.where(valid_mask, prediction_logprobs, 0)
+
+
+def softmax_cross_entropy(logits, labels, ignore_index: int = -100):
+    # Cast logits to f32
+    # Flatten logits
+    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)
+
+
+class ACTLossHead(nn.Module):
+    def __init__(self, model: nn.Module, loss_type: str, q_loss_coeff: float = 0.5, deep_supervision: bool = True):
+        super().__init__()
+        self.model = model
+        self.loss_fn = globals()[loss_type]
+        self.deep_supervision = deep_supervision
+        self.q_loss_coeff = q_loss_coeff
+        
+    def initial_carry(self, *args, **kwargs):
+        return self.model.initial_carry(*args, **kwargs)  # type: ignore
+
+    def set_num_iters(self, *args, **kwargs):
+        if hasattr(self.model, "set_num_iters"):
+            return self.model.set_num_iters(*args, **kwargs)  # type: ignore
+        return None
+
+    def forward(
+        self,
+        return_keys: Sequence[str],
+        # Model args
+        **model_kwargs,
+    ) -> Tuple[Any, torch.Tensor, Dict[str, torch.Tensor], Optional[Dict[str, torch.Tensor]], torch.Tensor]:
+        # Model logits
+        # B x SeqLen x D
+        new_carry, outputs = self.model(**model_kwargs)
+        labels = new_carry.current_data["labels"]
+
+        with torch.no_grad():
+            # Preds
+            outputs["preds"] = torch.argmax(outputs["logits"], dim=-1)
+
+            # Correctness
+            mask = (labels != IGNORE_LABEL_ID)
+            loss_counts = mask.sum(-1)
+            loss_divisor = loss_counts.clamp_min(1).unsqueeze(-1)  # Avoid NaNs in division
+
+            is_correct = mask & (torch.argmax(outputs["logits"], dim=-1) == labels)
+            seq_is_correct = is_correct.sum(-1) == loss_counts
+            
+            # Metrics (halted)
+            valid_metrics = new_carry.halted & (loss_counts > 0)
+            metrics = {
+                "count": valid_metrics.sum(),
+                
+                "accuracy":       torch.where(valid_metrics, (is_correct.to(torch.float32) / loss_divisor).sum(-1), 0).sum(),
+                "sequence_accuracy": (valid_metrics & seq_is_correct).sum(),
+
+                "q_halt_accuracy": (valid_metrics & ((outputs["q_halt_logits"] >= 0) == seq_is_correct)).sum(),
+                "steps":          torch.where(valid_metrics, new_carry.steps, 0).sum(),
+            }
+
+        # Losses
+        lm_loss = (self.loss_fn(outputs["logits"], labels, ignore_index=IGNORE_LABEL_ID, valid_mask=mask) / loss_divisor).sum()
+
+        if self.deep_supervision:
+            masked_loss = lm_loss
+        else:
+            lm_mask = mask & new_carry.halted.unsqueeze(-1)
+            lm_loss_counts = lm_mask.sum(-1)
+            lm_loss_divisor = lm_loss_counts.clamp_min(1).unsqueeze(-1)
+            masked_loss = (self.loss_fn(outputs["logits"], labels, ignore_index=IGNORE_LABEL_ID, valid_mask=lm_mask) / lm_loss_divisor).sum()
+        
+        q_halt_loss = F.binary_cross_entropy_with_logits(outputs["q_halt_logits"], seq_is_correct.to(outputs["q_halt_logits"].dtype), reduction="sum")
+        metrics.update({
+            "lm_loss": lm_loss.detach(),
+            "q_halt_loss": q_halt_loss.detach(),
+        })
+        # Q continue (bootstrapping target loss); Alexia: This fits Q-learning, but seems totally unecessary
+        q_continue_loss = 0
+        if "target_q_continue" in outputs:
+            q_continue_loss = F.binary_cross_entropy_with_logits(outputs["q_continue_logits"], outputs["target_q_continue"], reduction="sum")
+
+            metrics["q_continue_loss"] = q_continue_loss.detach()
+        # Filter outputs for return
+        detached_outputs = {k: outputs[k].detach() for k in return_keys if k in outputs}
+
+        masked_full_loss = masked_loss + self.q_loss_coeff * (q_halt_loss + q_continue_loss)
+        full_loss = lm_loss + self.q_loss_coeff * (q_halt_loss + q_continue_loss)
+
+        return new_carry, masked_full_loss, full_loss, metrics, detached_outputs, new_carry.halted.all()

arc1/step_103614

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9714cc4e5f33d5d0a5ef90bfe9b2a8d19b41e94e1f22e5c043cb95fd74f9370c
+size 1822215947

arc1/step_155422

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11a2e23dac433d39c6b0c3fc4685cbbc294c45175b1d345102b8ac1e4908bf94
+size 1822215947

arc1/step_207229

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b1d542a1aa4cf35e00ef838c3085cd00fb5ed743a94ab57e4560aac291006b8
+size 1822215947

arc1/step_259036

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c351369473dc35071c93ce2e03041aa1d28af5b69b68065dfe2441797953829
+size 1822215947

arc1/step_310843

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e38b31fbb39c4f7bf120c6f5d9cc5ef8f1bbad78da29ecd1771f7d0b207fcb06
+size 1822215947

arc1/step_362650

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55142798c4059f988074c16bacfed2db812a782dd21a6045ef03734ad41e2abf
+size 1822215947

arc1/step_414457

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a74f6af8c3048b112c2f68e73e6047ee33559c8a60163d1d6fb67033dac1bfb1
+size 1822215947

arc1/step_466264

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b81ad2e9e0abf8cde62461d54a9a40569ee42b6d6581ca25d5a3f5dacbf9336f
+size 1822215947

arc1/step_51807

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:223f5947240e304c27c74b57a194e9a275bf14b9cbb472080c93b73015dbcba8
+size 1822215925

arc1/step_518071

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:def6b01ca20982c63b9c319ecd6c8b8afd9e79dc6ba79cf4de3162488d1d36c6
+size 1822215947