Publish 11 evaluated Astra histories with reproducible checkpoint artifacts (part 51)

.gitattributes

@@ -1161,3 +1161,5 @@ tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/logs/session
 tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/logs/trajectory.jsonl filter=lfs diff=lfs merge=lfs -text
 tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/logs/sessions/2026/10/22/rollout-2026-10-22T03-38-50-01a161b0-ac23-78b3-96d0-140821a2d85b.jsonl filter=lfs diff=lfs merge=lfs -text
 tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/logs/trajectory.jsonl filter=lfs diff=lfs merge=lfs -text
+tasks/single-cell-perturbation-prediction/single-cell-perturbation-prediction-astra-xhigh-1h100-48h-20261020b/logs/sessions/2026/10/21/rollout-2026-10-21T03-57-13-01a15c9b-2307-7ab2-8e3e-1edc93189eb1.jsonl filter=lfs diff=lfs merge=lfs -text
+tasks/single-cell-perturbation-prediction/single-cell-perturbation-prediction-astra-xhigh-1h100-48h-20261020b/logs/trajectory.jsonl filter=lfs diff=lfs merge=lfs -text

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S052/unified.py

@@ -0,0 +1,643 @@
+"""One jointly learned protein encoder, shared pooling, and eleven small heads."""
+import math
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import esm2
+
+
+class NormalizedLinear(nn.Module):
+    def __init__(self, width, outputs=1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs)
+
+    def forward(self, values):
+        return self.linear((values - self.mean) / self.scale)
+
+
+class LowRankPositionHead(nn.Module):
+    """A shared residue projection followed by an ordered position readout."""
+    def __init__(self, dim, bins, rank, outputs=1):
+        super().__init__()
+        assert 0 < rank <= min(dim, bins)
+        self.dim = dim
+        self.project = nn.Linear(dim, rank, bias=False)
+        self.output = nn.Linear(bins * rank, outputs)
+
+    def forward(self, values):
+        residues = values.reshape(values.shape[0], -1, self.dim)
+        return self.output(self.project(residues).flatten(1))
+
+
+class NormalizedCosine(nn.Module):
+    def __init__(self, width, outputs, temperature=20.):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs, bias=False)
+        self.temperature = temperature
+
+    def forward(self, values):
+        features = F.normalize((values-self.mean)/self.scale, dim=-1)
+        return F.linear(features, F.normalize(self.linear.weight, dim=-1))*self.temperature
+
+
+class NormalizedMLP(nn.Module):
+    def __init__(self, width, outputs, hidden=128, dropout=.1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(), nn.LayerNorm(hidden),
+                                     nn.Dropout(dropout), nn.Linear(hidden, outputs))
+
+    def forward(self, values):
+        return self.network((values-self.mean)/self.scale)
+
+
+class SharedSummaryResidual(nn.Module):
+    """One nonlinear summary map jointly used by several classification heads."""
+    def __init__(self, width, hidden, dropout, classes):
+        super().__init__()
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(),
+                                     nn.LayerNorm(hidden), nn.Dropout(dropout),
+                                     nn.Linear(hidden, hidden), nn.GELU(), nn.Dropout(dropout))
+        self.heads = nn.ModuleDict({task: nn.Linear(hidden, outputs)
+                                   for task, outputs in sorted(classes.items())})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, normalized_summary):
+        return self.heads[task](self.network(normalized_summary))
+
+
+class NormalizedResidueLinear(nn.Module):
+    def __init__(self, dim, kernel=9):
+        super().__init__()
+        assert kernel > 0 and kernel % 2 == 1
+        self.kernel = kernel
+        self.readout = NormalizedLinear(dim * kernel, 3)
+
+    @staticmethod
+    def features(hidden, kernel):
+        padded = F.pad(hidden.float().transpose(1, 2), (kernel // 2, kernel // 2))
+        return padded.unfold(-1, kernel, 1).transpose(1, 2).flatten(2)
+
+    def forward(self, hidden):
+        return self.readout(self.features(hidden, self.kernel))
+
+
+class LocalResidueHead(nn.Sequential):
+    """Preserve the original four head parameter names; add a local residual."""
+    def __init__(self, dim):
+        super().__init__(nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+        self.context = nn.Sequential(nn.Conv1d(dim, dim, 9, padding=4, groups=dim),
+                                     nn.GELU(), nn.Conv1d(dim, dim, 1))
+        nn.init.zeros_(self.context[-1].weight)
+        nn.init.zeros_(self.context[-1].bias)
+
+    def forward(self, x):
+        x = x + self.context(x.transpose(1, 2)).transpose(1, 2)
+        for i in range(4):
+            x = self[i](x)
+        return x
+
+
+class CalibratedLocalResidueHead(LocalResidueHead):
+    def __init__(self, dim):
+        super().__init__(dim)
+        self[3] = NormalizedLinear(dim, 3)
+
+
+class ResidualSequenceConvHead(nn.Module):
+    """Learn local sequence motifs alongside the retained summary classifier."""
+    def __init__(self, dim, outputs, channels=128, dropout=.2, retain_summary=True):
+        super().__init__()
+        self.base = NormalizedLinear(7 * dim, outputs) if retain_summary else None
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, channels)
+        self.convs = nn.ModuleList([nn.Conv1d(channels, channels, k, padding=k//2) for k in (3,9)])
+        self.norms = nn.ModuleList([nn.LayerNorm(channels) for _ in self.convs])
+        self.output = nn.Linear(4 * channels, outputs)
+        nn.init.zeros_(self.output.weight);nn.init.zeros_(self.output.bias)
+        self.dropout = dropout
+
+    def forward(self, features):
+        valid = features['valid'].bool().unsqueeze(-1)
+        x = F.gelu(self.project((features['hidden']-self.mean)/self.scale)) * valid
+        summaries = []
+        for conv,norm in zip(self.convs,self.norms):
+            y = norm(F.gelu(conv(x.transpose(1,2)).transpose(1,2)))
+            center = (y*valid).sum(1)/valid.sum(1).clamp_min(1)
+            maximum = y.masked_fill(~valid,-1e4).amax(1)
+            maximum = torch.where(valid.any(1),maximum,torch.zeros_like(maximum))
+            summaries.extend([center,maximum])
+        pooled = F.dropout(torch.cat(summaries,dim=-1),self.dropout,self.training)
+        logits=self.output(pooled)
+        return self.base(features['summary']) + logits if self.base is not None else logits
+
+
+class TokenLogMeanExpHead(nn.Module):
+    """Class-specific local evidence, pooled without sequence-length bias."""
+    def __init__(self, dim, outputs):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.linear = nn.Linear(dim, outputs)
+
+    def forward(self, representation):
+        values, valid = representation['hidden'].float(), representation['valid']
+        logits = self.linear((values-self.mean)/self.scale)
+        logits = logits.masked_fill(~valid.unsqueeze(-1), -torch.inf)
+        return torch.logsumexp(logits, 1)-valid.sum(1).clamp_min(1).float().log()[:, None]
+
+    def packed(self, values, lengths):
+        """Equivalent unpadded computation for frozen-feature readout fitting."""
+        logits = self.linear((values.float()-self.mean)/self.scale)
+        # The stabilizing maximum cancels in the derivative; detach avoids
+        # retaining another large token-by-class gradient path.
+        maximum = torch.segment_reduce(logits.detach(), 'max', lengths=lengths)
+        index = torch.repeat_interleave(torch.arange(len(lengths), device=lengths.device), lengths,
+                                        output_size=len(values))
+        exponent = (logits-maximum[index]).exp()
+        total = torch.segment_reduce(exponent, 'sum', lengths=lengths)
+        return maximum+total.log()-lengths.float().log()[:, None]
+
+
+class SharedPairResidueInteraction(nn.Module):
+    """A shared nonlinear comparison of local states from both protein chains."""
+    def __init__(self, dim, settings, classes):
+        super().__init__()
+        width, hidden, channels = (settings[k] for k in ['projection_dim', 'pair_hidden', 'pair_channels'])
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, width)
+        self.compare = nn.Sequential(nn.Linear(2*width, hidden), nn.GELU(),
+                                     nn.Linear(hidden, channels), nn.GELU())
+        self.dropout = settings['dropout']
+        self.heads = nn.ModuleDict({task: nn.Linear(2*channels, classes.get(task, 1))
+                                   for task in sorted(esm2.Model.PAIR)})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, first, second):
+        first = F.gelu(self.project((first-self.mean)/self.scale))
+        second = F.gelu(self.project((second-self.mean)/self.scale))
+        first = F.dropout(first, self.dropout, self.training)
+        second = F.dropout(second, self.dropout, self.training)
+        pair = torch.cat([(first[:, :, None]-second[:, None, :]).abs(),
+                          first[:, :, None]*second[:, None, :]], dim=-1)
+        local = self.compare(pair)
+        summary = torch.cat([local.mean((1, 2)), local.amax((1, 2))], dim=-1)
+        return self.heads[task](summary)
+
+
+class SSChainDecoder(nn.Module):
+    """Small learned label-compatibility model, applied to frozen residue unaries."""
+    def __init__(self):
+        super().__init__()
+        self.transition = nn.Parameter(torch.empty(3, 3))
+        self.start = nn.Parameter(torch.empty(3))
+        self.end = nn.Parameter(torch.empty(3))
+        for parameter in self.parameters():
+            nn.init.normal_(parameter, std=.01)
+
+    def decode(self, probabilities):
+        from ss_chain import decode_probabilities
+        values = [parameter.detach().double().cpu().numpy()
+                  for parameter in (self.transition, self.start, self.end)]
+        return decode_probabilities(probabilities, *values)
+
+
+class UnifiedModel(esm2.Model):
+    TASK_ORDER = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+                  'subcellular_localization', 'binary_localization', 'fold',
+                  'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+    def __init__(self, config):
+        super().__init__(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+        self.config = config
+        self.task_index = {t: i for i, t in enumerate(self.TASK_ORDER)}
+        dim = config['dim']
+        if config.get('extension_layers', 0):
+            self.encoder.add_extension(config['extension_layers'], config['heads'],
+                                       before_norm=config.get('extension_before_norm', False))
+        if config.get('task_conditioning', False):
+            self.task_condition = nn.Parameter(torch.zeros(11, config['layers'], 4, dim))
+        if config.get('pooling', 'mean') == 'rich':
+            self.pool_query = nn.Parameter(torch.randn(len(self.TASK_ORDER), 2, dim) * 0.02)
+            self.pool_position = nn.Parameter(torch.zeros(len(self.TASK_ORDER), 2, 4))
+            # Shared across tasks, with a zero initial residual for safe lineage transfer.
+            self.pool_fuse = nn.Linear(6 * dim, dim)
+            nn.init.zeros_(self.pool_fuse.weight)
+            nn.init.zeros_(self.pool_fuse.bias)
+        if config.get('pair_interaction', False):
+            self.pair_fuse = nn.Linear(2 * dim, 2 * dim)
+            nn.init.zeros_(self.pair_fuse.weight)
+            nn.init.zeros_(self.pair_fuse.bias)
+        if config.get('ss_context', False):
+            self.heads['secondary_structure'] = LocalResidueHead(dim)
+        for task in config.get('linear_heads', []):
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(nn.Linear(width, self.CLASSES.get(task, 1)))
+        for task, settings in config.get('residue_readouts', {}).items():
+            self.heads[task] = NormalizedLinear(settings['bins'] * dim, self.CLASSES.get(task, 1))
+        for task, rank in config.get('residue_lowrank_heads', {}).items():
+            bins = config['residue_readouts'][task]['bins']
+            self.heads[task] = LowRankPositionHead(dim, bins, rank, self.CLASSES.get(task, 1))
+        for task in config.get('summary_readouts', []):
+            assert task not in self.PAIR and config.get('pooling') == 'rich'
+            self.heads[task] = NormalizedLinear(7 * dim, self.CLASSES.get(task, 1))
+        for task in config.get('sequence_composition_readouts', []):
+            from sequence_composition import WIDTH
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES
+            assert all(task not in config.get(key,[]) for key in
+                       ['cosine_heads','nonlinear_summary_heads','ss_summary_readouts',
+                        'sequence_conv_readouts','terminal_summary_readouts','token_logmeanexp_heads'])
+            self.heads[task] = NormalizedLinear(7 * dim + WIDTH, self.CLASSES[task])
+        for task, temperature in config.get('cosine_heads', {}).items():
+            assert task in config.get('summary_readouts', [])
+            self.heads[task] = NormalizedCosine(7*dim, self.CLASSES[task], temperature)
+        for task, settings in config.get('nonlinear_summary_heads', {}).items():
+            assert task in config.get('summary_readouts', []) and task not in config.get('cosine_heads', {})
+            self.heads[task] = NormalizedMLP(7*dim, self.CLASSES.get(task,1), settings['hidden'], settings['dropout'])
+        for task in config.get('calibrated_heads', []):
+            assert task not in config.get('summary_readouts', []) and task not in config.get('residue_readouts', {})
+            assert task not in config.get('linear_heads', [])
+            self.heads[task][3] = NormalizedLinear(dim, self.CLASSES.get(task,1))
+        for task in config.get('expanded_pair_readouts', []):
+            assert task in self.PAIR
+            width=3 if task in config.get('symmetric_pair_readouts',[]) else 4
+            if task in config.get('pair_summary_readouts', []):
+                assert config.get('pooling') == 'rich'
+                width *= 8
+            self.heads[task] = NormalizedLinear(width*dim, self.CLASSES.get(task,1))
+        if config.get('ss_linear_context'):
+            self.heads['secondary_structure'] = NormalizedResidueLinear(dim, config['ss_linear_context'])
+        if config.get('ss_calibrated'):
+            assert not config.get('ss_linear_context')
+            self.heads['secondary_structure'] = CalibratedLocalResidueHead(dim)
+        for task in config.get('ss_summary_readouts', []):
+            assert task in config.get('summary_readouts', []) and task not in self.PAIR
+            self.heads[task] = NormalizedLinear(7*dim+40, self.CLASSES[task])
+        for task,settings in config.get('sequence_conv_readouts',{}).items():
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES and task not in self.PAIR
+            self.heads[task] = ResidualSequenceConvHead(dim,self.CLASSES[task],settings['channels'],settings['dropout'],settings.get('retain_summary',True))
+        for task, settings in config.get('terminal_summary_readouts', {}).items():
+            assert task in config.get('summary_readouts', []) and task in self.CLASSES and task not in self.PAIR
+            assert all(task not in config.get(key, {}) for key in
+                       ['cosine_heads', 'nonlinear_summary_heads', 'ss_summary_readouts', 'sequence_conv_readouts'])
+            bins = settings['bins']
+            assert bins > 0 and all(settings[key] > 0 and settings[key] % bins == 0
+                                    for key in ['prefix_residues', 'suffix_residues'])
+            self.heads[task] = NormalizedLinear((7+2*bins)*dim, self.CLASSES[task])
+        if config.get('pair_bilinear_rank', 0):
+            rank = config['pair_bilinear_rank']
+            assert not config.get('pair_summary_readouts')
+            self.pair_bilinear_projection = nn.Linear(dim, rank, bias=False)
+            nn.init.normal_(self.pair_bilinear_projection.weight, std=dim ** -.5)
+            with torch.no_grad():
+                self.pair_bilinear_projection.weight.copy_(F.normalize(self.pair_bilinear_projection.weight, dim=1))
+            self.pair_bilinear_heads = nn.ModuleDict({
+                task: nn.Linear(rank, self.CLASSES.get(task, 1), bias=False)
+                for task in sorted(self.PAIR)})
+            for head in self.pair_bilinear_heads.values():
+                nn.init.zeros_(head.weight)
+            self.register_buffer('pair_bilinear_mean', torch.zeros(dim))
+            self.register_buffer('pair_bilinear_scale', torch.ones(dim))
+        if config.get('pair_residue_interaction'):
+            self.pair_residue_interaction = SharedPairResidueInteraction(
+                dim, config['pair_residue_interaction'], self.CLASSES)
+        for task in config.get('token_logmeanexp_heads', []):
+            assert task in self.CLASSES and task not in self.PAIR
+            assert task not in config.get('sequence_windows', [])
+            self.heads[task] = TokenLogMeanExpHead(dim, self.CLASSES[task])
+        if config.get('ss_chain_decoder', False):
+            self.ss_chain_decoder = SSChainDecoder()
+        if config.get('shared_summary_residual'):
+            settings = config['shared_summary_residual']
+            tasks = settings['tasks']
+            assert all(task in config.get('summary_readouts', []) and
+                       isinstance(self.heads[task], NormalizedLinear) for task in tasks)
+            self.summary_residual = SharedSummaryResidual(7*dim, settings['hidden'], settings['dropout'],
+                                                          {task: self.CLASSES[task] for task in tasks})
+
+    def pair_representation(self, task, first, second, base):
+        if task in self.config.get('pair_bilinear_tasks', []):
+            return {'base': base, 'chain_a': first, 'chain_b': second}
+        return base
+
+    def apply_head(self, task, representation):
+        if task in self.config.get('summary_residual_tasks', []):
+            head = self.heads[task]
+            normalized = (representation-head.mean)/head.scale
+            return head(representation) + self.summary_residual(task, normalized)
+        if isinstance(representation, dict) and 'residue_a' in representation:
+            base = {k:v for k,v in representation.items() if k not in ['residue_a', 'residue_b']}
+            original = self.apply_head(task, base if 'chain_a' in base else base['base'])
+            return original + self.pair_residue_interaction(task, representation['residue_a'], representation['residue_b'])
+        if isinstance(representation, dict) and 'chain_a' in representation:
+            first = (representation['chain_a'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            second = (representation['chain_b'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            interaction = self.pair_bilinear_projection(first) * self.pair_bilinear_projection(second)
+            interaction = interaction / math.sqrt(self.config['pair_bilinear_rank'])
+            return self.heads[task](representation['base']) + self.pair_bilinear_heads[task](interaction)
+        return self.heads[task](representation)
+
+    def encode_residues(self, tokens, task):
+        condition = None
+        if self.config.get('task_conditioning', False):
+            ti = 10 if task == 'secondary_structure' else self.task_index[task]
+            condition = self.task_condition[ti]
+        return self.encoder(tokens, condition=condition, depth=self.config.get('task_encoder_layers',{}).get(task),
+                            extension_depth=self.config.get('task_extension_depths',{}).get(task))
+
+    def pool(self, tokens, task):
+        hidden, pad_mask = self.encode_residues(tokens, task)
+        return self.summarize(hidden, tokens, pad_mask, task)
+
+    def summarize(self, hidden, tokens, pad_mask, task):
+        valid = (~pad_mask).unsqueeze(-1)
+        mean = (hidden * valid).sum(1) / valid.sum(1).clamp_min(1)
+        if self.config.get('pooling', 'mean') == 'mean':
+            return mean
+        residues = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+        # Empty/nonstandard-only inputs still produce a finite representation.
+        residues[:, 0] |= ~residues.any(1)
+        keep = residues.unsqueeze(-1)
+        count = keep.sum(1).clamp_min(1)
+        center = (hidden * keep).sum(1) / count
+        position = residues.cumsum(1).to(hidden.dtype) / count.to(hidden.dtype)
+        basis = torch.stack([position, position.square(), torch.sin(position * math.pi),
+                             torch.cos(position * math.pi)], dim=-1)
+        ti = self.task_index[task]
+        scores = torch.einsum('bld,qd->blq', hidden, self.pool_query[ti]) / math.sqrt(hidden.shape[-1])
+        scores = scores + torch.einsum('blp,qp->blq', basis, self.pool_position[ti])
+        scores = scores.masked_fill(~residues.unsqueeze(-1), -1e4)
+        attention = torch.einsum('blq,bld->bqd', scores.softmax(1), hidden)
+        variance = ((hidden - center[:, None]).float().square() * keep).sum(1) / count
+        deviation = (variance + 1e-5).sqrt().to(hidden.dtype)
+        maximum = hidden.masked_fill(~keep, -1e4).amax(1) - center
+        first = residues & (residues.cumsum(1) <= 32)
+        last = residues & ((residues.sum(1, keepdim=True) - residues.cumsum(1)) < 32)
+        prefix = (hidden * first.unsqueeze(-1)).sum(1) / first.sum(1, keepdim=True).clamp_min(1) - center
+        suffix = (hidden * last.unsqueeze(-1)).sum(1) / last.sum(1, keepdim=True).clamp_min(1) - center
+        summary = torch.cat([attention[:, 0] - center, attention[:, 1] - center,
+                             deviation, maximum, prefix, suffix], dim=-1)
+        if task in self.config.get('summary_readouts', []):
+            return torch.cat([mean, summary], dim=-1)
+        if task in self.config.get('pair_summary_readouts', []):
+            return torch.cat([mean + self.pool_fuse(summary), mean, summary], dim=-1)
+        return mean + self.pool_fuse(summary)
+
+    def pool_sequences(self, sequences, task, device, max_len):
+        if self.training and not self.config.get('window_pooling_training', True):
+            tokens=esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device)
+            return self.pool(tokens,task)
+        if task not in self.config.get('sequence_windows', []) or not any(len(s)>max_len-2 for s in sequences):
+            return self.pool(esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device),task)
+        results=[None]*len(sequences)
+        short=[i for i,s in enumerate(sequences) if len(s)<=max_len-2]
+        if short:
+            pooled=self.pool(esm2.pad_batch([esm2.encode(sequences[i],max_len) for i in short],device),task)
+            for j,index in enumerate(short):results[index]=pooled[j]
+        width=max_len-2;stride=min(768,width)
+        if self.training and self.config.get('batch_window_training',False):
+            pieces=[];starts_by_index={};encoded={}
+            for index,sequence in enumerate(sequences):
+                if len(sequence)<=width:continue
+                starts=list(range(0,len(sequence)-width+1,stride))
+                if starts[-1]!=len(sequence)-width:starts.append(len(sequence)-width)
+                starts_by_index[index]=starts
+                pieces.extend((index,start) for start in starts)
+            count=max(1,16384//max_len)
+            for begin in range(0,len(pieces),count):
+                part=pieces[begin:begin+count]
+                tokens=esm2.pad_batch([esm2.encode(sequences[i][s:s+width],max_len) for i,s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,key in enumerate(part):encoded[key]=hidden[j]
+            positions=torch.arange(width,device=device)
+            weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+            for index,starts in starts_by_index.items():
+                sequence=sequences[index];length=len(sequence)
+                total=torch.zeros(length,self.config['dim'],device=device);counts=torch.zeros(length,1,device=device)
+                for start in starts:
+                    total.index_add_(0,positions+start,encoded[index,start][1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+                assembled=torch.cat([encoded[index,starts[0]][0:1],total/counts.clamp_min(1),encoded[index,starts[-1]][width+1:width+2]],dim=0)[None]
+                tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+                results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+            return torch.stack(results)
+        for index,sequence in enumerate(sequences):
+            length=len(sequence)
+            if length<=width:continue
+            starts=list(range(0,length-width+1,stride))
+            if starts[-1]!=length-width:starts.append(length-width)
+            total=torch.zeros(length,self.config['dim'],device=device)
+            counts=torch.zeros(length,1,device=device)
+            first=last=None
+            for begin in range(0,len(starts),max(1,16384//max_len)):
+                part=starts[begin:begin+max(1,16384//max_len)]
+                tokens=esm2.pad_batch([esm2.encode(sequence[s:s+width],max_len) for s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,start in enumerate(part):
+                    if start==0:first=hidden[j,0:1]
+                    if start==starts[-1]:last=hidden[j,width+1:width+2]
+                    positions=torch.arange(width,device=device)
+                    weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+                    total.index_add_(0,positions+start,hidden[j,1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+            assembled=torch.cat([first,total/counts.clamp_min(1),last],dim=0)[None]
+            tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+            results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+        return torch.stack(results)
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.config.get('sequence_composition_readouts', []):
+            from sequence_composition import composition_features
+            sequences=[item['sequence'] for item in batch]
+            pooled=self.pool_sequences(sequences,task,device,max_len)
+            return torch.cat([pooled.float(),composition_features(sequences,device)],-1)
+        if task in self.config.get('token_logmeanexp_heads', []):
+            tokens = esm2.pad_batch([esm2.encode(row['sequence'], max_len) for row in batch], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            valid = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+            valid[:, 0] |= ~valid.any(1)
+            return {'hidden':hidden, 'valid':valid}
+        if task in self.config.get('terminal_summary_readouts', {}):
+            return self.terminal_summary_features(task, [item['sequence'] for item in batch], device, max_len)
+        if task in self.config.get('ss_summary_readouts', []):
+            sequences=[x['sequence'] for x in batch]
+            summary=self.pool_sequences(sequences,task,device,max_len)
+            structure=self.secondary_structure_summary(sequences,device,max_len)
+            return torch.cat([summary.float(),structure],-1)
+        if task in self.config.get('sequence_conv_readouts',{}):
+            tokens=esm2.pad_batch([esm2.encode(x['sequence'],max_len) for x in batch],device)
+            hidden,pad_mask=self.encode_residues(tokens,task)
+            lengths=torch.tensor([min(len(x['sequence']),max_len-2) for x in batch],device=device)
+            width=max(1,int(lengths.max()))
+            valid=torch.arange(width,device=device)[None,:]<lengths[:,None]
+            return {'hidden':hidden[:,1:1+width], 'valid':valid,
+                    'summary':self.summarize(hidden,tokens,pad_mask,task)}
+        if task in self.config.get('residue_readouts', {}):
+            bins = self.config['residue_readouts'][task]['bins']
+            sequences = [x['sequence'] for x in batch]
+            tokens = esm2.pad_batch([esm2.encode(s, max_len) for s in sequences], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            return self.position_features(hidden, [min(len(s), max_len-2) for s in sequences], bins)
+        if task in self.PAIR:
+            a = self.pool_sequences([x['sequence_a'] for x in batch],task,device,max_len)
+            b = self.pool_sequences([x['sequence_b'] for x in batch],task,device,max_len)
+            if task in self.config.get('expanded_pair_readouts', []):
+                if task in self.config.get('symmetric_pair_readouts',[]):
+                    features=torch.cat([(a.float()+b.float())*.5,a*b,(a-b).abs()],dim=-1)
+                else:
+                    features=torch.cat([a,b,a*b,(a-b).abs()],dim=-1)
+                base = F.dropout(features,p=self.config.get('pair_dropout',0.),training=self.training)
+                return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+            output = torch.cat([a, b], dim=-1)
+            if self.config.get('pair_interaction', False):
+                output = output + self.pair_fuse(torch.cat([a * b, (a - b).abs()], dim=-1))
+            base = F.dropout(output, p=self.config.get('pair_dropout', 0.0), training=self.training)
+            return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+        return self.pool_sequences([x['sequence'] for x in batch],task,device,max_len)
+
+    def add_pair_residues(self, task, batch, device, max_len, base):
+        if task not in self.config.get('pair_residue_tasks', []):
+            return base
+        result = dict(base) if isinstance(base, dict) else {'base': base}
+        bins = self.config['pair_residue_interaction']['bins']
+        for role, name in [('a', 'sequence_a'), ('b', 'sequence_b')]:
+            result['residue_'+role] = self.pool_residue_bins(
+                [row[name] for row in batch], task, device, max_len, bins)
+        return result
+
+    def pool_residue_bins(self, sequences, task, device, max_len, bins):
+        """Average every residue into fixed relative bins, with full-chain context."""
+        width = max_len-2
+        assert width > 0 and bins > 0
+        output = [None]*len(sequences)
+        short = [i for i, sequence in enumerate(sequences) if len(sequence) <= width]
+        if short:
+            tokens = esm2.pad_batch([esm2.encode(sequences[i], max_len) for i in short], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            for j, index in enumerate(short):
+                length = len(sequences[index])
+                values = hidden[j, 1:1+length].float()
+                output[index] = (F.adaptive_avg_pool1d(values.T[None], bins)[0].T if length
+                                 else torch.zeros(bins, self.config['dim'], device=device))
+        for index, sequence in enumerate(sequences):
+            if len(sequence) <= width:
+                continue
+            starts = list(range(0, len(sequence)-width+1, min(768, width)))
+            if starts[-1] != len(sequence)-width:
+                starts.append(len(sequence)-width)
+            total = torch.zeros(len(sequence), self.config['dim'], device=device)
+            count = torch.zeros(len(sequence), 1, device=device)
+            position = torch.arange(width, device=device)
+            weight = torch.minimum(torch.minimum(position+1, width-position),
+                                   torch.full_like(position, 128)).float()[:, None]
+            for begin in range(0, len(starts), max(1, 16384//max_len)):
+                part = starts[begin:begin+max(1, 16384//max_len)]
+                tokens = esm2.pad_batch([esm2.encode(sequence[s:s+width], max_len) for s in part], device)
+                hidden, _ = self.encode_residues(tokens, task)
+                for j, start in enumerate(part):
+                    total.index_add_(0, position+start, hidden[j, 1:1+width].float()*weight)
+                    count.index_add_(0, position+start, weight)
+            values = total/count.clamp_min(1)
+            output[index] = F.adaptive_avg_pool1d(values.T[None], bins)[0].T
+        return torch.stack(output)
+
+    @staticmethod
+    def terminal_bins(states, width, bins, align_end=False):
+        """Fixed absolute residue bins; exclude padding from partial-bin means."""
+        assert width > 0 and bins > 0 and width % bins == 0
+        states = (states[-width:] if align_end else states[:width]).float()
+        count = states.shape[0]
+        padded = states.new_zeros(width, states.shape[-1])
+        valid = states.new_zeros(width)
+        offset = width-count if align_end else 0
+        padded[offset:offset+count] = states
+        valid[offset:offset+count] = 1
+        total = padded.reshape(bins, width//bins, -1).sum(1)
+        denominator = valid.reshape(bins, width//bins).sum(1).clamp_min(1)[:, None]
+        return (total/denominator).flatten()
+
+    def terminal_summary_features(self, task, sequences, device, max_len):
+        settings = self.config['terminal_summary_readouts'][task]
+        width = max_len-2
+        assert width >= max(settings['prefix_residues'], settings['suffix_residues'])
+        tokens = esm2.pad_batch([esm2.encode(sequence, max_len) for sequence in sequences], device)
+        hidden, padding = self.encode_residues(tokens, task)
+        summary = self.summarize(hidden, tokens, padding, task)
+        long_ids = [index for index, sequence in enumerate(sequences) if len(sequence) > width]
+        tails = {}
+        if long_ids:
+            tail_tokens = esm2.pad_batch([esm2.encode(sequences[index][-width:], max_len)
+                                         for index in long_ids], device)
+            tail_hidden, _ = self.encode_residues(tail_tokens, task)
+            tails = {index: tail_hidden[local, 1:width+1] for local, index in enumerate(long_ids)}
+        terminals = []
+        for index, sequence in enumerate(sequences):
+            prefix = hidden[index, 1:1+min(len(sequence), width)]
+            suffix = tails.get(index, prefix)
+            terminals.append(torch.cat([
+                self.terminal_bins(prefix, settings['prefix_residues'], settings['bins']),
+                self.terminal_bins(suffix, settings['suffix_residues'], settings['bins'], align_end=True)]))
+        return torch.cat([summary.float(), torch.stack(terminals)], dim=-1)
+
+    @staticmethod
+    def position_features(hidden, lengths, bins):
+        features = []
+        for index, length in enumerate(lengths):
+            if length:
+                states = hidden[index:index+1, 1:1+length].float().transpose(1, 2)
+                features.append(F.interpolate(states, size=bins, mode='linear', align_corners=True).flatten())
+            else:
+                features.append(hidden.new_zeros(hidden.shape[-1] * bins).float())
+        return torch.stack(features)
+
+    def secondary_structure_summary(self, sequences, device, max_len):
+        tokens=esm2.pad_batch([esm2.encode(sequence,max_len) for sequence in sequences],device)
+        hidden,_=self.encode_residues(tokens,'secondary_structure')
+        with torch.autocast(device_type=device.type,enabled=False):
+            probabilities=self.heads['secondary_structure'](hidden.float()).softmax(-1)
+        summaries=[]
+        for index,sequence in enumerate(sequences):
+            length=min(len(sequence),max_len-2)
+            if not length:
+                summaries.append(probabilities.new_zeros(40));continue
+            value=probabilities[index,1:1+length]
+            mean=value.mean(0);std=value.std(0,unbiased=False)
+            transition=(value[:-1,:,None]*value[1:,None,:]).mean(0).flatten() if length>1 else value.new_zeros(9)
+            positions=F.adaptive_avg_pool1d(value.T[None],8).flatten()
+            summaries.append(torch.cat([mean,std,transition,positions,value.new_tensor([math.log1p(length)])]))
+        return torch.stack(summaries)
+
+    def normalize(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return (values - stats['mean']) / stats['std'] if stats else values
+
+    def unscale(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return values * stats['std'] + stats['mean'] if stats else values
+
+    def transfer(self, state, normalized_source=False):
+        """Transfer our own lineage only; retain random init for new parameters."""
+        current = self.state_dict()
+        fitting = {k: v for k, v in state.items() if k in current and v.shape == current[k].shape}
+        missing, unexpected = self.load_state_dict(fitting, strict=False)
+        if not normalized_source:
+            with torch.no_grad():
+                for task, stats in self.config.get('regression_stats', {}).items():
+                    # Preserve predictions when moving a trained head to standardized units.
+                    if f'heads.{task}.3.weight' in fitting:
+                        self.heads[task][3].weight.div_(stats['std'])
+                        self.heads[task][3].bias.sub_(stats['mean']).div_(stats['std'])
+        return {'transferred': len(fitting), 'new_tensors': missing, 'unexpected': unexpected}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S053/PUBLISHED.json

@@ -0,0 +1,5 @@
+{
+  "source": "/run-state/workspace/research/production-stability-lengthweight1/candidate/package",
+  "files": 9,
+  "bytes": 214711015
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S053/README.md

@@ -0,0 +1,61 @@
+# Unified PEER protein model
+
+One shared rotary transformer serves all eleven tasks: 12 layers, width 512,
+8 attention heads, plus two shared extension blocks. Exact parameter count:
+**53,000,306 total**, **44,150,303 encoder**, including **37,845,535 original
+encoder parameters used by every task**. Beta-lactamase and stability use both
+extension blocks; other tasks use the original encoder exit.
+
+All parameters originated from random initialization and training in this
+session. The common encoder received one hour of MLM on mounted decontaminated
+UniRef50 (1,713,641,682 token presentations), then joint supervision across all
+eleven fit tasks. The retained checkpoint has 600 active seconds / 11,899
+updates. Task conditioning and extension training also used all eleven fit
+tasks. No external weights, embeddings or data were used.
+
+Heads:
+
+- Fluorescence/beta-lactamase: normalized linear heads over 256/320 interpolated
+  residue positions, empirical rank targets and ridge 1.
+- Fold, solubility and both localization tasks: seven-summary normalized linear
+  heads. Binary localization adds a 475,906-parameter nonlinear summary residual
+  jointly trained across solubility and both localization tasks.
+- Human PPI: ordered chain summaries, product and absolute difference.
+  Yeast/affinity use symmetric averages, product and absolute difference. Yeast
+  additionally uses shared rank-32 bilinear and 64-bin residue interaction
+  modules, each jointly trained across all three PPI tasks.
+- Stability: MLP with normalized final linear head; the six learned head
+  tensors use the fixed continuation midpoint described below.
+- Secondary structure: local convolution and residue MLP with normalized final
+  layer. Its head received 64 supervised epochs and 64 distillation epochs on
+  2,221,507 valid fit residues, combining equal hard CE and temperature-2 KL.
+  The teacher was an own-session 85M model with two-hour MLM and joint all-task
+  supervision/conditioning. Teacher parameters and caches are absent here.
+
+Fold, fluorescence, beta-lactamase and affinity heads retain the parent fit+tune label fits. Each recipe passed a two-half added-label pilot before fitting the full permitted pool. Their production Tune scores and aggregate are in-sample and excluded from development selection.
+
+Stability starts from the previously selected fit-only head (including its
+earlier continuation midpoint). The new study compared natural weighting with
+equal total loss mass for the 36,446 length-43 and 17,168 length-50 fit rows.
+Both arms used identical batches, dropout RNG and 1,680 updates: whole-head
+AdamW, peak lr 0.0001, weight decay 0.01, batch 512, 16 epochs, cosine decay to
+10%, original fit-standardized MSE, clipping 1. Feature-normalization buffers
+were fixed. Only the predeclared final 50:50 parameter midpoint was eligible;
+raw endpoints and earlier checkpoints were not selected. Balanced weighting
+scored 0.7311607643 on cached Tune features versus 0.7274924149 for its parent
+and 0.7291215997 for the matched control; conditional paired 95% differences
+were [0.0019018632, 0.0054815226] and [0.0012832147, 0.0028118185].
+Complete independent production replay is valid: stability predictions exactly match the accepted fit-only candidate, and all ten other prediction files are byte-identical to the previous production package. Separate fit-only development mean is0.7166638090; stability is0.7311607643. Native paired stability gain is0.0036683835, conditional95%[0.0017767471,0.0054419975].
+
+Tune selects regularization, checkpoints, conditioning and task exits. This
+length-weighting hypothesis was informed by the observed Tune length
+distribution. Repeated Tune selection and protein-family dependence are not
+corrected by the conditional intervals. Small PPI splits and weak fold
+generalization remain limitations. SS and pair windows cover full chains;
+other tasks use a 1022-residue prefix. Human windows allow 1536 tokens and
+yeast 1024. GFP/beta rank outputs are not calibrated for absolute error.
+No held-out test measurement is available.
+
+Run `bash infer.sh INPUT_ROOT OUTPUT_ROOT` offline. This is one parameter set
+and needs no live trainer, research files, feature cache, sequence lookup,
+prediction ensemble or test-time fitting.

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S053/config.json

@@ -0,0 +1,134 @@
+{
+  "layers": 12,
+  "dim": 512,
+  "heads": 8,
+  "pooling": "rich",
+  "pair_interaction": true,
+  "ss_context": true,
+  "max_len": 1024,
+  "pair_dropout": 0.0,
+  "architecture": "unified",
+  "full_ss": true,
+  "regression_stats": {
+    "fluorescence": {
+      "mean": 3.180586883940159,
+      "std": 0.8339910288860748
+    },
+    "stability": {
+      "mean": 0.1790524860555312,
+      "std": 0.5662245232305059
+    },
+    "beta_lactamase": {
+      "mean": 0.7383112351980983,
+      "std": 0.31642946622284734
+    },
+    "ppi_affinity": {
+      "mean": -11.654589870742203,
+      "std": 3.0832061340498944
+    }
+  },
+  "residue_readouts": {
+    "fluorescence": {
+      "bins": 256
+    },
+    "beta_lactamase": {
+      "bins": 320
+    }
+  },
+  "fp32_heads": [
+    "beta_lactamase",
+    "binary_localization",
+    "fluorescence",
+    "fold",
+    "human_ppi",
+    "ppi_affinity",
+    "secondary_structure",
+    "solubility",
+    "stability",
+    "subcellular_localization",
+    "yeast_ppi"
+  ],
+  "ss_linear_context": 0,
+  "ss_calibrated": true,
+  "linear_heads": [],
+  "summary_readouts": [
+    "solubility",
+    "subcellular_localization",
+    "binary_localization",
+    "fold"
+  ],
+  "cosine_heads": {},
+  "nonlinear_summary_heads": {},
+  "calibrated_heads": [
+    "stability"
+  ],
+  "sequence_windows": [
+    "yeast_ppi",
+    "human_ppi"
+  ],
+  "expanded_pair_readouts": [
+    "yeast_ppi",
+    "human_ppi",
+    "ppi_affinity"
+  ],
+  "symmetric_pair_readouts": [
+    "yeast_ppi",
+    "ppi_affinity"
+  ],
+  "task_encoder_layers": {},
+  "task_conditioning": true,
+  "pair_summary_readouts": [],
+  "extension_layers": 2,
+  "window_pooling_training": true,
+  "batch_window_training": true,
+  "class_weight_power": {
+    "fold": 0.5
+  },
+  "task_extension_depths": {
+    "beta_lactamase": 2,
+    "binary_localization": 0,
+    "fluorescence": 0,
+    "fold": 0,
+    "human_ppi": 0,
+    "ppi_affinity": 0,
+    "secondary_structure": 0,
+    "solubility": 0,
+    "stability": 2,
+    "subcellular_localization": 0,
+    "yeast_ppi": 0
+  },
+  "task_max_len": {
+    "human_ppi": 1536
+  },
+  "pair_bilinear_rank": 32,
+  "pair_bilinear_tasks": [
+    "yeast_ppi"
+  ],
+  "pair_residue_interaction": {
+    "bins": 64,
+    "projection_dim": 32,
+    "pair_hidden": 32,
+    "pair_channels": 8,
+    "dropout": 0.1
+  },
+  "pair_residue_tasks": [
+    "yeast_ppi"
+  ],
+  "rank_target_tasks": [
+    "fluorescence",
+    "beta_lactamase"
+  ],
+  "ss_summary_readouts": [],
+  "terminal_summary_readouts": {},
+  "residue_lowrank_heads": {},
+  "shared_summary_residual": {
+    "tasks": [
+      "binary_localization"
+    ],
+    "hidden": 128,
+    "dropout": 0.2
+  },
+  "summary_residual_tasks": [
+    "binary_localization"
+  ]
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S053/esm2.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""An ESM-2 architecture, trained from scratch, as the reference baseline.
+
+Follows Lin et al. (Science 2023) / facebookresearch/esm in the ways that
+matter for a like-for-like architecture claim:
+
+  * rotary position embeddings, not learned positional embeddings -- this is
+    the defining architectural change from ESM-1b to ESM-2
+  * pre-LayerNorm blocks, GELU feed-forward at 4x expansion
+  * final LayerNorm before the LM head, and the LM head's projection weight
+    tied to the token embedding
+  * the ESM alphabet's special tokens (<cls>/<pad>/<eos>/<mask>) and the same
+    20 standard + rare amino-acid symbols
+
+The published size ladder is reproduced in CONFIGS so the baseline can be named
+by its ESM-2 counterpart rather than by an arbitrary width.
+"""
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ESM-2's alphabet, in its canonical order.
+SPECIALS = ["<cls>", "<pad>", "<eos>", "<unk>"]
+RESIDUES = list("LAGVSERTIDPKQNFYMHWCXBUZO")
+EXTRA = ["<null_1>", "<mask>"]
+ALPHABET = SPECIALS + RESIDUES + EXTRA
+TOKEN = {symbol: index for index, symbol in enumerate(ALPHABET)}
+CLS, PAD, EOS, UNK = TOKEN["<cls>"], TOKEN["<pad>"], TOKEN["<eos>"], TOKEN["<unk>"]
+MASK = TOKEN["<mask>"]
+VOCAB_SIZE = len(ALPHABET)
+FIRST_RESIDUE, LAST_RESIDUE = TOKEN["L"], TOKEN["O"]
+
+# name -> (layers, embed_dim, attention_heads), from the ESM-2 release table.
+CONFIGS = {
+    "esm2_t6_8M":    (6, 320, 20),
+    "esm2_t12_35M":  (12, 480, 20),
+    "esm2_t30_150M": (30, 640, 20),
+    "esm2_t33_650M": (33, 1280, 20),
+}
+
+
+def encode(sequence, max_len=1024):
+    body = [TOKEN.get(c, UNK) for c in sequence[:max_len - 2]]
+    return [CLS] + body + [EOS]
+
+
+def pad_batch(sequences, device):
+    width = max(len(s) for s in sequences)
+    out = torch.full((len(sequences), width), PAD, dtype=torch.long)
+    for row, ids in enumerate(sequences):
+        out[row, :len(ids)] = torch.tensor(ids, dtype=torch.long)
+    return out.to(device, non_blocking=True)
+
+
+class Rotary(nn.Module):
+    """Rotary position embedding, as ESM-2 applies it to q and k."""
+
+    def __init__(self, dim, base=10000):
+        super().__init__()
+        inverse = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inverse", inverse, persistent=False)
+        self._cached_length = 0
+
+    def _tables(self, length, device, dtype):
+        if length != self._cached_length or self._cos.device != device:
+            position = torch.arange(length, device=device, dtype=torch.float)
+            angles = torch.outer(position, self.inverse.to(device))
+            table = torch.cat([angles, angles], dim=-1)
+            self._cos = table.cos()[None, None]
+            self._sin = table.sin()[None, None]
+            self._cached_length = length
+        return self._cos.to(dtype), self._sin.to(dtype)
+
+    @staticmethod
+    def _rotate_half(x):
+        half = x.shape[-1] // 2
+        return torch.cat([-x[..., half:], x[..., :half]], dim=-1)
+
+    def forward(self, q, k):
+        cos, sin = self._tables(q.shape[-2], q.device, q.dtype)
+        return (q * cos + self._rotate_half(q) * sin,
+                k * cos + self._rotate_half(k) * sin)
+
+
+class Attention(nn.Module):
+    def __init__(self, dim, heads):
+        super().__init__()
+        self.heads = heads
+        self.head_dim = dim // heads
+        self.q = nn.Linear(dim, dim)
+        self.k = nn.Linear(dim, dim)
+        self.v = nn.Linear(dim, dim)
+        self.out = nn.Linear(dim, dim)
+        self.rotary = Rotary(self.head_dim)
+
+    def forward(self, x, pad_mask):
+        batch, length, _ = x.shape
+        shape = (batch, length, self.heads, self.head_dim)
+        q = self.q(x).view(shape).transpose(1, 2)
+        k = self.k(x).view(shape).transpose(1, 2)
+        v = self.v(x).view(shape).transpose(1, 2)
+        q, k = self.rotary(q, k)
+        attention_mask = None
+        if pad_mask is not None:
+            attention_mask = (~pad_mask)[:, None, None, :]
+        hidden = F.scaled_dot_product_attention(q, k, v, attn_mask=attention_mask)
+        hidden = hidden.transpose(1, 2).reshape(batch, length, -1)
+        return self.out(hidden)
+
+
+class Block(nn.Module):
+    def __init__(self, dim, heads, ffn):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim)
+        self.attention = Attention(dim, heads)
+        self.norm2 = nn.LayerNorm(dim)
+        self.ffn = nn.Sequential(nn.Linear(dim, ffn), nn.GELU(), nn.Linear(ffn, dim))
+
+    def forward(self, x, pad_mask, condition=None):
+        first = self.norm1(x)
+        if condition is not None:
+            first = first * (1 + condition[0]) + condition[1]
+        x = x + self.attention(first, pad_mask)
+        second = self.norm2(x)
+        if condition is not None:
+            second = second * (1 + condition[2]) + condition[3]
+        return x + self.ffn(second)
+
+
+class Encoder(nn.Module):
+    """The shared backbone. Every task reads from this one parameter set."""
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.dim = dim
+        self.embed = nn.Embedding(VOCAB_SIZE, dim, padding_idx=PAD)
+        self.blocks = nn.ModuleList([Block(dim, heads, dim * 4) for _ in range(layers)])
+        self.norm = nn.LayerNorm(dim)
+        self.lm_bias = nn.Parameter(torch.zeros(VOCAB_SIZE))
+        self.apply(self._init)
+
+    @staticmethod
+    def _init(module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, std=0.02)
+
+    def add_extension(self, layers, heads, before_norm=False):
+        """Append shared residual blocks after the original normalized representation."""
+        assert layers > 0 and not hasattr(self, 'extension')
+        self.extension_before_norm = bool(before_norm)
+        self.extension = nn.ModuleList([Block(self.dim, heads, 4*self.dim) for _ in range(layers)])
+        self.extension.apply(self._init)
+        # Identity at initialization preserves every existing readout exactly.
+        for block in self.extension:
+            nn.init.zeros_(block.attention.out.weight)
+            nn.init.zeros_(block.attention.out.bias)
+            nn.init.zeros_(block.ffn[2].weight)
+            nn.init.zeros_(block.ffn[2].bias)
+
+    def forward(self, tokens, condition=None, depth=None, extension_depth=None):
+        pad_mask = tokens.eq(PAD)
+        hidden = self.embed(tokens)
+        depth=len(self.blocks) if depth is None else int(depth)
+        if not 1<=depth<=len(self.blocks):
+            raise ValueError(f'Encoder depth {depth} is outside 1..{len(self.blocks)}')
+        for index, block in enumerate(self.blocks):
+            if index>=depth:
+                break
+            hidden = block(hidden, pad_mask, condition[index] if condition is not None else None)
+        # Local residue heads must not observe artificial states at padded
+        # positions; otherwise predictions near the C terminus depend on which
+        # other sequences share the batch. Valid transformer states are unchanged.
+        before_norm = getattr(self, 'extension_before_norm', False)
+        if not before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        extension = getattr(self, 'extension', ())
+        extension_depth = len(extension) if extension_depth is None else int(extension_depth)
+        if not 0 <= extension_depth <= len(extension):
+            raise ValueError(f'Extension depth {extension_depth} is outside 0..{len(extension)}')
+        for index, block in enumerate(extension):
+            if index >= extension_depth:
+                break
+            hidden = block(hidden, pad_mask).masked_fill(pad_mask.unsqueeze(-1), 0)
+        if before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        return hidden, pad_mask
+
+    def lm_logits(self, hidden):
+        # Weight tying, as in ESM-2's RobertaLMHead.
+        return F.linear(hidden, self.embed.weight) + self.lm_bias
+
+    def pool(self, tokens):
+        hidden, pad_mask = self.forward(tokens)
+        keep = (~pad_mask).to(hidden.dtype).unsqueeze(-1)
+        return (hidden * keep).sum(1) / keep.sum(1).clamp(min=1)
+
+
+class Model(nn.Module):
+    """ESM-2 backbone plus the eleven PEER task heads."""
+
+    CLASSES = {"solubility": 2, "subcellular_localization": 10,
+               "binary_localization": 2, "fold": 1195,
+               "yeast_ppi": 2, "human_ppi": 2}
+    REGRESSION = ("fluorescence", "stability", "beta_lactamase", "ppi_affinity")
+    PAIR = {"yeast_ppi", "human_ppi", "ppi_affinity"}
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.encoder = Encoder(layers=layers, dim=dim, heads=heads)
+        self.heads = nn.ModuleDict()
+        for task, n in self.CLASSES.items():
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, n))
+        for task in self.REGRESSION:
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 1))
+        self.heads["secondary_structure"] = nn.Sequential(
+            nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.PAIR:
+            a = self.encoder.pool(pad_batch(
+                [encode(x["sequence_a"], max_len) for x in batch], device))
+            b = self.encoder.pool(pad_batch(
+                [encode(x["sequence_b"], max_len) for x in batch], device))
+            return torch.cat([a, b], dim=-1)
+        return self.encoder.pool(pad_batch(
+            [encode(x["sequence"], max_len) for x in batch], device))
+
+
+def build(name="esm2_t12_35M"):
+    layers, dim, heads = CONFIGS[name]
+    model = Model(layers=layers, dim=dim, heads=heads)
+    return model, {"name": name, "layers": layers, "dim": dim, "heads": heads}
+
+
+if __name__ == "__main__":
+    for name in CONFIGS:
+        model, config = build(name)
+        backbone = sum(p.numel() for p in model.encoder.parameters())
+        total = sum(p.numel() for p in model.parameters())
+        print(f"{name:16s} backbone {backbone/1e6:7.2f}M   with heads {total/1e6:7.2f}M")

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S053/infer.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PYTHONDONTWRITEBYTECODE=1
+exec python3 "$(dirname "$0")/replay.py" "$1" "$2"

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S053/provenance.json

@@ -0,0 +1,291 @@
+{
+  "parent_package": "/workspace/research/production-stability-midpoint1/candidate/package",
+  "parent_sha256": "5a5e8f90a608f84f0592bad0213117ba9b3d056d6dc3feb325965a830f25a3e0",
+  "parent_provenance": {
+    "method": "Retain production model and replace only six stability head tensors with the accepted fit-only parameter midpoint.",
+    "production_parent": "/workspace/research/production-fullpool-summary1/candidate/package",
+    "production_parent_sha256": "195b60bcb0833ce75ed07c8846fb50ccd840c137ee4f4616d9c8b5d1427107a9",
+    "development": "/workspace/research/selected-stability-midpoint1/candidate/package",
+    "development_sha256": "e01ae99a458b5d8d2aba968e1efc663b3d346220fd16b5498a3f91b5cf29626c",
+    "parent_provenance": {
+      "method": "Retain every production tensor and add the accepted jointly trained nonlinear summary residual.",
+      "production_parent": "/workspace/research/production-fullpool-ss-distill64/candidate/package",
+      "production_parent_sha256": "37fc717aeb0cab3f68c4311ac9b5d6c8b0a56aecad738ab093bd4d986ea4c766",
+      "addition_source": "/workspace/research/shared-summary-residual1/candidate/package",
+      "addition_source_sha256": "f890eebb10bb2dc08b84c28e7e0378960af5df4fb0d646ab2e8b33e130c74202",
+      "added_parameters": 475906,
+      "parameters": 53000306,
+      "original_production_tensors_exact": true,
+      "one_shared_encoder_for_all_tasks": true,
+      "data": "Own from-scratch shared lineage; fit-only residual gradients and normalization; tune model selection. Fold/GFP/beta/affinity retain permitted fit+tune heads.",
+      "changed_tasks": [
+        "binary_localization"
+      ],
+      "tasks_reusing_tune_labels": [
+        "fold",
+        "fluorescence",
+        "beta_lactamase",
+        "ppi_affinity"
+      ],
+      "feature_cache_exported": false,
+      "inference_dependencies_outside_package": false
+    },
+    "development_provenance": {
+      "method": "One fixed 50:50 parameter midpoint of parent and fit-only 16-epoch stability head continuation; no ensemble.",
+      "source_parent": "/workspace/research/shared-summary-residual1/candidate/package",
+      "source_candidate": "/workspace/research/selected-stability-head64/candidate/package",
+      "source_model_sha256": {
+        "/workspace/research/shared-summary-residual1/candidate/package": "f890eebb10bb2dc08b84c28e7e0378960af5df4fb0d646ab2e8b33e130c74202",
+        "/workspace/research/selected-stability-head64/candidate/package": "8fe80a673a65650bb5769b1cf75a59f10a65961da91cc62a491094f874042c79"
+      },
+      "parent_provenance": {
+        "method": "One jointly learned nonlinear residual map over frozen shared sequence summaries, with task-specific zero-initialized outputs.",
+        "fit_tasks": [
+          "solubility",
+          "subcellular_localization",
+          "binary_localization"
+        ],
+        "selected_tasks": [
+          "binary_localization"
+        ],
+        "selected_global_step": 3000,
+        "source": "/workspace/research/ss-distillation-continuation1/candidate/package",
+        "export_base": "/workspace/research/ss-distillation-continuation1/candidate/package",
+        "export_base_model_sha256": "4fee0a0154af24665de9a95f11a722017f3fa6d92354475bec8e81235a219f00",
+        "rebased_SS_tensors": [],
+        "seed": 20270102,
+        "steps": 6000,
+        "lr": 0.001,
+        "weight_decay": 0.01,
+        "dropout": 0.2,
+        "data": "Fit only for gradients and existing normalization; Tune chooses oneglobalcheckpoint andresidualexits usingpredeclaredconditionalCIgate.",
+        "original_parameters_exact": true,
+        "parameters": 53000306,
+        "encoder_parameters": 44150303,
+        "feature_cache_exported": false
+      },
+      "fit_recipe": {
+        "seed": 20270129,
+        "epochs": 64,
+        "evaluate_epochs": [
+          4,
+          16,
+          32,
+          64
+        ],
+        "batch_size": 512,
+        "lr": 0.0001,
+        "weight_decay": 0.01,
+        "loss": "MSE to original fit-standardized stabilitylabels, matching selectedmodeltarget semantics;clip1;originaldropout active inbotharms;fixednormalizationbuffers. No newranktargetchange.",
+        "optimizer": "FreshCPUAdamW,cosine64epochs to0.1floor; matcheddataorder/dropoutRNG/updatecounts; per-epochatomicresume."
+      },
+      "source_selected_epoch": 16,
+      "diagnostic": {
+        "utc": "2026-10-25T13:39:33.197851+00:00",
+        "status": "CPU_diagnostic_complete_no_export",
+        "alpha": 0.5,
+        "points": {
+          "parent": 0.7226969980994319,
+          "midpoint": 0.7274924148853711,
+          "whole": 0.7274598466634085
+        },
+        "midpoint_delta_vs_parent": 0.004795416785939199,
+        "conditional95": [
+          0.0017412267324550784,
+          0.007940572842815559
+        ],
+        "draws": 1000,
+        "seed": 20270130,
+        "parameters": 53000306,
+        "six_changed_learned_tensors": [
+          "heads.stability.0.weight",
+          "heads.stability.0.bias",
+          "heads.stability.2.weight",
+          "heads.stability.2.bias",
+          "heads.stability.3.linear.weight",
+          "heads.stability.3.linear.bias"
+        ],
+        "all_other_tensors_and_buffers_exact": true,
+        "eligible_for_manual_complete_replay": true,
+        "publication": false,
+        "GPU_used": false,
+        "limitations": "Singlepredeclaredparameter midpoint, notpredictionensemble. Conditionalrowbootstrapuncorrectedforpriorcheckpointselectionandfamilydependence. CPUdiagnosticisnotan11taskreplay.",
+        "source_sha256": {
+          "/workspace/research/check_selected_stability_midpoint.py": "13615a5b2689a0bd503cbc8a9a8a722014962677f6769cec871e13aa5133ff77",
+          "/workspace/research/shared-summary-residual1/candidate/package/model.pt": "f890eebb10bb2dc08b84c28e7e0378960af5df4fb0d646ab2e8b33e130c74202",
+          "/workspace/research/selected-stability-head64/candidate/package/model.pt": "8fe80a673a65650bb5769b1cf75a59f10a65961da91cc62a491094f874042c79"
+        }
+      },
+      "data": "Fit-only labels and fixed normalization; tune selects epoch and evaluates one predeclared midpoint.",
+      "parameters": 53000306,
+      "feature_cache_exported": false
+    },
+    "parameters": 53000306,
+    "all_other_production_tensors_exact": true,
+    "data": "Mounted fit labels and own from-scratch shared encoder lineage; tune model selection for stability. Four prior fullpool heads retain their permitted fit+tune training and crossfit evidence.",
+    "tasks_reusing_tune_labels": [
+      "fold",
+      "fluorescence",
+      "beta_lactamase",
+      "ppi_affinity"
+    ],
+    "feature_cache_exported": false,
+    "inference_dependencies_outside_package": false
+  },
+  "fit_plan": {
+    "utc": "2026-10-25T16:08:33.461759+00:00",
+    "status": "queued",
+    "CPU_only": true,
+    "recovery_registered": false,
+    "source_package": "/workspace/research/selected-stability-midpoint1/candidate/package",
+    "source_report": "/workspace/research/selected-stability-midpoint1/candidate/report.json",
+    "features": "/workspace/research/rank-target-functions2/features-stability",
+    "feature_producer": "/workspace/research/rank-target-fluorescence1/candidate/package",
+    "arms": [
+      "natural",
+      "balanced"
+    ],
+    "expected_fit_lengths": [
+      43,
+      50
+    ],
+    "seed": 20270208,
+    "threads": 6,
+    "epochs": 16,
+    "batch_size": 512,
+    "lr": 0.0001,
+    "weight_decay": 0.01,
+    "alpha": 0.5,
+    "minimum_gain": 0.001,
+    "bootstrap_seed": 20270209,
+    "bootstrap_draws": 1000,
+    "hypothesis": "Natural stability fit data are68%43-residue proteins but all observed Tune chains have50residues. Equal loss mass for the two fit-length groups may reduce interference on the50-residue domain. This is a test prompted by visible Tune distribution, not evidence of benefit.",
+    "loss": "Original-fit-standardized-label MSE. Identical shuffled full-fit batches in both arms; natural unit weights; balanced weights N/(2*N_group), averaged over minibatch without per-batch renormalization. Both train all six existing head tensors, fixed feature-normalization buffers.",
+    "schedule": "FreshAdamW,16epochs/1680updates,cosine to0.1floor,clip1; originaldropoutactive with identical RNG and data order. Same current selected initial head.",
+    "selection": "Only one fixed50:50 parameter midpoint at the final16epoch endpoint per arm is eligible. Raw endpoints are descriptive. Require gain>=.001 and positive conditional95versus selected; balanced additionally requires positive conditional95versus natural control. No intermediate Tune selection, no seed/mixture grid. Manual review then full11 native replay before any publication.",
+    "all_task_policy": "Only six stabilityheadparameters may change. Shared encoder remains jointly learned for all11. All10otherparameters/config/outputfiles must remain exact on native replay. No automatic export or publication.",
+    "resume": "CPU per-epoch atomic optimizer/head/NumPy/torchRNG checkpoints; rerun same script after interruption. Planhash verified on resume.",
+    "recovery_command": [
+      "env",
+      "CUDA_VISIBLE_DEVICES=",
+      "OMP_NUM_THREADS=6",
+      "MKL_NUM_THREADS=6",
+      "OPENBLAS_NUM_THREADS=1",
+      "python3",
+      "-u",
+      "/workspace/research/run_stability_length_weighting.py",
+      "--run",
+      "/workspace/research/selected-stability-lengthweight1"
+    ],
+    "frozen_sha256": {
+      "/workspace/research/run_stability_length_weighting.py": "3c5aac6a79a1397e5c50278a7635e32d7c3583438f64996c8a42a372d16a29f6",
+      "/workspace/research/check_shared_adapters_cpu.py": "db7d8d846b90929decad5865de36dd55fb95139aaa116b6ae2987cd96786c990",
+      "/workspace/research/crossfit_beta_labels.py": "bd1d29e2ab78cb0273213ef1a00657cef450a91f155ba7d9aa7f3db7721bd632",
+      "/workspace/research/stability-length-shift-diagnostic.json": "36a890f702bb6709e893c5f9d94c5cf15959f83f4a91d71e58a7b5f681065f6d",
+      "/workspace/research/selected-stability-midpoint1/candidate/report.json": "feedb171d285a4fa4d3c2a2bdd819873caaad1308ef90fd59df9df1ace166827",
+      "/workspace/research/selected-stability-midpoint1/candidate/package/model.pt": "e01ae99a458b5d8d2aba968e1efc663b3d346220fd16b5498a3f91b5cf29626c",
+      "/workspace/research/selected-stability-midpoint1/candidate/package/config.json": "162a2f4985944bba7492854315bd594fd3a38386548ab1c6b0c7a4f0d2bd7625",
+      "/workspace/research/selected-stability-midpoint1/candidate/package/unified.py": "bb00abef5853bc8badfef6a8d38ef8cb11f0ff6d9fe143eb7deebd582058efa3",
+      "/workspace/research/selected-stability-midpoint1/candidate/package/esm2.py": "d4d512296047ebbd0f9a26dc1390107f72762cb5de011eefc9fecb18118a9be9",
+      "/workspace/research/selected-stability-midpoint1/candidate/package/replay.py": "9c5add2d3fb117470241cf63f621e4797a16962cddadbaad6de2cfb481e7fa85",
+      "/workspace/research/selected-stability-midpoint1/candidate/package/infer.sh": "60f55b73f5b39a35a61df84026abed9a127b1cc035d650c9e1ca62f54fc2b468",
+      "/workspace/research/rank-target-fluorescence1/candidate/package/model.pt": "a13dad3c4f0cd7a1917d5b6763b27aaf3d38f3b7d775e747b61241ea36b681e0",
+      "/workspace/research/rank-target-fluorescence1/candidate/package/config.json": "e3da1d0ea2df3e6d6cc8b069016bffca2a37fd05accf1597cc6453f946d8fd89",
+      "/workspace/research/rank-target-functions2/features-stability/stability-fit.pt": "3fde47645a74370a003dd5f509a73ccecbaaac36ce4e8871938979a003ba3862",
+      "/workspace/research/rank-target-functions2/features-stability/stability-tune.pt": "92066e0c8abfcfc4ac3b8f2c7edcc4319cb8f8b4b97b53dd6e589147a1c460bf"
+    }
+  },
+  "fit_outcome": {
+    "utc": "2026-10-25T16:08:53.918703+00:00",
+    "status": "cached_analysis_complete",
+    "arms": {
+      "natural": {
+        "arm": "natural",
+        "endpoint_reward": 0.7291215996959544,
+        "raw_reward_descriptive_only": 0.72991937369715,
+        "step": 1680,
+        "active_seconds": 5.326252081984421,
+        "final_numpy_rng": {
+          "bit_generator": "PCG64",
+          "state": {
+            "state": 264542032468656517169208881192101401107,
+            "inc": 100251262600960163324587047460976422035
+          },
+          "has_uint32": 1,
+          "uinteger": 637011686
+        },
+        "final_torch_rng_sha256": "fd56e05488c9ae31e940c2b1d859f13ca90497826206c0e3602aaba9c339ef52",
+        "optimizer_steps": [
+          1680.0
+        ],
+        "lr": 1.0000078679859099e-05,
+        "fixed_buffers_exact": true
+      },
+      "balanced": {
+        "arm": "balanced",
+        "endpoint_reward": 0.7311607642876724,
+        "raw_reward_descriptive_only": 0.7330130871638806,
+        "step": 1680,
+        "active_seconds": 5.340115340979537,
+        "final_numpy_rng": {
+          "bit_generator": "PCG64",
+          "state": {
+            "state": 264542032468656517169208881192101401107,
+            "inc": 100251262600960163324587047460976422035
+          },
+          "has_uint32": 1,
+          "uinteger": 637011686
+        },
+        "final_torch_rng_sha256": "fd56e05488c9ae31e940c2b1d859f13ca90497826206c0e3602aaba9c339ef52",
+        "optimizer_steps": [
+          1680.0
+        ],
+        "lr": 1.0000078679859099e-05,
+        "fixed_buffers_exact": true
+      }
+    },
+    "comparisons": {
+      "natural_vs_parent": {
+        "delta": 0.001629184810583273,
+        "conditional_95": [
+          0.00024683637661263025,
+          0.003237432482155497
+        ]
+      },
+      "balanced_vs_parent": {
+        "delta": 0.0036683494023013186,
+        "conditional_95": [
+          0.0019018632266723152,
+          0.0054815225624275
+        ]
+      },
+      "balanced_vs_natural": {
+        "delta": 0.0020391645917180456,
+        "conditional_95": [
+          0.0012832147204794586,
+          0.0028118185483942955
+        ]
+      }
+    },
+    "eligible_arms": [
+      "natural",
+      "balanced"
+    ],
+    "published": false,
+    "GPU_used": false,
+    "candidate_exported": false,
+    "matched_order_dropout_optimizer_clocks": true,
+    "ten_other_tasks": "No state edited; any proposed export must keep their parameters/configuration exact and independently replay all eleven.",
+    "limitations": "Conditional example bootstrap after repeated tune inspection; family dependence and selection uncertainty omitted. Tune length distribution informed this hypothesis. Raw endpoints are descriptive only. No full-pool or test-time fitting."
+  },
+  "changed_tensors": [
+    "heads.stability.0.weight",
+    "heads.stability.0.bias",
+    "heads.stability.2.weight",
+    "heads.stability.2.bias",
+    "heads.stability.3.linear.weight",
+    "heads.stability.3.linear.bias"
+  ],
+  "all_other_tensors_and_buffers_exact": true,
+  "method": "One fixed final balanced-length continuation midpoint; no output averaging or test-time fitting."
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S053/replay.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Self-contained replay shared by research evaluation and frozen packages."""
+import contextlib
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+
+import esm2
+
+TASKS = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+         'subcellular_localization', 'binary_localization', 'fold',
+         'secondary_structure', 'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+
+def autocast(device):
+    return torch.autocast('cuda', dtype=torch.bfloat16) if device.type == 'cuda' else contextlib.nullcontext()
+
+
+def head_output(model, task, representation, device, fp32=False):
+    apply = model.apply_head if hasattr(model, 'apply_head') else lambda task, value: model.heads[task](value)
+    if fp32:
+        with torch.autocast(device.type, enabled=False):
+            values={k:v.float() if v.is_floating_point() else v for k,v in representation.items()} if isinstance(representation,dict) else representation.float()
+            return apply(task, values).float()
+    return apply(task, representation).float()
+
+
+def residue_states(model, tokens, task):
+    return model.encode_residues(tokens, task) if hasattr(model, 'encode_residues') else model.encoder(tokens)
+
+
+def windows(length, width=1022, stride=768):
+    if length <= width:
+        return [(0, length)]
+    starts = list(range(0, length - width + 1, stride))
+    if starts[-1] != length - width:
+        starts.append(length - width)
+    return [(s, min(s + width, length)) for s in starts]
+
+
+def batches(rows, task, token_budget=16384, max_len=1024, max_batch=128):
+    lengths = [min(max(map(len, r['features'].values())) + 2, max_len) for r in rows]
+    order = sorted(range(len(rows)), key=lengths.__getitem__)
+    current, width = [], 0
+    for i in order:
+        length = lengths[i]
+        # Pair sequences require two separate passes, but the peak tensor size is unchanged.
+        if current and (max(width, length) * (len(current) + 1) > token_budget or len(current) >= max_batch):
+            yield current
+            current, width = [], 0
+        current.append(i)
+        width = max(width, length)
+    if current:
+        yield current
+
+
+@torch.inference_mode()
+def predict_records(model, rows, task, device, config=None, token_budget=16384):
+    config = config or {}
+    max_len = config.get('task_max_len', {}).get(task, config.get('max_len', 1024))
+    full_ss = config.get('full_ss', True)
+    fp32_option = config.get('fp32_heads', False)
+    fp32_heads = fp32_option is True or (isinstance(fp32_option, list) and task in fp32_option)
+    was_training = model.training
+    model.eval()
+    result = {}
+    for ids in batches(rows, task, token_budget, max_len):
+        chunk = [rows[i] for i in ids]
+        features = [r['features'] for r in chunk]
+        if task == 'secondary_structure':
+            if full_ss and any(len(f['sequence']) > max_len - 2 for f in features):
+                for record in chunk:
+                    seq = record['features']['sequence']
+                    pieces = windows(len(seq), max_len - 2, min(768, max_len - 2))
+                    total = np.zeros((len(seq), 3), dtype=np.float32)
+                    weight_sum = np.zeros((len(seq), 1), dtype=np.float32)
+                    for begin in range(0, len(pieces), max(1, token_budget // max_len)):
+                        part = pieces[begin:begin + max(1, token_budget // max_len)]
+                        tokens = esm2.pad_batch([esm2.encode(seq[s:e], max_len) for s, e in part], device)
+                        with autocast(device):
+                            hidden, _ = residue_states(model, tokens, task)
+                            logits = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                        for j, (s, e) in enumerate(part):
+                            size = e - s
+                            # Smooth boundaries, without discarding any residue.
+                            weight = np.minimum(np.arange(1, size + 1), np.arange(size, 0, -1))
+                            weight = np.minimum(weight, 128).astype(np.float32)[:, None]
+                            total[s:e] += logits[j, 1:1+size] * weight
+                            weight_sum[s:e] += weight
+                    scores = total / np.maximum(weight_sum, 1)
+                    result[record['example_id']] = {'ss3_scores': scores.tolist()}
+            else:
+                tokens = esm2.pad_batch([esm2.encode(f['sequence'], max_len) for f in features], device)
+                with autocast(device):
+                    hidden, _ = residue_states(model, tokens, task)
+                    probabilities = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                for j, record in enumerate(chunk):
+                    length = len(record['features']['sequence'])
+                    used = min(length, max_len - 2)
+                    scores = probabilities[j, 1:1+used].tolist()
+                    scores.extend([[1.0, 1.0, 1.0] for _ in range(length-used)])
+                    result[record['example_id']] = {'ss3_scores': scores}
+            continue
+        with autocast(device):
+            representation = model.represent(task, features, device, max_len)
+            output = head_output(model, task, representation, device, fp32_heads)
+            if task in model.CLASSES:
+                output = output.softmax(-1)
+            if task in config.get('symmetric_pairs', []):
+                swapped = [{'sequence_a': f['sequence_b'], 'sequence_b': f['sequence_a']} for f in features]
+                swapped_rep = model.represent(task, swapped, device, max_len)
+                second = head_output(model, task, swapped_rep, device, fp32_heads)
+                if task in model.CLASSES:
+                    second = second.softmax(-1)
+                output = (output + second) * 0.5
+            if task in model.CLASSES:
+                output = output.clamp_min(1e-9)
+            elif hasattr(model, 'unscale'):
+                output = model.unscale(task, output)
+        values = output.cpu().tolist()
+        for record, value in zip(chunk, values):
+            result[record['example_id']] = {'scores': value} if task in model.CLASSES else {'value': value[0]}
+    if task == 'secondary_structure' and hasattr(model, 'ss_chain_decoder'):
+        # Decode complete chains only after all overlapping-window probabilities
+        # have been aggregated. No labels or parameter updates enter replay.
+        identifiers = [record['example_id'] for record in rows]
+        probabilities = [result[identifier]['ss3_scores'] for identifier in identifiers]
+        decoded = model.ss_chain_decoder.decode(probabilities)
+        for identifier, scores in zip(identifiers, decoded):
+            result[identifier] = {'ss3_scores': scores.tolist()}
+    model.train(was_training)
+    return result
+
+
+def load_model(package, device):
+    config = json.loads((package / 'config.json').read_text())
+    if config.get('architecture') == 'unified':
+        from unified import UnifiedModel
+        model = UnifiedModel(config)
+    else:
+        model = esm2.Model(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+    model.load_state_dict(torch.load(package / 'model.pt', map_location='cpu', weights_only=True))
+    return model.to(device).eval(), config
+
+
+def main():
+    if len(sys.argv) != 3:
+        raise SystemExit('usage: replay.py INPUT_ROOT OUTPUT_ROOT')
+    torch.set_num_threads(6)
+    source, destination = Path(sys.argv[1]), Path(sys.argv[2]) / 'predictions'
+    destination.mkdir(parents=True, exist_ok=True)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model, config = load_model(Path(__file__).resolve().parent, device)
+    for task in TASKS:
+        rows = [json.loads(line) for line in (source / f'{task}.jsonl').open()]
+        predictions = predict_records(model, rows, task, device, config)
+        with (destination / f'{task}.jsonl').open('w') as sink:
+            for row in rows:
+                sink.write(json.dumps({'example_id': row['example_id'], 'prediction': predictions[row['example_id']]}, separators=(',', ':')) + '\n')
+
+
+if __name__ == '__main__':
+    main()

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S053/selection.json

@@ -0,0 +1,46 @@
+{
+  "score_kind": "tune_labels_used_for_fold_fluorescence_beta_lactamase_and_ppi_affinity",
+  "tasks_reusing_tune_labels": [
+    "fold",
+    "fluorescence",
+    "beta_lactamase",
+    "ppi_affinity"
+  ],
+  "fit_only_development_reward": 0.7166638090200526,
+  "stability_fit_only_evidence": {
+    "kind": "fit_only_complete_tune_replay",
+    "task": "stability",
+    "before": 0.7274923808177973,
+    "after": 0.7311607642876724,
+    "delta": 0.0036683834698750806,
+    "conditional_95_percentile_interval": [
+      0.0017767471141417273,
+      0.00544199745819068
+    ],
+    "examples": 2512,
+    "mean_delta": 0.0003334894063522801,
+    "conditional_mean95": [
+      0.0001615224649219752,
+      0.0004947270416536983
+    ],
+    "matched_natural_mixture_control": {
+      "delta": 0.0020391645917180456,
+      "conditional_95": [
+        0.0012832147204794586,
+        0.0028118185483942955
+      ]
+    },
+    "fixed_endpoint_updates": 1680,
+    "alpha": 0.5,
+    "ten_other_prediction_files_exact": true,
+    "limitations": "Conditional on already-selected models. Does not account for repeated tune selection, shared proteins across tasks, or family dependence within splits; not an independent generalization guarantee. The visible Tune length distribution informed the group-weighting hypothesis."
+  },
+  "production_aggregate_excluded_from_selection": true,
+  "pending_independent_replay": false,
+  "stability_length_weighting": "balanced",
+  "stability_weighting_endpoint_epochs": 16,
+  "stability_weighting_parameter_midpoint": 0.5,
+  "independent_replay_verified": true,
+  "other_ten_predictions_exact_previous_production": true,
+  "stability_predictions_exact_accepted_development": true
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S053/unified.py

@@ -0,0 +1,643 @@
+"""One jointly learned protein encoder, shared pooling, and eleven small heads."""
+import math
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import esm2
+
+
+class NormalizedLinear(nn.Module):
+    def __init__(self, width, outputs=1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs)
+
+    def forward(self, values):
+        return self.linear((values - self.mean) / self.scale)
+
+
+class LowRankPositionHead(nn.Module):
+    """A shared residue projection followed by an ordered position readout."""
+    def __init__(self, dim, bins, rank, outputs=1):
+        super().__init__()
+        assert 0 < rank <= min(dim, bins)
+        self.dim = dim
+        self.project = nn.Linear(dim, rank, bias=False)
+        self.output = nn.Linear(bins * rank, outputs)
+
+    def forward(self, values):
+        residues = values.reshape(values.shape[0], -1, self.dim)
+        return self.output(self.project(residues).flatten(1))
+
+
+class NormalizedCosine(nn.Module):
+    def __init__(self, width, outputs, temperature=20.):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs, bias=False)
+        self.temperature = temperature
+
+    def forward(self, values):
+        features = F.normalize((values-self.mean)/self.scale, dim=-1)
+        return F.linear(features, F.normalize(self.linear.weight, dim=-1))*self.temperature
+
+
+class NormalizedMLP(nn.Module):
+    def __init__(self, width, outputs, hidden=128, dropout=.1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(), nn.LayerNorm(hidden),
+                                     nn.Dropout(dropout), nn.Linear(hidden, outputs))
+
+    def forward(self, values):
+        return self.network((values-self.mean)/self.scale)
+
+
+class SharedSummaryResidual(nn.Module):
+    """One nonlinear summary map jointly used by several classification heads."""
+    def __init__(self, width, hidden, dropout, classes):
+        super().__init__()
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(),
+                                     nn.LayerNorm(hidden), nn.Dropout(dropout),
+                                     nn.Linear(hidden, hidden), nn.GELU(), nn.Dropout(dropout))
+        self.heads = nn.ModuleDict({task: nn.Linear(hidden, outputs)
+                                   for task, outputs in sorted(classes.items())})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, normalized_summary):
+        return self.heads[task](self.network(normalized_summary))
+
+
+class NormalizedResidueLinear(nn.Module):
+    def __init__(self, dim, kernel=9):
+        super().__init__()
+        assert kernel > 0 and kernel % 2 == 1
+        self.kernel = kernel
+        self.readout = NormalizedLinear(dim * kernel, 3)
+
+    @staticmethod
+    def features(hidden, kernel):
+        padded = F.pad(hidden.float().transpose(1, 2), (kernel // 2, kernel // 2))
+        return padded.unfold(-1, kernel, 1).transpose(1, 2).flatten(2)
+
+    def forward(self, hidden):
+        return self.readout(self.features(hidden, self.kernel))
+
+
+class LocalResidueHead(nn.Sequential):
+    """Preserve the original four head parameter names; add a local residual."""
+    def __init__(self, dim):
+        super().__init__(nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+        self.context = nn.Sequential(nn.Conv1d(dim, dim, 9, padding=4, groups=dim),
+                                     nn.GELU(), nn.Conv1d(dim, dim, 1))
+        nn.init.zeros_(self.context[-1].weight)
+        nn.init.zeros_(self.context[-1].bias)
+
+    def forward(self, x):
+        x = x + self.context(x.transpose(1, 2)).transpose(1, 2)
+        for i in range(4):
+            x = self[i](x)
+        return x
+
+
+class CalibratedLocalResidueHead(LocalResidueHead):
+    def __init__(self, dim):
+        super().__init__(dim)
+        self[3] = NormalizedLinear(dim, 3)
+
+
+class ResidualSequenceConvHead(nn.Module):
+    """Learn local sequence motifs alongside the retained summary classifier."""
+    def __init__(self, dim, outputs, channels=128, dropout=.2, retain_summary=True):
+        super().__init__()
+        self.base = NormalizedLinear(7 * dim, outputs) if retain_summary else None
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, channels)
+        self.convs = nn.ModuleList([nn.Conv1d(channels, channels, k, padding=k//2) for k in (3,9)])
+        self.norms = nn.ModuleList([nn.LayerNorm(channels) for _ in self.convs])
+        self.output = nn.Linear(4 * channels, outputs)
+        nn.init.zeros_(self.output.weight);nn.init.zeros_(self.output.bias)
+        self.dropout = dropout
+
+    def forward(self, features):
+        valid = features['valid'].bool().unsqueeze(-1)
+        x = F.gelu(self.project((features['hidden']-self.mean)/self.scale)) * valid
+        summaries = []
+        for conv,norm in zip(self.convs,self.norms):
+            y = norm(F.gelu(conv(x.transpose(1,2)).transpose(1,2)))
+            center = (y*valid).sum(1)/valid.sum(1).clamp_min(1)
+            maximum = y.masked_fill(~valid,-1e4).amax(1)
+            maximum = torch.where(valid.any(1),maximum,torch.zeros_like(maximum))
+            summaries.extend([center,maximum])
+        pooled = F.dropout(torch.cat(summaries,dim=-1),self.dropout,self.training)
+        logits=self.output(pooled)
+        return self.base(features['summary']) + logits if self.base is not None else logits
+
+
+class TokenLogMeanExpHead(nn.Module):
+    """Class-specific local evidence, pooled without sequence-length bias."""
+    def __init__(self, dim, outputs):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.linear = nn.Linear(dim, outputs)
+
+    def forward(self, representation):
+        values, valid = representation['hidden'].float(), representation['valid']
+        logits = self.linear((values-self.mean)/self.scale)
+        logits = logits.masked_fill(~valid.unsqueeze(-1), -torch.inf)
+        return torch.logsumexp(logits, 1)-valid.sum(1).clamp_min(1).float().log()[:, None]
+
+    def packed(self, values, lengths):
+        """Equivalent unpadded computation for frozen-feature readout fitting."""
+        logits = self.linear((values.float()-self.mean)/self.scale)
+        # The stabilizing maximum cancels in the derivative; detach avoids
+        # retaining another large token-by-class gradient path.
+        maximum = torch.segment_reduce(logits.detach(), 'max', lengths=lengths)
+        index = torch.repeat_interleave(torch.arange(len(lengths), device=lengths.device), lengths,
+                                        output_size=len(values))
+        exponent = (logits-maximum[index]).exp()
+        total = torch.segment_reduce(exponent, 'sum', lengths=lengths)
+        return maximum+total.log()-lengths.float().log()[:, None]
+
+
+class SharedPairResidueInteraction(nn.Module):
+    """A shared nonlinear comparison of local states from both protein chains."""
+    def __init__(self, dim, settings, classes):
+        super().__init__()
+        width, hidden, channels = (settings[k] for k in ['projection_dim', 'pair_hidden', 'pair_channels'])
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, width)
+        self.compare = nn.Sequential(nn.Linear(2*width, hidden), nn.GELU(),
+                                     nn.Linear(hidden, channels), nn.GELU())
+        self.dropout = settings['dropout']
+        self.heads = nn.ModuleDict({task: nn.Linear(2*channels, classes.get(task, 1))
+                                   for task in sorted(esm2.Model.PAIR)})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, first, second):
+        first = F.gelu(self.project((first-self.mean)/self.scale))
+        second = F.gelu(self.project((second-self.mean)/self.scale))
+        first = F.dropout(first, self.dropout, self.training)
+        second = F.dropout(second, self.dropout, self.training)
+        pair = torch.cat([(first[:, :, None]-second[:, None, :]).abs(),
+                          first[:, :, None]*second[:, None, :]], dim=-1)
+        local = self.compare(pair)
+        summary = torch.cat([local.mean((1, 2)), local.amax((1, 2))], dim=-1)
+        return self.heads[task](summary)
+
+
+class SSChainDecoder(nn.Module):
+    """Small learned label-compatibility model, applied to frozen residue unaries."""
+    def __init__(self):
+        super().__init__()
+        self.transition = nn.Parameter(torch.empty(3, 3))
+        self.start = nn.Parameter(torch.empty(3))
+        self.end = nn.Parameter(torch.empty(3))
+        for parameter in self.parameters():
+            nn.init.normal_(parameter, std=.01)
+
+    def decode(self, probabilities):
+        from ss_chain import decode_probabilities
+        values = [parameter.detach().double().cpu().numpy()
+                  for parameter in (self.transition, self.start, self.end)]
+        return decode_probabilities(probabilities, *values)
+
+
+class UnifiedModel(esm2.Model):
+    TASK_ORDER = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+                  'subcellular_localization', 'binary_localization', 'fold',
+                  'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+    def __init__(self, config):
+        super().__init__(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+        self.config = config
+        self.task_index = {t: i for i, t in enumerate(self.TASK_ORDER)}
+        dim = config['dim']
+        if config.get('extension_layers', 0):
+            self.encoder.add_extension(config['extension_layers'], config['heads'],
+                                       before_norm=config.get('extension_before_norm', False))
+        if config.get('task_conditioning', False):
+            self.task_condition = nn.Parameter(torch.zeros(11, config['layers'], 4, dim))
+        if config.get('pooling', 'mean') == 'rich':
+            self.pool_query = nn.Parameter(torch.randn(len(self.TASK_ORDER), 2, dim) * 0.02)
+            self.pool_position = nn.Parameter(torch.zeros(len(self.TASK_ORDER), 2, 4))
+            # Shared across tasks, with a zero initial residual for safe lineage transfer.
+            self.pool_fuse = nn.Linear(6 * dim, dim)
+            nn.init.zeros_(self.pool_fuse.weight)
+            nn.init.zeros_(self.pool_fuse.bias)
+        if config.get('pair_interaction', False):
+            self.pair_fuse = nn.Linear(2 * dim, 2 * dim)
+            nn.init.zeros_(self.pair_fuse.weight)
+            nn.init.zeros_(self.pair_fuse.bias)
+        if config.get('ss_context', False):
+            self.heads['secondary_structure'] = LocalResidueHead(dim)
+        for task in config.get('linear_heads', []):
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(nn.Linear(width, self.CLASSES.get(task, 1)))
+        for task, settings in config.get('residue_readouts', {}).items():
+            self.heads[task] = NormalizedLinear(settings['bins'] * dim, self.CLASSES.get(task, 1))
+        for task, rank in config.get('residue_lowrank_heads', {}).items():
+            bins = config['residue_readouts'][task]['bins']
+            self.heads[task] = LowRankPositionHead(dim, bins, rank, self.CLASSES.get(task, 1))
+        for task in config.get('summary_readouts', []):
+            assert task not in self.PAIR and config.get('pooling') == 'rich'
+            self.heads[task] = NormalizedLinear(7 * dim, self.CLASSES.get(task, 1))
+        for task in config.get('sequence_composition_readouts', []):
+            from sequence_composition import WIDTH
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES
+            assert all(task not in config.get(key,[]) for key in
+                       ['cosine_heads','nonlinear_summary_heads','ss_summary_readouts',
+                        'sequence_conv_readouts','terminal_summary_readouts','token_logmeanexp_heads'])
+            self.heads[task] = NormalizedLinear(7 * dim + WIDTH, self.CLASSES[task])
+        for task, temperature in config.get('cosine_heads', {}).items():
+            assert task in config.get('summary_readouts', [])
+            self.heads[task] = NormalizedCosine(7*dim, self.CLASSES[task], temperature)
+        for task, settings in config.get('nonlinear_summary_heads', {}).items():
+            assert task in config.get('summary_readouts', []) and task not in config.get('cosine_heads', {})
+            self.heads[task] = NormalizedMLP(7*dim, self.CLASSES.get(task,1), settings['hidden'], settings['dropout'])
+        for task in config.get('calibrated_heads', []):
+            assert task not in config.get('summary_readouts', []) and task not in config.get('residue_readouts', {})
+            assert task not in config.get('linear_heads', [])
+            self.heads[task][3] = NormalizedLinear(dim, self.CLASSES.get(task,1))
+        for task in config.get('expanded_pair_readouts', []):
+            assert task in self.PAIR
+            width=3 if task in config.get('symmetric_pair_readouts',[]) else 4
+            if task in config.get('pair_summary_readouts', []):
+                assert config.get('pooling') == 'rich'
+                width *= 8
+            self.heads[task] = NormalizedLinear(width*dim, self.CLASSES.get(task,1))
+        if config.get('ss_linear_context'):
+            self.heads['secondary_structure'] = NormalizedResidueLinear(dim, config['ss_linear_context'])
+        if config.get('ss_calibrated'):
+            assert not config.get('ss_linear_context')
+            self.heads['secondary_structure'] = CalibratedLocalResidueHead(dim)
+        for task in config.get('ss_summary_readouts', []):
+            assert task in config.get('summary_readouts', []) and task not in self.PAIR
+            self.heads[task] = NormalizedLinear(7*dim+40, self.CLASSES[task])
+        for task,settings in config.get('sequence_conv_readouts',{}).items():
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES and task not in self.PAIR
+            self.heads[task] = ResidualSequenceConvHead(dim,self.CLASSES[task],settings['channels'],settings['dropout'],settings.get('retain_summary',True))
+        for task, settings in config.get('terminal_summary_readouts', {}).items():
+            assert task in config.get('summary_readouts', []) and task in self.CLASSES and task not in self.PAIR
+            assert all(task not in config.get(key, {}) for key in
+                       ['cosine_heads', 'nonlinear_summary_heads', 'ss_summary_readouts', 'sequence_conv_readouts'])
+            bins = settings['bins']
+            assert bins > 0 and all(settings[key] > 0 and settings[key] % bins == 0
+                                    for key in ['prefix_residues', 'suffix_residues'])
+            self.heads[task] = NormalizedLinear((7+2*bins)*dim, self.CLASSES[task])
+        if config.get('pair_bilinear_rank', 0):
+            rank = config['pair_bilinear_rank']
+            assert not config.get('pair_summary_readouts')
+            self.pair_bilinear_projection = nn.Linear(dim, rank, bias=False)
+            nn.init.normal_(self.pair_bilinear_projection.weight, std=dim ** -.5)
+            with torch.no_grad():
+                self.pair_bilinear_projection.weight.copy_(F.normalize(self.pair_bilinear_projection.weight, dim=1))
+            self.pair_bilinear_heads = nn.ModuleDict({
+                task: nn.Linear(rank, self.CLASSES.get(task, 1), bias=False)
+                for task in sorted(self.PAIR)})
+            for head in self.pair_bilinear_heads.values():
+                nn.init.zeros_(head.weight)
+            self.register_buffer('pair_bilinear_mean', torch.zeros(dim))
+            self.register_buffer('pair_bilinear_scale', torch.ones(dim))
+        if config.get('pair_residue_interaction'):
+            self.pair_residue_interaction = SharedPairResidueInteraction(
+                dim, config['pair_residue_interaction'], self.CLASSES)
+        for task in config.get('token_logmeanexp_heads', []):
+            assert task in self.CLASSES and task not in self.PAIR
+            assert task not in config.get('sequence_windows', [])
+            self.heads[task] = TokenLogMeanExpHead(dim, self.CLASSES[task])
+        if config.get('ss_chain_decoder', False):
+            self.ss_chain_decoder = SSChainDecoder()
+        if config.get('shared_summary_residual'):
+            settings = config['shared_summary_residual']
+            tasks = settings['tasks']
+            assert all(task in config.get('summary_readouts', []) and
+                       isinstance(self.heads[task], NormalizedLinear) for task in tasks)
+            self.summary_residual = SharedSummaryResidual(7*dim, settings['hidden'], settings['dropout'],
+                                                          {task: self.CLASSES[task] for task in tasks})
+
+    def pair_representation(self, task, first, second, base):
+        if task in self.config.get('pair_bilinear_tasks', []):
+            return {'base': base, 'chain_a': first, 'chain_b': second}
+        return base
+
+    def apply_head(self, task, representation):
+        if task in self.config.get('summary_residual_tasks', []):
+            head = self.heads[task]
+            normalized = (representation-head.mean)/head.scale
+            return head(representation) + self.summary_residual(task, normalized)
+        if isinstance(representation, dict) and 'residue_a' in representation:
+            base = {k:v for k,v in representation.items() if k not in ['residue_a', 'residue_b']}
+            original = self.apply_head(task, base if 'chain_a' in base else base['base'])
+            return original + self.pair_residue_interaction(task, representation['residue_a'], representation['residue_b'])
+        if isinstance(representation, dict) and 'chain_a' in representation:
+            first = (representation['chain_a'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            second = (representation['chain_b'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            interaction = self.pair_bilinear_projection(first) * self.pair_bilinear_projection(second)
+            interaction = interaction / math.sqrt(self.config['pair_bilinear_rank'])
+            return self.heads[task](representation['base']) + self.pair_bilinear_heads[task](interaction)
+        return self.heads[task](representation)
+
+    def encode_residues(self, tokens, task):
+        condition = None
+        if self.config.get('task_conditioning', False):
+            ti = 10 if task == 'secondary_structure' else self.task_index[task]
+            condition = self.task_condition[ti]
+        return self.encoder(tokens, condition=condition, depth=self.config.get('task_encoder_layers',{}).get(task),
+                            extension_depth=self.config.get('task_extension_depths',{}).get(task))
+
+    def pool(self, tokens, task):
+        hidden, pad_mask = self.encode_residues(tokens, task)
+        return self.summarize(hidden, tokens, pad_mask, task)
+
+    def summarize(self, hidden, tokens, pad_mask, task):
+        valid = (~pad_mask).unsqueeze(-1)
+        mean = (hidden * valid).sum(1) / valid.sum(1).clamp_min(1)
+        if self.config.get('pooling', 'mean') == 'mean':
+            return mean
+        residues = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+        # Empty/nonstandard-only inputs still produce a finite representation.
+        residues[:, 0] |= ~residues.any(1)
+        keep = residues.unsqueeze(-1)
+        count = keep.sum(1).clamp_min(1)
+        center = (hidden * keep).sum(1) / count
+        position = residues.cumsum(1).to(hidden.dtype) / count.to(hidden.dtype)
+        basis = torch.stack([position, position.square(), torch.sin(position * math.pi),
+                             torch.cos(position * math.pi)], dim=-1)
+        ti = self.task_index[task]
+        scores = torch.einsum('bld,qd->blq', hidden, self.pool_query[ti]) / math.sqrt(hidden.shape[-1])
+        scores = scores + torch.einsum('blp,qp->blq', basis, self.pool_position[ti])
+        scores = scores.masked_fill(~residues.unsqueeze(-1), -1e4)
+        attention = torch.einsum('blq,bld->bqd', scores.softmax(1), hidden)
+        variance = ((hidden - center[:, None]).float().square() * keep).sum(1) / count
+        deviation = (variance + 1e-5).sqrt().to(hidden.dtype)
+        maximum = hidden.masked_fill(~keep, -1e4).amax(1) - center
+        first = residues & (residues.cumsum(1) <= 32)
+        last = residues & ((residues.sum(1, keepdim=True) - residues.cumsum(1)) < 32)
+        prefix = (hidden * first.unsqueeze(-1)).sum(1) / first.sum(1, keepdim=True).clamp_min(1) - center
+        suffix = (hidden * last.unsqueeze(-1)).sum(1) / last.sum(1, keepdim=True).clamp_min(1) - center
+        summary = torch.cat([attention[:, 0] - center, attention[:, 1] - center,
+                             deviation, maximum, prefix, suffix], dim=-1)
+        if task in self.config.get('summary_readouts', []):
+            return torch.cat([mean, summary], dim=-1)
+        if task in self.config.get('pair_summary_readouts', []):
+            return torch.cat([mean + self.pool_fuse(summary), mean, summary], dim=-1)
+        return mean + self.pool_fuse(summary)
+
+    def pool_sequences(self, sequences, task, device, max_len):
+        if self.training and not self.config.get('window_pooling_training', True):
+            tokens=esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device)
+            return self.pool(tokens,task)
+        if task not in self.config.get('sequence_windows', []) or not any(len(s)>max_len-2 for s in sequences):
+            return self.pool(esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device),task)
+        results=[None]*len(sequences)
+        short=[i for i,s in enumerate(sequences) if len(s)<=max_len-2]
+        if short:
+            pooled=self.pool(esm2.pad_batch([esm2.encode(sequences[i],max_len) for i in short],device),task)
+            for j,index in enumerate(short):results[index]=pooled[j]
+        width=max_len-2;stride=min(768,width)
+        if self.training and self.config.get('batch_window_training',False):
+            pieces=[];starts_by_index={};encoded={}
+            for index,sequence in enumerate(sequences):
+                if len(sequence)<=width:continue
+                starts=list(range(0,len(sequence)-width+1,stride))
+                if starts[-1]!=len(sequence)-width:starts.append(len(sequence)-width)
+                starts_by_index[index]=starts
+                pieces.extend((index,start) for start in starts)
+            count=max(1,16384//max_len)
+            for begin in range(0,len(pieces),count):
+                part=pieces[begin:begin+count]
+                tokens=esm2.pad_batch([esm2.encode(sequences[i][s:s+width],max_len) for i,s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,key in enumerate(part):encoded[key]=hidden[j]
+            positions=torch.arange(width,device=device)
+            weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+            for index,starts in starts_by_index.items():
+                sequence=sequences[index];length=len(sequence)
+                total=torch.zeros(length,self.config['dim'],device=device);counts=torch.zeros(length,1,device=device)
+                for start in starts:
+                    total.index_add_(0,positions+start,encoded[index,start][1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+                assembled=torch.cat([encoded[index,starts[0]][0:1],total/counts.clamp_min(1),encoded[index,starts[-1]][width+1:width+2]],dim=0)[None]
+                tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+                results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+            return torch.stack(results)
+        for index,sequence in enumerate(sequences):
+            length=len(sequence)
+            if length<=width:continue
+            starts=list(range(0,length-width+1,stride))
+            if starts[-1]!=length-width:starts.append(length-width)
+            total=torch.zeros(length,self.config['dim'],device=device)
+            counts=torch.zeros(length,1,device=device)
+            first=last=None
+            for begin in range(0,len(starts),max(1,16384//max_len)):
+                part=starts[begin:begin+max(1,16384//max_len)]
+                tokens=esm2.pad_batch([esm2.encode(sequence[s:s+width],max_len) for s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,start in enumerate(part):
+                    if start==0:first=hidden[j,0:1]
+                    if start==starts[-1]:last=hidden[j,width+1:width+2]
+                    positions=torch.arange(width,device=device)
+                    weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+                    total.index_add_(0,positions+start,hidden[j,1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+            assembled=torch.cat([first,total/counts.clamp_min(1),last],dim=0)[None]
+            tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+            results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+        return torch.stack(results)
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.config.get('sequence_composition_readouts', []):
+            from sequence_composition import composition_features
+            sequences=[item['sequence'] for item in batch]
+            pooled=self.pool_sequences(sequences,task,device,max_len)
+            return torch.cat([pooled.float(),composition_features(sequences,device)],-1)
+        if task in self.config.get('token_logmeanexp_heads', []):
+            tokens = esm2.pad_batch([esm2.encode(row['sequence'], max_len) for row in batch], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            valid = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+            valid[:, 0] |= ~valid.any(1)
+            return {'hidden':hidden, 'valid':valid}
+        if task in self.config.get('terminal_summary_readouts', {}):
+            return self.terminal_summary_features(task, [item['sequence'] for item in batch], device, max_len)
+        if task in self.config.get('ss_summary_readouts', []):
+            sequences=[x['sequence'] for x in batch]
+            summary=self.pool_sequences(sequences,task,device,max_len)
+            structure=self.secondary_structure_summary(sequences,device,max_len)
+            return torch.cat([summary.float(),structure],-1)
+        if task in self.config.get('sequence_conv_readouts',{}):
+            tokens=esm2.pad_batch([esm2.encode(x['sequence'],max_len) for x in batch],device)
+            hidden,pad_mask=self.encode_residues(tokens,task)
+            lengths=torch.tensor([min(len(x['sequence']),max_len-2) for x in batch],device=device)
+            width=max(1,int(lengths.max()))
+            valid=torch.arange(width,device=device)[None,:]<lengths[:,None]
+            return {'hidden':hidden[:,1:1+width], 'valid':valid,
+                    'summary':self.summarize(hidden,tokens,pad_mask,task)}
+        if task in self.config.get('residue_readouts', {}):
+            bins = self.config['residue_readouts'][task]['bins']
+            sequences = [x['sequence'] for x in batch]
+            tokens = esm2.pad_batch([esm2.encode(s, max_len) for s in sequences], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            return self.position_features(hidden, [min(len(s), max_len-2) for s in sequences], bins)
+        if task in self.PAIR:
+            a = self.pool_sequences([x['sequence_a'] for x in batch],task,device,max_len)
+            b = self.pool_sequences([x['sequence_b'] for x in batch],task,device,max_len)
+            if task in self.config.get('expanded_pair_readouts', []):
+                if task in self.config.get('symmetric_pair_readouts',[]):
+                    features=torch.cat([(a.float()+b.float())*.5,a*b,(a-b).abs()],dim=-1)
+                else:
+                    features=torch.cat([a,b,a*b,(a-b).abs()],dim=-1)
+                base = F.dropout(features,p=self.config.get('pair_dropout',0.),training=self.training)
+                return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+            output = torch.cat([a, b], dim=-1)
+            if self.config.get('pair_interaction', False):
+                output = output + self.pair_fuse(torch.cat([a * b, (a - b).abs()], dim=-1))
+            base = F.dropout(output, p=self.config.get('pair_dropout', 0.0), training=self.training)
+            return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+        return self.pool_sequences([x['sequence'] for x in batch],task,device,max_len)
+
+    def add_pair_residues(self, task, batch, device, max_len, base):
+        if task not in self.config.get('pair_residue_tasks', []):
+            return base
+        result = dict(base) if isinstance(base, dict) else {'base': base}
+        bins = self.config['pair_residue_interaction']['bins']
+        for role, name in [('a', 'sequence_a'), ('b', 'sequence_b')]:
+            result['residue_'+role] = self.pool_residue_bins(
+                [row[name] for row in batch], task, device, max_len, bins)
+        return result
+
+    def pool_residue_bins(self, sequences, task, device, max_len, bins):
+        """Average every residue into fixed relative bins, with full-chain context."""
+        width = max_len-2
+        assert width > 0 and bins > 0
+        output = [None]*len(sequences)
+        short = [i for i, sequence in enumerate(sequences) if len(sequence) <= width]
+        if short:
+            tokens = esm2.pad_batch([esm2.encode(sequences[i], max_len) for i in short], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            for j, index in enumerate(short):
+                length = len(sequences[index])
+                values = hidden[j, 1:1+length].float()
+                output[index] = (F.adaptive_avg_pool1d(values.T[None], bins)[0].T if length
+                                 else torch.zeros(bins, self.config['dim'], device=device))
+        for index, sequence in enumerate(sequences):
+            if len(sequence) <= width:
+                continue
+            starts = list(range(0, len(sequence)-width+1, min(768, width)))
+            if starts[-1] != len(sequence)-width:
+                starts.append(len(sequence)-width)
+            total = torch.zeros(len(sequence), self.config['dim'], device=device)
+            count = torch.zeros(len(sequence), 1, device=device)
+            position = torch.arange(width, device=device)
+            weight = torch.minimum(torch.minimum(position+1, width-position),
+                                   torch.full_like(position, 128)).float()[:, None]
+            for begin in range(0, len(starts), max(1, 16384//max_len)):
+                part = starts[begin:begin+max(1, 16384//max_len)]
+                tokens = esm2.pad_batch([esm2.encode(sequence[s:s+width], max_len) for s in part], device)
+                hidden, _ = self.encode_residues(tokens, task)
+                for j, start in enumerate(part):
+                    total.index_add_(0, position+start, hidden[j, 1:1+width].float()*weight)
+                    count.index_add_(0, position+start, weight)
+            values = total/count.clamp_min(1)
+            output[index] = F.adaptive_avg_pool1d(values.T[None], bins)[0].T
+        return torch.stack(output)
+
+    @staticmethod
+    def terminal_bins(states, width, bins, align_end=False):
+        """Fixed absolute residue bins; exclude padding from partial-bin means."""
+        assert width > 0 and bins > 0 and width % bins == 0
+        states = (states[-width:] if align_end else states[:width]).float()
+        count = states.shape[0]
+        padded = states.new_zeros(width, states.shape[-1])
+        valid = states.new_zeros(width)
+        offset = width-count if align_end else 0
+        padded[offset:offset+count] = states
+        valid[offset:offset+count] = 1
+        total = padded.reshape(bins, width//bins, -1).sum(1)
+        denominator = valid.reshape(bins, width//bins).sum(1).clamp_min(1)[:, None]
+        return (total/denominator).flatten()
+
+    def terminal_summary_features(self, task, sequences, device, max_len):
+        settings = self.config['terminal_summary_readouts'][task]
+        width = max_len-2
+        assert width >= max(settings['prefix_residues'], settings['suffix_residues'])
+        tokens = esm2.pad_batch([esm2.encode(sequence, max_len) for sequence in sequences], device)
+        hidden, padding = self.encode_residues(tokens, task)
+        summary = self.summarize(hidden, tokens, padding, task)
+        long_ids = [index for index, sequence in enumerate(sequences) if len(sequence) > width]
+        tails = {}
+        if long_ids:
+            tail_tokens = esm2.pad_batch([esm2.encode(sequences[index][-width:], max_len)
+                                         for index in long_ids], device)
+            tail_hidden, _ = self.encode_residues(tail_tokens, task)
+            tails = {index: tail_hidden[local, 1:width+1] for local, index in enumerate(long_ids)}
+        terminals = []
+        for index, sequence in enumerate(sequences):
+            prefix = hidden[index, 1:1+min(len(sequence), width)]
+            suffix = tails.get(index, prefix)
+            terminals.append(torch.cat([
+                self.terminal_bins(prefix, settings['prefix_residues'], settings['bins']),
+                self.terminal_bins(suffix, settings['suffix_residues'], settings['bins'], align_end=True)]))
+        return torch.cat([summary.float(), torch.stack(terminals)], dim=-1)
+
+    @staticmethod
+    def position_features(hidden, lengths, bins):
+        features = []
+        for index, length in enumerate(lengths):
+            if length:
+                states = hidden[index:index+1, 1:1+length].float().transpose(1, 2)
+                features.append(F.interpolate(states, size=bins, mode='linear', align_corners=True).flatten())
+            else:
+                features.append(hidden.new_zeros(hidden.shape[-1] * bins).float())
+        return torch.stack(features)
+
+    def secondary_structure_summary(self, sequences, device, max_len):
+        tokens=esm2.pad_batch([esm2.encode(sequence,max_len) for sequence in sequences],device)
+        hidden,_=self.encode_residues(tokens,'secondary_structure')
+        with torch.autocast(device_type=device.type,enabled=False):
+            probabilities=self.heads['secondary_structure'](hidden.float()).softmax(-1)
+        summaries=[]
+        for index,sequence in enumerate(sequences):
+            length=min(len(sequence),max_len-2)
+            if not length:
+                summaries.append(probabilities.new_zeros(40));continue
+            value=probabilities[index,1:1+length]
+            mean=value.mean(0);std=value.std(0,unbiased=False)
+            transition=(value[:-1,:,None]*value[1:,None,:]).mean(0).flatten() if length>1 else value.new_zeros(9)
+            positions=F.adaptive_avg_pool1d(value.T[None],8).flatten()
+            summaries.append(torch.cat([mean,std,transition,positions,value.new_tensor([math.log1p(length)])]))
+        return torch.stack(summaries)
+
+    def normalize(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return (values - stats['mean']) / stats['std'] if stats else values
+
+    def unscale(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return values * stats['std'] + stats['mean'] if stats else values
+
+    def transfer(self, state, normalized_source=False):
+        """Transfer our own lineage only; retain random init for new parameters."""
+        current = self.state_dict()
+        fitting = {k: v for k, v in state.items() if k in current and v.shape == current[k].shape}
+        missing, unexpected = self.load_state_dict(fitting, strict=False)
+        if not normalized_source:
+            with torch.no_grad():
+                for task, stats in self.config.get('regression_stats', {}).items():
+                    # Preserve predictions when moving a trained head to standardized units.
+                    if f'heads.{task}.3.weight' in fitting:
+                        self.heads[task][3].weight.div_(stats['std'])
+                        self.heads[task][3].bias.sub_(stats['mean']).div_(stats['std'])
+        return {'transferred': len(fitting), 'new_tensors': missing, 'unexpected': unexpected}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S054/PUBLISHED.json

@@ -0,0 +1,5 @@
+{
+  "source": "/run-state/workspace/research/production-stability-lengthweight-fullpool1/candidate/package",
+  "files": 9,
+  "bytes": 214725002
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S054/README.md

@@ -0,0 +1,78 @@
+# Unified PEER protein model
+
+One shared rotary transformer serves all eleven tasks: 12 layers, width 512,
+8 attention heads, plus two shared extension blocks. Exact parameter count:
+**53,000,306 total**, **44,150,303 encoder**, including **37,845,535 original
+encoder parameters used by every task**. Beta-lactamase and stability use both
+extension blocks; other tasks use the original encoder exit.
+
+All parameters originated from random initialization and training in this
+session. The common encoder received one hour of MLM on mounted decontaminated
+UniRef50 (1,713,641,682 token presentations), then joint supervision across all
+eleven fit tasks. The retained checkpoint has 600 active seconds / 11,899
+updates. Task conditioning and extension training also used all eleven fit
+tasks. No external weights, embeddings or data were used.
+
+Heads:
+
+- Fluorescence/beta-lactamase: normalized linear heads over 256/320 interpolated
+  residue positions, empirical rank targets and ridge 1.
+- Fold, solubility and both localization tasks: seven-summary normalized linear
+  heads. Binary localization adds a 475,906-parameter nonlinear summary residual
+  jointly trained across solubility and both localization tasks.
+- Human PPI: ordered chain summaries, product and absolute difference.
+  Yeast/affinity use symmetric averages, product and absolute difference. Yeast
+  additionally uses shared rank-32 bilinear and 64-bin residue interaction
+  modules, each jointly trained across all three PPI tasks.
+- Stability: MLP with normalized final linear head; the six learned head
+  tensors use the fixed continuation midpoint described below.
+- Secondary structure: local convolution and residue MLP with normalized final
+  layer. Its head received 64 supervised epochs and 64 distillation epochs on
+  2,221,507 valid fit residues, combining equal hard CE and temperature-2 KL.
+  The teacher was an own-session 85M model with two-hour MLM and joint all-task
+  supervision/conditioning. Teacher parameters and caches are absent here.
+
+Fold, fluorescence, beta-lactamase and affinity heads retain the parent fit+tune label fits. Each recipe passed a two-half added-label pilot before fitting the full permitted pool. Their production Tune scores and aggregate are in-sample and excluded from development selection.
+
+Stability starts from the previously selected fit-only head (including its
+earlier continuation midpoint). The new study compared natural weighting with
+equal total loss mass for the 36,446 length-43 and 17,168 length-50 fit rows.
+Both arms used identical batches, dropout RNG and 1,680 updates: whole-head
+AdamW, peak lr 0.0001, weight decay 0.01, batch 512, 16 epochs, cosine decay to
+10%, original fit-standardized MSE, clipping 1. Feature-normalization buffers
+were fixed. Only the predeclared final 50:50 parameter midpoint was eligible;
+raw endpoints and earlier checkpoints were not selected. Balanced weighting
+scored 0.7311607643 on cached Tune features versus 0.7274924149 for its parent
+and 0.7291215997 for the matched control; conditional paired 95% differences
+were [0.0019018632, 0.0054815226] and [0.0012832147, 0.0028118185].
+The accepted fit-only development reference has mean0.7166638090 and stability
+0.7311607643. A fixed two-half added-label pilot then reproduced its fit-only
+head bit-for-bit and obtained out-of-fold stability0.7337159020, gain0.0025551377,
+conditional95%[0.0015641030,0.0036431410]. Both held-out halves improved. Halves
+were label-stratified, not protein-family or scaffold splits; prior Tune
+selection still biases this evidence.
+
+The production stability head now applies that same fixed recipe to all
+53,614fit plus2,512Tune labels: same original head initialization, fixed
+normalization,1,680updates and50:50parameter midpoint, with equal total loss
+mass per length group. The larger pool ends during its16th epoch. This is
+one ordinary head, not the two research cross-fit heads. Stability is now a
+fifth head using Tune labels, alongside fold, fluorescence, beta-lactamase and
+affinity. All five production Tune scores and the aggregate are IN-SAMPLE and
+excluded from development selection. The extra-label recipe was accepted
+before its full-pool fit; its in-sample score is not a selection criterion.
+Complete independent production replay is valid for all eleven tasks; the ten other prediction files are byte-identical to the previous production package. Only the six learned stability-head tensors changed.
+
+
+Tune selects regularization, checkpoints, conditioning and task exits. This
+length-weighting hypothesis was informed by the observed Tune length
+distribution. Repeated Tune selection and protein-family dependence are not
+corrected by the conditional intervals. Small PPI splits and weak fold
+generalization remain limitations. SS and pair windows cover full chains;
+other tasks use a 1022-residue prefix. Human windows allow 1536 tokens and
+yeast 1024. GFP/beta rank outputs are not calibrated for absolute error.
+No held-out test measurement is available.
+
+Run `bash infer.sh INPUT_ROOT OUTPUT_ROOT` offline. This is one parameter set
+and needs no live trainer, research files, feature cache, sequence lookup,
+prediction ensemble or test-time fitting.

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S054/config.json

@@ -0,0 +1,134 @@
+{
+  "layers": 12,
+  "dim": 512,
+  "heads": 8,
+  "pooling": "rich",
+  "pair_interaction": true,
+  "ss_context": true,
+  "max_len": 1024,
+  "pair_dropout": 0.0,
+  "architecture": "unified",
+  "full_ss": true,
+  "regression_stats": {
+    "fluorescence": {
+      "mean": 3.180586883940159,
+      "std": 0.8339910288860748
+    },
+    "stability": {
+      "mean": 0.1790524860555312,
+      "std": 0.5662245232305059
+    },
+    "beta_lactamase": {
+      "mean": 0.7383112351980983,
+      "std": 0.31642946622284734
+    },
+    "ppi_affinity": {
+      "mean": -11.654589870742203,
+      "std": 3.0832061340498944
+    }
+  },
+  "residue_readouts": {
+    "fluorescence": {
+      "bins": 256
+    },
+    "beta_lactamase": {
+      "bins": 320
+    }
+  },
+  "fp32_heads": [
+    "beta_lactamase",
+    "binary_localization",
+    "fluorescence",
+    "fold",
+    "human_ppi",
+    "ppi_affinity",
+    "secondary_structure",
+    "solubility",
+    "stability",
+    "subcellular_localization",
+    "yeast_ppi"
+  ],
+  "ss_linear_context": 0,
+  "ss_calibrated": true,
+  "linear_heads": [],
+  "summary_readouts": [
+    "solubility",
+    "subcellular_localization",
+    "binary_localization",
+    "fold"
+  ],
+  "cosine_heads": {},
+  "nonlinear_summary_heads": {},
+  "calibrated_heads": [
+    "stability"
+  ],
+  "sequence_windows": [
+    "yeast_ppi",
+    "human_ppi"
+  ],
+  "expanded_pair_readouts": [
+    "yeast_ppi",
+    "human_ppi",
+    "ppi_affinity"
+  ],
+  "symmetric_pair_readouts": [
+    "yeast_ppi",
+    "ppi_affinity"
+  ],
+  "task_encoder_layers": {},
+  "task_conditioning": true,
+  "pair_summary_readouts": [],
+  "extension_layers": 2,
+  "window_pooling_training": true,
+  "batch_window_training": true,
+  "class_weight_power": {
+    "fold": 0.5
+  },
+  "task_extension_depths": {
+    "beta_lactamase": 2,
+    "binary_localization": 0,
+    "fluorescence": 0,
+    "fold": 0,
+    "human_ppi": 0,
+    "ppi_affinity": 0,
+    "secondary_structure": 0,
+    "solubility": 0,
+    "stability": 2,
+    "subcellular_localization": 0,
+    "yeast_ppi": 0
+  },
+  "task_max_len": {
+    "human_ppi": 1536
+  },
+  "pair_bilinear_rank": 32,
+  "pair_bilinear_tasks": [
+    "yeast_ppi"
+  ],
+  "pair_residue_interaction": {
+    "bins": 64,
+    "projection_dim": 32,
+    "pair_hidden": 32,
+    "pair_channels": 8,
+    "dropout": 0.1
+  },
+  "pair_residue_tasks": [
+    "yeast_ppi"
+  ],
+  "rank_target_tasks": [
+    "fluorescence",
+    "beta_lactamase"
+  ],
+  "ss_summary_readouts": [],
+  "terminal_summary_readouts": {},
+  "residue_lowrank_heads": {},
+  "shared_summary_residual": {
+    "tasks": [
+      "binary_localization"
+    ],
+    "hidden": 128,
+    "dropout": 0.2
+  },
+  "summary_residual_tasks": [
+    "binary_localization"
+  ]
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S054/esm2.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""An ESM-2 architecture, trained from scratch, as the reference baseline.
+
+Follows Lin et al. (Science 2023) / facebookresearch/esm in the ways that
+matter for a like-for-like architecture claim:
+
+  * rotary position embeddings, not learned positional embeddings -- this is
+    the defining architectural change from ESM-1b to ESM-2
+  * pre-LayerNorm blocks, GELU feed-forward at 4x expansion
+  * final LayerNorm before the LM head, and the LM head's projection weight
+    tied to the token embedding
+  * the ESM alphabet's special tokens (<cls>/<pad>/<eos>/<mask>) and the same
+    20 standard + rare amino-acid symbols
+
+The published size ladder is reproduced in CONFIGS so the baseline can be named
+by its ESM-2 counterpart rather than by an arbitrary width.
+"""
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ESM-2's alphabet, in its canonical order.
+SPECIALS = ["<cls>", "<pad>", "<eos>", "<unk>"]
+RESIDUES = list("LAGVSERTIDPKQNFYMHWCXBUZO")
+EXTRA = ["<null_1>", "<mask>"]
+ALPHABET = SPECIALS + RESIDUES + EXTRA
+TOKEN = {symbol: index for index, symbol in enumerate(ALPHABET)}
+CLS, PAD, EOS, UNK = TOKEN["<cls>"], TOKEN["<pad>"], TOKEN["<eos>"], TOKEN["<unk>"]
+MASK = TOKEN["<mask>"]
+VOCAB_SIZE = len(ALPHABET)
+FIRST_RESIDUE, LAST_RESIDUE = TOKEN["L"], TOKEN["O"]
+
+# name -> (layers, embed_dim, attention_heads), from the ESM-2 release table.
+CONFIGS = {
+    "esm2_t6_8M":    (6, 320, 20),
+    "esm2_t12_35M":  (12, 480, 20),
+    "esm2_t30_150M": (30, 640, 20),
+    "esm2_t33_650M": (33, 1280, 20),
+}
+
+
+def encode(sequence, max_len=1024):
+    body = [TOKEN.get(c, UNK) for c in sequence[:max_len - 2]]
+    return [CLS] + body + [EOS]
+
+
+def pad_batch(sequences, device):
+    width = max(len(s) for s in sequences)
+    out = torch.full((len(sequences), width), PAD, dtype=torch.long)
+    for row, ids in enumerate(sequences):
+        out[row, :len(ids)] = torch.tensor(ids, dtype=torch.long)
+    return out.to(device, non_blocking=True)
+
+
+class Rotary(nn.Module):
+    """Rotary position embedding, as ESM-2 applies it to q and k."""
+
+    def __init__(self, dim, base=10000):
+        super().__init__()
+        inverse = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inverse", inverse, persistent=False)
+        self._cached_length = 0
+
+    def _tables(self, length, device, dtype):
+        if length != self._cached_length or self._cos.device != device:
+            position = torch.arange(length, device=device, dtype=torch.float)
+            angles = torch.outer(position, self.inverse.to(device))
+            table = torch.cat([angles, angles], dim=-1)
+            self._cos = table.cos()[None, None]
+            self._sin = table.sin()[None, None]
+            self._cached_length = length
+        return self._cos.to(dtype), self._sin.to(dtype)
+
+    @staticmethod
+    def _rotate_half(x):
+        half = x.shape[-1] // 2
+        return torch.cat([-x[..., half:], x[..., :half]], dim=-1)
+
+    def forward(self, q, k):
+        cos, sin = self._tables(q.shape[-2], q.device, q.dtype)
+        return (q * cos + self._rotate_half(q) * sin,
+                k * cos + self._rotate_half(k) * sin)
+
+
+class Attention(nn.Module):
+    def __init__(self, dim, heads):
+        super().__init__()
+        self.heads = heads
+        self.head_dim = dim // heads
+        self.q = nn.Linear(dim, dim)
+        self.k = nn.Linear(dim, dim)
+        self.v = nn.Linear(dim, dim)
+        self.out = nn.Linear(dim, dim)
+        self.rotary = Rotary(self.head_dim)
+
+    def forward(self, x, pad_mask):
+        batch, length, _ = x.shape
+        shape = (batch, length, self.heads, self.head_dim)
+        q = self.q(x).view(shape).transpose(1, 2)
+        k = self.k(x).view(shape).transpose(1, 2)
+        v = self.v(x).view(shape).transpose(1, 2)
+        q, k = self.rotary(q, k)
+        attention_mask = None
+        if pad_mask is not None:
+            attention_mask = (~pad_mask)[:, None, None, :]
+        hidden = F.scaled_dot_product_attention(q, k, v, attn_mask=attention_mask)
+        hidden = hidden.transpose(1, 2).reshape(batch, length, -1)
+        return self.out(hidden)
+
+
+class Block(nn.Module):
+    def __init__(self, dim, heads, ffn):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim)
+        self.attention = Attention(dim, heads)
+        self.norm2 = nn.LayerNorm(dim)
+        self.ffn = nn.Sequential(nn.Linear(dim, ffn), nn.GELU(), nn.Linear(ffn, dim))
+
+    def forward(self, x, pad_mask, condition=None):
+        first = self.norm1(x)
+        if condition is not None:
+            first = first * (1 + condition[0]) + condition[1]
+        x = x + self.attention(first, pad_mask)
+        second = self.norm2(x)
+        if condition is not None:
+            second = second * (1 + condition[2]) + condition[3]
+        return x + self.ffn(second)
+
+
+class Encoder(nn.Module):
+    """The shared backbone. Every task reads from this one parameter set."""
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.dim = dim
+        self.embed = nn.Embedding(VOCAB_SIZE, dim, padding_idx=PAD)
+        self.blocks = nn.ModuleList([Block(dim, heads, dim * 4) for _ in range(layers)])
+        self.norm = nn.LayerNorm(dim)
+        self.lm_bias = nn.Parameter(torch.zeros(VOCAB_SIZE))
+        self.apply(self._init)
+
+    @staticmethod
+    def _init(module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, std=0.02)
+
+    def add_extension(self, layers, heads, before_norm=False):
+        """Append shared residual blocks after the original normalized representation."""
+        assert layers > 0 and not hasattr(self, 'extension')
+        self.extension_before_norm = bool(before_norm)
+        self.extension = nn.ModuleList([Block(self.dim, heads, 4*self.dim) for _ in range(layers)])
+        self.extension.apply(self._init)
+        # Identity at initialization preserves every existing readout exactly.
+        for block in self.extension:
+            nn.init.zeros_(block.attention.out.weight)
+            nn.init.zeros_(block.attention.out.bias)
+            nn.init.zeros_(block.ffn[2].weight)
+            nn.init.zeros_(block.ffn[2].bias)
+
+    def forward(self, tokens, condition=None, depth=None, extension_depth=None):
+        pad_mask = tokens.eq(PAD)
+        hidden = self.embed(tokens)
+        depth=len(self.blocks) if depth is None else int(depth)
+        if not 1<=depth<=len(self.blocks):
+            raise ValueError(f'Encoder depth {depth} is outside 1..{len(self.blocks)}')
+        for index, block in enumerate(self.blocks):
+            if index>=depth:
+                break
+            hidden = block(hidden, pad_mask, condition[index] if condition is not None else None)
+        # Local residue heads must not observe artificial states at padded
+        # positions; otherwise predictions near the C terminus depend on which
+        # other sequences share the batch. Valid transformer states are unchanged.
+        before_norm = getattr(self, 'extension_before_norm', False)
+        if not before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        extension = getattr(self, 'extension', ())
+        extension_depth = len(extension) if extension_depth is None else int(extension_depth)
+        if not 0 <= extension_depth <= len(extension):
+            raise ValueError(f'Extension depth {extension_depth} is outside 0..{len(extension)}')
+        for index, block in enumerate(extension):
+            if index >= extension_depth:
+                break
+            hidden = block(hidden, pad_mask).masked_fill(pad_mask.unsqueeze(-1), 0)
+        if before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        return hidden, pad_mask
+
+    def lm_logits(self, hidden):
+        # Weight tying, as in ESM-2's RobertaLMHead.
+        return F.linear(hidden, self.embed.weight) + self.lm_bias
+
+    def pool(self, tokens):
+        hidden, pad_mask = self.forward(tokens)
+        keep = (~pad_mask).to(hidden.dtype).unsqueeze(-1)
+        return (hidden * keep).sum(1) / keep.sum(1).clamp(min=1)
+
+
+class Model(nn.Module):
+    """ESM-2 backbone plus the eleven PEER task heads."""
+
+    CLASSES = {"solubility": 2, "subcellular_localization": 10,
+               "binary_localization": 2, "fold": 1195,
+               "yeast_ppi": 2, "human_ppi": 2}
+    REGRESSION = ("fluorescence", "stability", "beta_lactamase", "ppi_affinity")
+    PAIR = {"yeast_ppi", "human_ppi", "ppi_affinity"}
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.encoder = Encoder(layers=layers, dim=dim, heads=heads)
+        self.heads = nn.ModuleDict()
+        for task, n in self.CLASSES.items():
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, n))
+        for task in self.REGRESSION:
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 1))
+        self.heads["secondary_structure"] = nn.Sequential(
+            nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.PAIR:
+            a = self.encoder.pool(pad_batch(
+                [encode(x["sequence_a"], max_len) for x in batch], device))
+            b = self.encoder.pool(pad_batch(
+                [encode(x["sequence_b"], max_len) for x in batch], device))
+            return torch.cat([a, b], dim=-1)
+        return self.encoder.pool(pad_batch(
+            [encode(x["sequence"], max_len) for x in batch], device))
+
+
+def build(name="esm2_t12_35M"):
+    layers, dim, heads = CONFIGS[name]
+    model = Model(layers=layers, dim=dim, heads=heads)
+    return model, {"name": name, "layers": layers, "dim": dim, "heads": heads}
+
+
+if __name__ == "__main__":
+    for name in CONFIGS:
+        model, config = build(name)
+        backbone = sum(p.numel() for p in model.encoder.parameters())
+        total = sum(p.numel() for p in model.parameters())
+        print(f"{name:16s} backbone {backbone/1e6:7.2f}M   with heads {total/1e6:7.2f}M")

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S054/infer.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PYTHONDONTWRITEBYTECODE=1
+exec python3 "$(dirname "$0")/replay.py" "$1" "$2"

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S054/provenance.json

@@ -0,0 +1,460 @@
+{
+  "parent_package": "/workspace/research/production-stability-lengthweight1/candidate/package",
+  "parent_model_sha256": "6cae7d0e4fd47e56a27acc11bfcb299e858437351abd554cdc25c3aa5b187b0d",
+  "parent_provenance": {
+    "parent_package": "/workspace/research/production-stability-midpoint1/candidate/package",
+    "parent_sha256": "5a5e8f90a608f84f0592bad0213117ba9b3d056d6dc3feb325965a830f25a3e0",
+    "parent_provenance": {
+      "method": "Retain production model and replace only six stability head tensors with the accepted fit-only parameter midpoint.",
+      "production_parent": "/workspace/research/production-fullpool-summary1/candidate/package",
+      "production_parent_sha256": "195b60bcb0833ce75ed07c8846fb50ccd840c137ee4f4616d9c8b5d1427107a9",
+      "development": "/workspace/research/selected-stability-midpoint1/candidate/package",
+      "development_sha256": "e01ae99a458b5d8d2aba968e1efc663b3d346220fd16b5498a3f91b5cf29626c",
+      "parent_provenance": {
+        "method": "Retain every production tensor and add the accepted jointly trained nonlinear summary residual.",
+        "production_parent": "/workspace/research/production-fullpool-ss-distill64/candidate/package",
+        "production_parent_sha256": "37fc717aeb0cab3f68c4311ac9b5d6c8b0a56aecad738ab093bd4d986ea4c766",
+        "addition_source": "/workspace/research/shared-summary-residual1/candidate/package",
+        "addition_source_sha256": "f890eebb10bb2dc08b84c28e7e0378960af5df4fb0d646ab2e8b33e130c74202",
+        "added_parameters": 475906,
+        "parameters": 53000306,
+        "original_production_tensors_exact": true,
+        "one_shared_encoder_for_all_tasks": true,
+        "data": "Own from-scratch shared lineage; fit-only residual gradients and normalization; tune model selection. Fold/GFP/beta/affinity retain permitted fit+tune heads.",
+        "changed_tasks": [
+          "binary_localization"
+        ],
+        "tasks_reusing_tune_labels": [
+          "fold",
+          "fluorescence",
+          "beta_lactamase",
+          "ppi_affinity"
+        ],
+        "feature_cache_exported": false,
+        "inference_dependencies_outside_package": false
+      },
+      "development_provenance": {
+        "method": "One fixed 50:50 parameter midpoint of parent and fit-only 16-epoch stability head continuation; no ensemble.",
+        "source_parent": "/workspace/research/shared-summary-residual1/candidate/package",
+        "source_candidate": "/workspace/research/selected-stability-head64/candidate/package",
+        "source_model_sha256": {
+          "/workspace/research/shared-summary-residual1/candidate/package": "f890eebb10bb2dc08b84c28e7e0378960af5df4fb0d646ab2e8b33e130c74202",
+          "/workspace/research/selected-stability-head64/candidate/package": "8fe80a673a65650bb5769b1cf75a59f10a65961da91cc62a491094f874042c79"
+        },
+        "parent_provenance": {
+          "method": "One jointly learned nonlinear residual map over frozen shared sequence summaries, with task-specific zero-initialized outputs.",
+          "fit_tasks": [
+            "solubility",
+            "subcellular_localization",
+            "binary_localization"
+          ],
+          "selected_tasks": [
+            "binary_localization"
+          ],
+          "selected_global_step": 3000,
+          "source": "/workspace/research/ss-distillation-continuation1/candidate/package",
+          "export_base": "/workspace/research/ss-distillation-continuation1/candidate/package",
+          "export_base_model_sha256": "4fee0a0154af24665de9a95f11a722017f3fa6d92354475bec8e81235a219f00",
+          "rebased_SS_tensors": [],
+          "seed": 20270102,
+          "steps": 6000,
+          "lr": 0.001,
+          "weight_decay": 0.01,
+          "dropout": 0.2,
+          "data": "Fit only for gradients and existing normalization; Tune chooses oneglobalcheckpoint andresidualexits usingpredeclaredconditionalCIgate.",
+          "original_parameters_exact": true,
+          "parameters": 53000306,
+          "encoder_parameters": 44150303,
+          "feature_cache_exported": false
+        },
+        "fit_recipe": {
+          "seed": 20270129,
+          "epochs": 64,
+          "evaluate_epochs": [
+            4,
+            16,
+            32,
+            64
+          ],
+          "batch_size": 512,
+          "lr": 0.0001,
+          "weight_decay": 0.01,
+          "loss": "MSE to original fit-standardized stabilitylabels, matching selectedmodeltarget semantics;clip1;originaldropout active inbotharms;fixednormalizationbuffers. No newranktargetchange.",
+          "optimizer": "FreshCPUAdamW,cosine64epochs to0.1floor; matcheddataorder/dropoutRNG/updatecounts; per-epochatomicresume."
+        },
+        "source_selected_epoch": 16,
+        "diagnostic": {
+          "utc": "2026-10-25T13:39:33.197851+00:00",
+          "status": "CPU_diagnostic_complete_no_export",
+          "alpha": 0.5,
+          "points": {
+            "parent": 0.7226969980994319,
+            "midpoint": 0.7274924148853711,
+            "whole": 0.7274598466634085
+          },
+          "midpoint_delta_vs_parent": 0.004795416785939199,
+          "conditional95": [
+            0.0017412267324550784,
+            0.007940572842815559
+          ],
+          "draws": 1000,
+          "seed": 20270130,
+          "parameters": 53000306,
+          "six_changed_learned_tensors": [
+            "heads.stability.0.weight",
+            "heads.stability.0.bias",
+            "heads.stability.2.weight",
+            "heads.stability.2.bias",
+            "heads.stability.3.linear.weight",
+            "heads.stability.3.linear.bias"
+          ],
+          "all_other_tensors_and_buffers_exact": true,
+          "eligible_for_manual_complete_replay": true,
+          "publication": false,
+          "GPU_used": false,
+          "limitations": "Singlepredeclaredparameter midpoint, notpredictionensemble. Conditionalrowbootstrapuncorrectedforpriorcheckpointselectionandfamilydependence. CPUdiagnosticisnotan11taskreplay.",
+          "source_sha256": {
+            "/workspace/research/check_selected_stability_midpoint.py": "13615a5b2689a0bd503cbc8a9a8a722014962677f6769cec871e13aa5133ff77",
+            "/workspace/research/shared-summary-residual1/candidate/package/model.pt": "f890eebb10bb2dc08b84c28e7e0378960af5df4fb0d646ab2e8b33e130c74202",
+            "/workspace/research/selected-stability-head64/candidate/package/model.pt": "8fe80a673a65650bb5769b1cf75a59f10a65961da91cc62a491094f874042c79"
+          }
+        },
+        "data": "Fit-only labels and fixed normalization; tune selects epoch and evaluates one predeclared midpoint.",
+        "parameters": 53000306,
+        "feature_cache_exported": false
+      },
+      "parameters": 53000306,
+      "all_other_production_tensors_exact": true,
+      "data": "Mounted fit labels and own from-scratch shared encoder lineage; tune model selection for stability. Four prior fullpool heads retain their permitted fit+tune training and crossfit evidence.",
+      "tasks_reusing_tune_labels": [
+        "fold",
+        "fluorescence",
+        "beta_lactamase",
+        "ppi_affinity"
+      ],
+      "feature_cache_exported": false,
+      "inference_dependencies_outside_package": false
+    },
+    "fit_plan": {
+      "utc": "2026-10-25T16:08:33.461759+00:00",
+      "status": "queued",
+      "CPU_only": true,
+      "recovery_registered": false,
+      "source_package": "/workspace/research/selected-stability-midpoint1/candidate/package",
+      "source_report": "/workspace/research/selected-stability-midpoint1/candidate/report.json",
+      "features": "/workspace/research/rank-target-functions2/features-stability",
+      "feature_producer": "/workspace/research/rank-target-fluorescence1/candidate/package",
+      "arms": [
+        "natural",
+        "balanced"
+      ],
+      "expected_fit_lengths": [
+        43,
+        50
+      ],
+      "seed": 20270208,
+      "threads": 6,
+      "epochs": 16,
+      "batch_size": 512,
+      "lr": 0.0001,
+      "weight_decay": 0.01,
+      "alpha": 0.5,
+      "minimum_gain": 0.001,
+      "bootstrap_seed": 20270209,
+      "bootstrap_draws": 1000,
+      "hypothesis": "Natural stability fit data are68%43-residue proteins but all observed Tune chains have50residues. Equal loss mass for the two fit-length groups may reduce interference on the50-residue domain. This is a test prompted by visible Tune distribution, not evidence of benefit.",
+      "loss": "Original-fit-standardized-label MSE. Identical shuffled full-fit batches in both arms; natural unit weights; balanced weights N/(2*N_group), averaged over minibatch without per-batch renormalization. Both train all six existing head tensors, fixed feature-normalization buffers.",
+      "schedule": "FreshAdamW,16epochs/1680updates,cosine to0.1floor,clip1; originaldropoutactive with identical RNG and data order. Same current selected initial head.",
+      "selection": "Only one fixed50:50 parameter midpoint at the final16epoch endpoint per arm is eligible. Raw endpoints are descriptive. Require gain>=.001 and positive conditional95versus selected; balanced additionally requires positive conditional95versus natural control. No intermediate Tune selection, no seed/mixture grid. Manual review then full11 native replay before any publication.",
+      "all_task_policy": "Only six stabilityheadparameters may change. Shared encoder remains jointly learned for all11. All10otherparameters/config/outputfiles must remain exact on native replay. No automatic export or publication.",
+      "resume": "CPU per-epoch atomic optimizer/head/NumPy/torchRNG checkpoints; rerun same script after interruption. Planhash verified on resume.",
+      "recovery_command": [
+        "env",
+        "CUDA_VISIBLE_DEVICES=",
+        "OMP_NUM_THREADS=6",
+        "MKL_NUM_THREADS=6",
+        "OPENBLAS_NUM_THREADS=1",
+        "python3",
+        "-u",
+        "/workspace/research/run_stability_length_weighting.py",
+        "--run",
+        "/workspace/research/selected-stability-lengthweight1"
+      ],
+      "frozen_sha256": {
+        "/workspace/research/run_stability_length_weighting.py": "3c5aac6a79a1397e5c50278a7635e32d7c3583438f64996c8a42a372d16a29f6",
+        "/workspace/research/check_shared_adapters_cpu.py": "db7d8d846b90929decad5865de36dd55fb95139aaa116b6ae2987cd96786c990",
+        "/workspace/research/crossfit_beta_labels.py": "bd1d29e2ab78cb0273213ef1a00657cef450a91f155ba7d9aa7f3db7721bd632",
+        "/workspace/research/stability-length-shift-diagnostic.json": "36a890f702bb6709e893c5f9d94c5cf15959f83f4a91d71e58a7b5f681065f6d",
+        "/workspace/research/selected-stability-midpoint1/candidate/report.json": "feedb171d285a4fa4d3c2a2bdd819873caaad1308ef90fd59df9df1ace166827",
+        "/workspace/research/selected-stability-midpoint1/candidate/package/model.pt": "e01ae99a458b5d8d2aba968e1efc663b3d346220fd16b5498a3f91b5cf29626c",
+        "/workspace/research/selected-stability-midpoint1/candidate/package/config.json": "162a2f4985944bba7492854315bd594fd3a38386548ab1c6b0c7a4f0d2bd7625",
+        "/workspace/research/selected-stability-midpoint1/candidate/package/unified.py": "bb00abef5853bc8badfef6a8d38ef8cb11f0ff6d9fe143eb7deebd582058efa3",
+        "/workspace/research/selected-stability-midpoint1/candidate/package/esm2.py": "d4d512296047ebbd0f9a26dc1390107f72762cb5de011eefc9fecb18118a9be9",
+        "/workspace/research/selected-stability-midpoint1/candidate/package/replay.py": "9c5add2d3fb117470241cf63f621e4797a16962cddadbaad6de2cfb481e7fa85",
+        "/workspace/research/selected-stability-midpoint1/candidate/package/infer.sh": "60f55b73f5b39a35a61df84026abed9a127b1cc035d650c9e1ca62f54fc2b468",
+        "/workspace/research/rank-target-fluorescence1/candidate/package/model.pt": "a13dad3c4f0cd7a1917d5b6763b27aaf3d38f3b7d775e747b61241ea36b681e0",
+        "/workspace/research/rank-target-fluorescence1/candidate/package/config.json": "e3da1d0ea2df3e6d6cc8b069016bffca2a37fd05accf1597cc6453f946d8fd89",
+        "/workspace/research/rank-target-functions2/features-stability/stability-fit.pt": "3fde47645a74370a003dd5f509a73ccecbaaac36ce4e8871938979a003ba3862",
+        "/workspace/research/rank-target-functions2/features-stability/stability-tune.pt": "92066e0c8abfcfc4ac3b8f2c7edcc4319cb8f8b4b97b53dd6e589147a1c460bf"
+      }
+    },
+    "fit_outcome": {
+      "utc": "2026-10-25T16:08:53.918703+00:00",
+      "status": "cached_analysis_complete",
+      "arms": {
+        "natural": {
+          "arm": "natural",
+          "endpoint_reward": 0.7291215996959544,
+          "raw_reward_descriptive_only": 0.72991937369715,
+          "step": 1680,
+          "active_seconds": 5.326252081984421,
+          "final_numpy_rng": {
+            "bit_generator": "PCG64",
+            "state": {
+              "state": 264542032468656517169208881192101401107,
+              "inc": 100251262600960163324587047460976422035
+            },
+            "has_uint32": 1,
+            "uinteger": 637011686
+          },
+          "final_torch_rng_sha256": "fd56e05488c9ae31e940c2b1d859f13ca90497826206c0e3602aaba9c339ef52",
+          "optimizer_steps": [
+            1680.0
+          ],
+          "lr": 1.0000078679859099e-05,
+          "fixed_buffers_exact": true
+        },
+        "balanced": {
+          "arm": "balanced",
+          "endpoint_reward": 0.7311607642876724,
+          "raw_reward_descriptive_only": 0.7330130871638806,
+          "step": 1680,
+          "active_seconds": 5.340115340979537,
+          "final_numpy_rng": {
+            "bit_generator": "PCG64",
+            "state": {
+              "state": 264542032468656517169208881192101401107,
+              "inc": 100251262600960163324587047460976422035
+            },
+            "has_uint32": 1,
+            "uinteger": 637011686
+          },
+          "final_torch_rng_sha256": "fd56e05488c9ae31e940c2b1d859f13ca90497826206c0e3602aaba9c339ef52",
+          "optimizer_steps": [
+            1680.0
+          ],
+          "lr": 1.0000078679859099e-05,
+          "fixed_buffers_exact": true
+        }
+      },
+      "comparisons": {
+        "natural_vs_parent": {
+          "delta": 0.001629184810583273,
+          "conditional_95": [
+            0.00024683637661263025,
+            0.003237432482155497
+          ]
+        },
+        "balanced_vs_parent": {
+          "delta": 0.0036683494023013186,
+          "conditional_95": [
+            0.0019018632266723152,
+            0.0054815225624275
+          ]
+        },
+        "balanced_vs_natural": {
+          "delta": 0.0020391645917180456,
+          "conditional_95": [
+            0.0012832147204794586,
+            0.0028118185483942955
+          ]
+        }
+      },
+      "eligible_arms": [
+        "natural",
+        "balanced"
+      ],
+      "published": false,
+      "GPU_used": false,
+      "candidate_exported": false,
+      "matched_order_dropout_optimizer_clocks": true,
+      "ten_other_tasks": "No state edited; any proposed export must keep their parameters/configuration exact and independently replay all eleven.",
+      "limitations": "Conditional example bootstrap after repeated tune inspection; family dependence and selection uncertainty omitted. Tune length distribution informed this hypothesis. Raw endpoints are descriptive only. No full-pool or test-time fitting."
+    },
+    "changed_tensors": [
+      "heads.stability.0.weight",
+      "heads.stability.0.bias",
+      "heads.stability.2.weight",
+      "heads.stability.2.bias",
+      "heads.stability.3.linear.weight",
+      "heads.stability.3.linear.bias"
+    ],
+    "all_other_tensors_and_buffers_exact": true,
+    "method": "One fixed final balanced-length continuation midpoint; no output averaging or test-time fitting."
+  },
+  "fullpool_training_plan": {
+    "utc": "2026-10-25T16:17:50.660603+00:00",
+    "status": "queued",
+    "recovery_registered": true,
+    "fit_recipe_plan": "/workspace/research/selected-stability-lengthweight1/plan.json",
+    "accepted_fit_only_head": "/workspace/research/selected-stability-lengthweight1/balanced/midpoint-head.pt",
+    "reference_predictions": "/workspace/research/selected-stability-lengthweight1-replay/candidate/replay/predictions/stability.jsonl",
+    "required_development_decision": "/workspace/research/selected-stability-lengthweight1-replay/decision.json",
+    "fixed_split_artifact": "/workspace/research/crossfit-stability-data1/research-predictions.pt",
+    "threads": 6,
+    "updates": 1680,
+    "bootstrap_seed": 20270210,
+    "bootstrap_draws": 1000,
+    "hypothesis": "Apply the already accepted fixed extra-label recipe to all permitted stability labels; no further model selection on its in-sample Tune output.",
+    "initialization": "Exact original selected-stability-midpoint1 head used in the accepted fit-only balanced recipe, not the later fitted midpoint; old feature-normalization buffers and target affine normalization remain fixed.",
+    "matching": "Exactly1680updates,16-epoch-equivalent control LR horizon,seed20270208,AdamW1e-4,wd.01,clip1,batch512,cosinefloor.1. Control must reproduce all accepted head tensors bitexact before either added-label arm. Added pools are larger and end in a partial16thepoch; batch membership and partial-batch sizes necessarily differ.",
+    "data": "Fit pooled features plus one fixed previously declared label-stratified Tune half per arm; evaluate only the other half. Group weights N/(2*N_group) recomputed using that arm training pool only. No heldout labels enter gradients, target normalization or head normalization.",
+    "selection": "No fullpoolTune quality selection. Exactly one fixed1680update midpoint; complete all11native replay and ten other production files exact before manual publication.",
+    "limitations": "Earlier Tune checkpoint/architecture selection biases estimates. Fixed label-stratified halves do not enforce protein-family or designed-scaffold independence. OOF predicts with two research heads trained on half the extra labels; it is recipe evidence, not a single final model measurement. Conditional bootstrap omits family dependence and prior selection.",
+    "GPU_used": false,
+    "fullpool_fitting_queued": true,
+    "candidate_export_capability": false,
+    "frozen_sha256": {
+      "/workspace/research/crossfit_stability_lengthweight.py": "c78dd44a2408b8302d2bac9b130f6b1d0ed8583e0addd849e704306cae1895e1",
+      "/workspace/research/run_stability_length_weighting.py": "3c5aac6a79a1397e5c50278a7635e32d7c3583438f64996c8a42a372d16a29f6",
+      "/workspace/research/selected-stability-lengthweight1/plan.json": "4bb848e73639ce379a55de765634624cda8428354bc004368715cc6be0ce4f2d",
+      "/workspace/research/selected-stability-lengthweight1/outcome.json": "48f960b5897432f316e1422d72ba59d793187e467d0479991eda05eaa307f9a9",
+      "/workspace/research/selected-stability-lengthweight1/balanced/midpoint-head.pt": "efb5afa7ce15a6b175a304a81fb4f4704947d93922c32e57eb18128b27586f22",
+      "/workspace/research/crossfit-stability-data1/research-predictions.pt": "bb127c6773051e5186bf6e1c373da1648e243334316627aea4912098031245c3",
+      "/workspace/research/selected-stability-lengthweight1-replay/candidate/replay/predictions/stability.jsonl": "b95864102e42933f1fb9c4c112077404db01e01275752af27ddef7bb67ce701c",
+      "/workspace/research/selected-stability-lengthweight1-replay/decision.json": "13e26f3f1cd7d1f2e30bbe55084a7db7971d8ee12402095a0d0375cea4aec220",
+      "/workspace/research/check_shared_adapters_cpu.py": "db7d8d846b90929decad5865de36dd55fb95139aaa116b6ae2987cd96786c990",
+      "/workspace/research/crossfit_beta_labels.py": "bd1d29e2ab78cb0273213ef1a00657cef450a91f155ba7d9aa7f3db7721bd632",
+      "/workspace/research/fit_fullpool_stability_lengthweight.py": "c0636f0b4a895a3333b33b9a3a9e9675690954e799b318cce2f912d9e8190a3b",
+      "/workspace/research/crossfit-stability-lengthweight1/decision.json": "aad9faa0a791551afc0f3dd9a68c2960533e0b4782652a144b54a79ba001e147",
+      "/workspace/research/crossfit-stability-lengthweight1/outcome.json": "9ff04cfd9fac3d4c4cd71b09c0c51262af468c3c0a73e2f73d665bdcaa928b65"
+    },
+    "queued_utc": "2026-10-25T16:16:33.916922+00:00",
+    "required_crossfit_decision": "/workspace/research/crossfit-stability-lengthweight1/decision.json"
+  },
+  "fullpool_training": {
+    "utc": "2026-10-25T16:18:12.158869+00:00",
+    "status": "fullpool_head_fit_complete_pending_assembly",
+    "training": {
+      "step": 1680,
+      "epochs_started": 16,
+      "active_seconds": 7.640217978012515,
+      "training_rows": 56126,
+      "added_tune_rows": 2512,
+      "fixed_buffers_exact": true,
+      "group_counts": {
+        "43": 36446,
+        "50": 19680
+      },
+      "final_lr": 1.0000078679859099e-05
+    },
+    "source_initialization": "/workspace/research/selected-stability-midpoint1/candidate/package",
+    "head": "/workspace/research/fullpool-stability-lengthweight1/fullpool/final-head.pt",
+    "head_sha256": "f531855c132c8fca7b1def6827ef4b2cf30d0af7c1c14e39c33afaa017f482c2",
+    "changed_head_tensors": [
+      "0.weight",
+      "0.bias",
+      "2.weight",
+      "2.bias",
+      "3.linear.weight",
+      "3.linear.bias"
+    ],
+    "fixed_normalization_buffers_exact": true,
+    "same_training_function_as_crossfit": true,
+    "published": false,
+    "candidate_exported": false,
+    "GPU_used": false,
+    "Tune_labels_used": 2512,
+    "in_sample_metric_used_for_selection": false,
+    "limitations": "Earlier Tune checkpoint/architecture selection biases estimates. Fixed label-stratified halves do not enforce protein-family or designed-scaffold independence. OOF predicts with two research heads trained on half the extra labels; it is recipe evidence, not a single final model measurement. Conditional bootstrap omits family dependence and prior selection."
+  },
+  "crossfit_recipe_approval": {
+    "utc": "2026-10-25T16:17:50.640175+00:00",
+    "status": "accepted_fixed_recipe_for_fullpool_stability_head",
+    "published": false,
+    "fullpool_head_fitted": false,
+    "evidence": {
+      "utc": "2026-10-25T16:17:04.539090+00:00",
+      "status": "research_only_crossfit_complete",
+      "scores": {
+        "incumbent": 0.7311607642876724,
+        "matched_fit_only": 0.7311607642876724,
+        "crossfit": 0.7337159019671029
+      },
+      "comparisons": {
+        "incumbent": {
+          "delta": 0.002555137679430497,
+          "conditional_95": [
+            0.0015641029747572976,
+            0.0036431410475218527
+          ]
+        },
+        "matched_fit_only": {
+          "delta": 0.002555137679430497,
+          "conditional_95": [
+            0.0015641029747572976,
+            0.0036431410475218527
+          ]
+        }
+      },
+      "fold_results": [
+        {
+          "heldout_half": 0,
+          "heldout_rows": 1256,
+          "incumbent_same_half": 0.7325449010474826,
+          "matched_control_same_half": 0.7325449010474826,
+          "crossfit_same_half": 0.7351256285381212,
+          "step": 1680,
+          "epochs_started": 16,
+          "active_seconds": 7.389840035961242,
+          "training_rows": 54870,
+          "added_tune_rows": 1256,
+          "fixed_buffers_exact": true,
+          "group_counts": {
+            "43": 36446,
+            "50": 18424
+          },
+          "final_lr": 1.0000078679859099e-05
+        },
+        {
+          "heldout_half": 1,
+          "heldout_rows": 1256,
+          "incumbent_same_half": 0.7298113878884595,
+          "matched_control_same_half": 0.7298113878884595,
+          "crossfit_same_half": 0.7327158507790285,
+          "step": 1680,
+          "epochs_started": 16,
+          "active_seconds": 7.374784096988151,
+          "training_rows": 54870,
+          "added_tune_rows": 1256,
+          "fixed_buffers_exact": true,
+          "group_counts": {
+            "43": 36446,
+            "50": 18424
+          },
+          "final_lr": 1.0000078679859099e-05
+        }
+      ],
+      "passes_predeclared_fullpool_gate": true,
+      "fit_only_reproduction_all_head_tensors_bit_exact": true,
+      "updates_per_arm": 1680,
+      "published": false,
+      "fullpool_head_fitted": false,
+      "candidate_exported": false,
+      "GPU_used": false,
+      "limitations": "Earlier Tune checkpoint/architecture selection biases estimates. Fixed label-stratified halves do not enforce protein-family or designed-scaffold independence. OOF predicts with two research heads trained on half the extra labels; it is recipe evidence, not a single final model measurement. Conditional bootstrap omits family dependence and prior selection."
+    },
+    "reason": "The fixed whole-head balanced-length recipe passes all prior policy gates: positive OOFdelta versus nativeincumbent and bitexact matchedcontrol, positivepaired95interval, both heldout halves improve. Shared encoder and normalization stay unchanged. FullpoolTune metrics will be in-sample and excluded from developmentselection.",
+    "all_other_tasks": "Exactly unchanged weights/features; subsequent full11production replay must verify ten byte-exact files."
+  },
+  "changed_tensors": [
+    "heads.stability.0.weight",
+    "heads.stability.0.bias",
+    "heads.stability.2.weight",
+    "heads.stability.2.bias",
+    "heads.stability.3.linear.weight",
+    "heads.stability.3.linear.bias"
+  ],
+  "all_other_tensors_and_feature_normalization_buffers_exact": true,
+  "method": "One fixed1680update balanced-length whole-head continuation and50:50parameter midpoint, initial head fromownselected-stability-midpoint1; allfit+tune labels permitted bycontract; no head averaging at inference."
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S054/replay.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Self-contained replay shared by research evaluation and frozen packages."""
+import contextlib
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+
+import esm2
+
+TASKS = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+         'subcellular_localization', 'binary_localization', 'fold',
+         'secondary_structure', 'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+
+def autocast(device):
+    return torch.autocast('cuda', dtype=torch.bfloat16) if device.type == 'cuda' else contextlib.nullcontext()
+
+
+def head_output(model, task, representation, device, fp32=False):
+    apply = model.apply_head if hasattr(model, 'apply_head') else lambda task, value: model.heads[task](value)
+    if fp32:
+        with torch.autocast(device.type, enabled=False):
+            values={k:v.float() if v.is_floating_point() else v for k,v in representation.items()} if isinstance(representation,dict) else representation.float()
+            return apply(task, values).float()
+    return apply(task, representation).float()
+
+
+def residue_states(model, tokens, task):
+    return model.encode_residues(tokens, task) if hasattr(model, 'encode_residues') else model.encoder(tokens)
+
+
+def windows(length, width=1022, stride=768):
+    if length <= width:
+        return [(0, length)]
+    starts = list(range(0, length - width + 1, stride))
+    if starts[-1] != length - width:
+        starts.append(length - width)
+    return [(s, min(s + width, length)) for s in starts]
+
+
+def batches(rows, task, token_budget=16384, max_len=1024, max_batch=128):
+    lengths = [min(max(map(len, r['features'].values())) + 2, max_len) for r in rows]
+    order = sorted(range(len(rows)), key=lengths.__getitem__)
+    current, width = [], 0
+    for i in order:
+        length = lengths[i]
+        # Pair sequences require two separate passes, but the peak tensor size is unchanged.
+        if current and (max(width, length) * (len(current) + 1) > token_budget or len(current) >= max_batch):
+            yield current
+            current, width = [], 0
+        current.append(i)
+        width = max(width, length)
+    if current:
+        yield current
+
+
+@torch.inference_mode()
+def predict_records(model, rows, task, device, config=None, token_budget=16384):
+    config = config or {}
+    max_len = config.get('task_max_len', {}).get(task, config.get('max_len', 1024))
+    full_ss = config.get('full_ss', True)
+    fp32_option = config.get('fp32_heads', False)
+    fp32_heads = fp32_option is True or (isinstance(fp32_option, list) and task in fp32_option)
+    was_training = model.training
+    model.eval()
+    result = {}
+    for ids in batches(rows, task, token_budget, max_len):
+        chunk = [rows[i] for i in ids]
+        features = [r['features'] for r in chunk]
+        if task == 'secondary_structure':
+            if full_ss and any(len(f['sequence']) > max_len - 2 for f in features):
+                for record in chunk:
+                    seq = record['features']['sequence']
+                    pieces = windows(len(seq), max_len - 2, min(768, max_len - 2))
+                    total = np.zeros((len(seq), 3), dtype=np.float32)
+                    weight_sum = np.zeros((len(seq), 1), dtype=np.float32)
+                    for begin in range(0, len(pieces), max(1, token_budget // max_len)):
+                        part = pieces[begin:begin + max(1, token_budget // max_len)]
+                        tokens = esm2.pad_batch([esm2.encode(seq[s:e], max_len) for s, e in part], device)
+                        with autocast(device):
+                            hidden, _ = residue_states(model, tokens, task)
+                            logits = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                        for j, (s, e) in enumerate(part):
+                            size = e - s
+                            # Smooth boundaries, without discarding any residue.
+                            weight = np.minimum(np.arange(1, size + 1), np.arange(size, 0, -1))
+                            weight = np.minimum(weight, 128).astype(np.float32)[:, None]
+                            total[s:e] += logits[j, 1:1+size] * weight
+                            weight_sum[s:e] += weight
+                    scores = total / np.maximum(weight_sum, 1)
+                    result[record['example_id']] = {'ss3_scores': scores.tolist()}
+            else:
+                tokens = esm2.pad_batch([esm2.encode(f['sequence'], max_len) for f in features], device)
+                with autocast(device):
+                    hidden, _ = residue_states(model, tokens, task)
+                    probabilities = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                for j, record in enumerate(chunk):
+                    length = len(record['features']['sequence'])
+                    used = min(length, max_len - 2)
+                    scores = probabilities[j, 1:1+used].tolist()
+                    scores.extend([[1.0, 1.0, 1.0] for _ in range(length-used)])
+                    result[record['example_id']] = {'ss3_scores': scores}
+            continue
+        with autocast(device):
+            representation = model.represent(task, features, device, max_len)
+            output = head_output(model, task, representation, device, fp32_heads)
+            if task in model.CLASSES:
+                output = output.softmax(-1)
+            if task in config.get('symmetric_pairs', []):
+                swapped = [{'sequence_a': f['sequence_b'], 'sequence_b': f['sequence_a']} for f in features]
+                swapped_rep = model.represent(task, swapped, device, max_len)
+                second = head_output(model, task, swapped_rep, device, fp32_heads)
+                if task in model.CLASSES:
+                    second = second.softmax(-1)
+                output = (output + second) * 0.5
+            if task in model.CLASSES:
+                output = output.clamp_min(1e-9)
+            elif hasattr(model, 'unscale'):
+                output = model.unscale(task, output)
+        values = output.cpu().tolist()
+        for record, value in zip(chunk, values):
+            result[record['example_id']] = {'scores': value} if task in model.CLASSES else {'value': value[0]}
+    if task == 'secondary_structure' and hasattr(model, 'ss_chain_decoder'):
+        # Decode complete chains only after all overlapping-window probabilities
+        # have been aggregated. No labels or parameter updates enter replay.
+        identifiers = [record['example_id'] for record in rows]
+        probabilities = [result[identifier]['ss3_scores'] for identifier in identifiers]
+        decoded = model.ss_chain_decoder.decode(probabilities)
+        for identifier, scores in zip(identifiers, decoded):
+            result[identifier] = {'ss3_scores': scores.tolist()}
+    model.train(was_training)
+    return result
+
+
+def load_model(package, device):
+    config = json.loads((package / 'config.json').read_text())
+    if config.get('architecture') == 'unified':
+        from unified import UnifiedModel
+        model = UnifiedModel(config)
+    else:
+        model = esm2.Model(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+    model.load_state_dict(torch.load(package / 'model.pt', map_location='cpu', weights_only=True))
+    return model.to(device).eval(), config
+
+
+def main():
+    if len(sys.argv) != 3:
+        raise SystemExit('usage: replay.py INPUT_ROOT OUTPUT_ROOT')
+    torch.set_num_threads(6)
+    source, destination = Path(sys.argv[1]), Path(sys.argv[2]) / 'predictions'
+    destination.mkdir(parents=True, exist_ok=True)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model, config = load_model(Path(__file__).resolve().parent, device)
+    for task in TASKS:
+        rows = [json.loads(line) for line in (source / f'{task}.jsonl').open()]
+        predictions = predict_records(model, rows, task, device, config)
+        with (destination / f'{task}.jsonl').open('w') as sink:
+            for row in rows:
+                sink.write(json.dumps({'example_id': row['example_id'], 'prediction': predictions[row['example_id']]}, separators=(',', ':')) + '\n')
+
+
+if __name__ == '__main__':
+    main()

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S054/selection.json

@@ -0,0 +1,116 @@
+{
+  "pending_independent_replay": false,
+  "independent_replay_verified": true,
+  "score_kind": "tune_labels_used_for_fold_fluorescence_beta_lactamase_ppi_affinity_and_stability",
+  "tasks_reusing_tune_labels": [
+    "fold",
+    "fluorescence",
+    "beta_lactamase",
+    "ppi_affinity",
+    "stability"
+  ],
+  "fit_only_development_reward": 0.7166638090200526,
+  "fit_only_development_package": "/workspace/research/selected-stability-lengthweight1-replay/candidate/package",
+  "stability_fit_only_evidence": {
+    "kind": "fit_only_complete_tune_replay",
+    "task": "stability",
+    "before": 0.7274923808177973,
+    "after": 0.7311607642876724,
+    "delta": 0.0036683834698750806,
+    "conditional_95_percentile_interval": [
+      0.0017767471141417273,
+      0.00544199745819068
+    ],
+    "examples": 2512,
+    "mean_delta": 0.0003334894063522801,
+    "conditional_mean95": [
+      0.0001615224649219752,
+      0.0004947270416536983
+    ],
+    "matched_natural_mixture_control": {
+      "delta": 0.0020391645917180456,
+      "conditional_95": [
+        0.0012832147204794586,
+        0.0028118185483942955
+      ]
+    },
+    "fixed_endpoint_updates": 1680,
+    "alpha": 0.5,
+    "ten_other_prediction_files_exact": true,
+    "limitations": "Conditional on already-selected models. Does not account for repeated tune selection, shared proteins across tasks, or family dependence within splits; not an independent generalization guarantee. The visible Tune length distribution informed the group-weighting hypothesis."
+  },
+  "stability_extra_label_recipe_evidence": {
+    "utc": "2026-10-25T16:17:04.539090+00:00",
+    "status": "research_only_crossfit_complete",
+    "scores": {
+      "incumbent": 0.7311607642876724,
+      "matched_fit_only": 0.7311607642876724,
+      "crossfit": 0.7337159019671029
+    },
+    "comparisons": {
+      "incumbent": {
+        "delta": 0.002555137679430497,
+        "conditional_95": [
+          0.0015641029747572976,
+          0.0036431410475218527
+        ]
+      },
+      "matched_fit_only": {
+        "delta": 0.002555137679430497,
+        "conditional_95": [
+          0.0015641029747572976,
+          0.0036431410475218527
+        ]
+      }
+    },
+    "fold_results": [
+      {
+        "heldout_half": 0,
+        "heldout_rows": 1256,
+        "incumbent_same_half": 0.7325449010474826,
+        "matched_control_same_half": 0.7325449010474826,
+        "crossfit_same_half": 0.7351256285381212,
+        "step": 1680,
+        "epochs_started": 16,
+        "active_seconds": 7.389840035961242,
+        "training_rows": 54870,
+        "added_tune_rows": 1256,
+        "fixed_buffers_exact": true,
+        "group_counts": {
+          "43": 36446,
+          "50": 18424
+        },
+        "final_lr": 1.0000078679859099e-05
+      },
+      {
+        "heldout_half": 1,
+        "heldout_rows": 1256,
+        "incumbent_same_half": 0.7298113878884595,
+        "matched_control_same_half": 0.7298113878884595,
+        "crossfit_same_half": 0.7327158507790285,
+        "step": 1680,
+        "epochs_started": 16,
+        "active_seconds": 7.374784096988151,
+        "training_rows": 54870,
+        "added_tune_rows": 1256,
+        "fixed_buffers_exact": true,
+        "group_counts": {
+          "43": 36446,
+          "50": 18424
+        },
+        "final_lr": 1.0000078679859099e-05
+      }
+    ],
+    "passes_predeclared_fullpool_gate": true,
+    "fit_only_reproduction_all_head_tensors_bit_exact": true,
+    "updates_per_arm": 1680,
+    "published": false,
+    "fullpool_head_fitted": false,
+    "candidate_exported": false,
+    "GPU_used": false,
+    "limitations": "Earlier Tune checkpoint/architecture selection biases estimates. Fixed label-stratified halves do not enforce protein-family or designed-scaffold independence. OOF predicts with two research heads trained on half the extra labels; it is recipe evidence, not a single final model measurement. Conditional bootstrap omits family dependence and prior selection."
+  },
+  "production_aggregate_excluded_from_selection": true,
+  "other_ten_predictions_exact_previous_production": true,
+  "stability_Tune_metric_is_in_sample": true
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S054/unified.py

@@ -0,0 +1,643 @@
+"""One jointly learned protein encoder, shared pooling, and eleven small heads."""
+import math
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import esm2
+
+
+class NormalizedLinear(nn.Module):
+    def __init__(self, width, outputs=1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs)
+
+    def forward(self, values):
+        return self.linear((values - self.mean) / self.scale)
+
+
+class LowRankPositionHead(nn.Module):
+    """A shared residue projection followed by an ordered position readout."""
+    def __init__(self, dim, bins, rank, outputs=1):
+        super().__init__()
+        assert 0 < rank <= min(dim, bins)
+        self.dim = dim
+        self.project = nn.Linear(dim, rank, bias=False)
+        self.output = nn.Linear(bins * rank, outputs)
+
+    def forward(self, values):
+        residues = values.reshape(values.shape[0], -1, self.dim)
+        return self.output(self.project(residues).flatten(1))
+
+
+class NormalizedCosine(nn.Module):
+    def __init__(self, width, outputs, temperature=20.):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs, bias=False)
+        self.temperature = temperature
+
+    def forward(self, values):
+        features = F.normalize((values-self.mean)/self.scale, dim=-1)
+        return F.linear(features, F.normalize(self.linear.weight, dim=-1))*self.temperature
+
+
+class NormalizedMLP(nn.Module):
+    def __init__(self, width, outputs, hidden=128, dropout=.1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(), nn.LayerNorm(hidden),
+                                     nn.Dropout(dropout), nn.Linear(hidden, outputs))
+
+    def forward(self, values):
+        return self.network((values-self.mean)/self.scale)
+
+
+class SharedSummaryResidual(nn.Module):
+    """One nonlinear summary map jointly used by several classification heads."""
+    def __init__(self, width, hidden, dropout, classes):
+        super().__init__()
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(),
+                                     nn.LayerNorm(hidden), nn.Dropout(dropout),
+                                     nn.Linear(hidden, hidden), nn.GELU(), nn.Dropout(dropout))
+        self.heads = nn.ModuleDict({task: nn.Linear(hidden, outputs)
+                                   for task, outputs in sorted(classes.items())})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, normalized_summary):
+        return self.heads[task](self.network(normalized_summary))
+
+
+class NormalizedResidueLinear(nn.Module):
+    def __init__(self, dim, kernel=9):
+        super().__init__()
+        assert kernel > 0 and kernel % 2 == 1
+        self.kernel = kernel
+        self.readout = NormalizedLinear(dim * kernel, 3)
+
+    @staticmethod
+    def features(hidden, kernel):
+        padded = F.pad(hidden.float().transpose(1, 2), (kernel // 2, kernel // 2))
+        return padded.unfold(-1, kernel, 1).transpose(1, 2).flatten(2)
+
+    def forward(self, hidden):
+        return self.readout(self.features(hidden, self.kernel))
+
+
+class LocalResidueHead(nn.Sequential):
+    """Preserve the original four head parameter names; add a local residual."""
+    def __init__(self, dim):
+        super().__init__(nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+        self.context = nn.Sequential(nn.Conv1d(dim, dim, 9, padding=4, groups=dim),
+                                     nn.GELU(), nn.Conv1d(dim, dim, 1))
+        nn.init.zeros_(self.context[-1].weight)
+        nn.init.zeros_(self.context[-1].bias)
+
+    def forward(self, x):
+        x = x + self.context(x.transpose(1, 2)).transpose(1, 2)
+        for i in range(4):
+            x = self[i](x)
+        return x
+
+
+class CalibratedLocalResidueHead(LocalResidueHead):
+    def __init__(self, dim):
+        super().__init__(dim)
+        self[3] = NormalizedLinear(dim, 3)
+
+
+class ResidualSequenceConvHead(nn.Module):
+    """Learn local sequence motifs alongside the retained summary classifier."""
+    def __init__(self, dim, outputs, channels=128, dropout=.2, retain_summary=True):
+        super().__init__()
+        self.base = NormalizedLinear(7 * dim, outputs) if retain_summary else None
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, channels)
+        self.convs = nn.ModuleList([nn.Conv1d(channels, channels, k, padding=k//2) for k in (3,9)])
+        self.norms = nn.ModuleList([nn.LayerNorm(channels) for _ in self.convs])
+        self.output = nn.Linear(4 * channels, outputs)
+        nn.init.zeros_(self.output.weight);nn.init.zeros_(self.output.bias)
+        self.dropout = dropout
+
+    def forward(self, features):
+        valid = features['valid'].bool().unsqueeze(-1)
+        x = F.gelu(self.project((features['hidden']-self.mean)/self.scale)) * valid
+        summaries = []
+        for conv,norm in zip(self.convs,self.norms):
+            y = norm(F.gelu(conv(x.transpose(1,2)).transpose(1,2)))
+            center = (y*valid).sum(1)/valid.sum(1).clamp_min(1)
+            maximum = y.masked_fill(~valid,-1e4).amax(1)
+            maximum = torch.where(valid.any(1),maximum,torch.zeros_like(maximum))
+            summaries.extend([center,maximum])
+        pooled = F.dropout(torch.cat(summaries,dim=-1),self.dropout,self.training)
+        logits=self.output(pooled)
+        return self.base(features['summary']) + logits if self.base is not None else logits
+
+
+class TokenLogMeanExpHead(nn.Module):
+    """Class-specific local evidence, pooled without sequence-length bias."""
+    def __init__(self, dim, outputs):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.linear = nn.Linear(dim, outputs)
+
+    def forward(self, representation):
+        values, valid = representation['hidden'].float(), representation['valid']
+        logits = self.linear((values-self.mean)/self.scale)
+        logits = logits.masked_fill(~valid.unsqueeze(-1), -torch.inf)
+        return torch.logsumexp(logits, 1)-valid.sum(1).clamp_min(1).float().log()[:, None]
+
+    def packed(self, values, lengths):
+        """Equivalent unpadded computation for frozen-feature readout fitting."""
+        logits = self.linear((values.float()-self.mean)/self.scale)
+        # The stabilizing maximum cancels in the derivative; detach avoids
+        # retaining another large token-by-class gradient path.
+        maximum = torch.segment_reduce(logits.detach(), 'max', lengths=lengths)
+        index = torch.repeat_interleave(torch.arange(len(lengths), device=lengths.device), lengths,
+                                        output_size=len(values))
+        exponent = (logits-maximum[index]).exp()
+        total = torch.segment_reduce(exponent, 'sum', lengths=lengths)
+        return maximum+total.log()-lengths.float().log()[:, None]
+
+
+class SharedPairResidueInteraction(nn.Module):
+    """A shared nonlinear comparison of local states from both protein chains."""
+    def __init__(self, dim, settings, classes):
+        super().__init__()
+        width, hidden, channels = (settings[k] for k in ['projection_dim', 'pair_hidden', 'pair_channels'])
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, width)
+        self.compare = nn.Sequential(nn.Linear(2*width, hidden), nn.GELU(),
+                                     nn.Linear(hidden, channels), nn.GELU())
+        self.dropout = settings['dropout']
+        self.heads = nn.ModuleDict({task: nn.Linear(2*channels, classes.get(task, 1))
+                                   for task in sorted(esm2.Model.PAIR)})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, first, second):
+        first = F.gelu(self.project((first-self.mean)/self.scale))
+        second = F.gelu(self.project((second-self.mean)/self.scale))
+        first = F.dropout(first, self.dropout, self.training)
+        second = F.dropout(second, self.dropout, self.training)
+        pair = torch.cat([(first[:, :, None]-second[:, None, :]).abs(),
+                          first[:, :, None]*second[:, None, :]], dim=-1)
+        local = self.compare(pair)
+        summary = torch.cat([local.mean((1, 2)), local.amax((1, 2))], dim=-1)
+        return self.heads[task](summary)
+
+
+class SSChainDecoder(nn.Module):
+    """Small learned label-compatibility model, applied to frozen residue unaries."""
+    def __init__(self):
+        super().__init__()
+        self.transition = nn.Parameter(torch.empty(3, 3))
+        self.start = nn.Parameter(torch.empty(3))
+        self.end = nn.Parameter(torch.empty(3))
+        for parameter in self.parameters():
+            nn.init.normal_(parameter, std=.01)
+
+    def decode(self, probabilities):
+        from ss_chain import decode_probabilities
+        values = [parameter.detach().double().cpu().numpy()
+                  for parameter in (self.transition, self.start, self.end)]
+        return decode_probabilities(probabilities, *values)
+
+
+class UnifiedModel(esm2.Model):
+    TASK_ORDER = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+                  'subcellular_localization', 'binary_localization', 'fold',
+                  'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+    def __init__(self, config):
+        super().__init__(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+        self.config = config
+        self.task_index = {t: i for i, t in enumerate(self.TASK_ORDER)}
+        dim = config['dim']
+        if config.get('extension_layers', 0):
+            self.encoder.add_extension(config['extension_layers'], config['heads'],
+                                       before_norm=config.get('extension_before_norm', False))
+        if config.get('task_conditioning', False):
+            self.task_condition = nn.Parameter(torch.zeros(11, config['layers'], 4, dim))
+        if config.get('pooling', 'mean') == 'rich':
+            self.pool_query = nn.Parameter(torch.randn(len(self.TASK_ORDER), 2, dim) * 0.02)
+            self.pool_position = nn.Parameter(torch.zeros(len(self.TASK_ORDER), 2, 4))
+            # Shared across tasks, with a zero initial residual for safe lineage transfer.
+            self.pool_fuse = nn.Linear(6 * dim, dim)
+            nn.init.zeros_(self.pool_fuse.weight)
+            nn.init.zeros_(self.pool_fuse.bias)
+        if config.get('pair_interaction', False):
+            self.pair_fuse = nn.Linear(2 * dim, 2 * dim)
+            nn.init.zeros_(self.pair_fuse.weight)
+            nn.init.zeros_(self.pair_fuse.bias)
+        if config.get('ss_context', False):
+            self.heads['secondary_structure'] = LocalResidueHead(dim)
+        for task in config.get('linear_heads', []):
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(nn.Linear(width, self.CLASSES.get(task, 1)))
+        for task, settings in config.get('residue_readouts', {}).items():
+            self.heads[task] = NormalizedLinear(settings['bins'] * dim, self.CLASSES.get(task, 1))
+        for task, rank in config.get('residue_lowrank_heads', {}).items():
+            bins = config['residue_readouts'][task]['bins']
+            self.heads[task] = LowRankPositionHead(dim, bins, rank, self.CLASSES.get(task, 1))
+        for task in config.get('summary_readouts', []):
+            assert task not in self.PAIR and config.get('pooling') == 'rich'
+            self.heads[task] = NormalizedLinear(7 * dim, self.CLASSES.get(task, 1))
+        for task in config.get('sequence_composition_readouts', []):
+            from sequence_composition import WIDTH
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES
+            assert all(task not in config.get(key,[]) for key in
+                       ['cosine_heads','nonlinear_summary_heads','ss_summary_readouts',
+                        'sequence_conv_readouts','terminal_summary_readouts','token_logmeanexp_heads'])
+            self.heads[task] = NormalizedLinear(7 * dim + WIDTH, self.CLASSES[task])
+        for task, temperature in config.get('cosine_heads', {}).items():
+            assert task in config.get('summary_readouts', [])
+            self.heads[task] = NormalizedCosine(7*dim, self.CLASSES[task], temperature)
+        for task, settings in config.get('nonlinear_summary_heads', {}).items():
+            assert task in config.get('summary_readouts', []) and task not in config.get('cosine_heads', {})
+            self.heads[task] = NormalizedMLP(7*dim, self.CLASSES.get(task,1), settings['hidden'], settings['dropout'])
+        for task in config.get('calibrated_heads', []):
+            assert task not in config.get('summary_readouts', []) and task not in config.get('residue_readouts', {})
+            assert task not in config.get('linear_heads', [])
+            self.heads[task][3] = NormalizedLinear(dim, self.CLASSES.get(task,1))
+        for task in config.get('expanded_pair_readouts', []):
+            assert task in self.PAIR
+            width=3 if task in config.get('symmetric_pair_readouts',[]) else 4
+            if task in config.get('pair_summary_readouts', []):
+                assert config.get('pooling') == 'rich'
+                width *= 8
+            self.heads[task] = NormalizedLinear(width*dim, self.CLASSES.get(task,1))
+        if config.get('ss_linear_context'):
+            self.heads['secondary_structure'] = NormalizedResidueLinear(dim, config['ss_linear_context'])
+        if config.get('ss_calibrated'):
+            assert not config.get('ss_linear_context')
+            self.heads['secondary_structure'] = CalibratedLocalResidueHead(dim)
+        for task in config.get('ss_summary_readouts', []):
+            assert task in config.get('summary_readouts', []) and task not in self.PAIR
+            self.heads[task] = NormalizedLinear(7*dim+40, self.CLASSES[task])
+        for task,settings in config.get('sequence_conv_readouts',{}).items():
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES and task not in self.PAIR
+            self.heads[task] = ResidualSequenceConvHead(dim,self.CLASSES[task],settings['channels'],settings['dropout'],settings.get('retain_summary',True))
+        for task, settings in config.get('terminal_summary_readouts', {}).items():
+            assert task in config.get('summary_readouts', []) and task in self.CLASSES and task not in self.PAIR
+            assert all(task not in config.get(key, {}) for key in
+                       ['cosine_heads', 'nonlinear_summary_heads', 'ss_summary_readouts', 'sequence_conv_readouts'])
+            bins = settings['bins']
+            assert bins > 0 and all(settings[key] > 0 and settings[key] % bins == 0
+                                    for key in ['prefix_residues', 'suffix_residues'])
+            self.heads[task] = NormalizedLinear((7+2*bins)*dim, self.CLASSES[task])
+        if config.get('pair_bilinear_rank', 0):
+            rank = config['pair_bilinear_rank']
+            assert not config.get('pair_summary_readouts')
+            self.pair_bilinear_projection = nn.Linear(dim, rank, bias=False)
+            nn.init.normal_(self.pair_bilinear_projection.weight, std=dim ** -.5)
+            with torch.no_grad():
+                self.pair_bilinear_projection.weight.copy_(F.normalize(self.pair_bilinear_projection.weight, dim=1))
+            self.pair_bilinear_heads = nn.ModuleDict({
+                task: nn.Linear(rank, self.CLASSES.get(task, 1), bias=False)
+                for task in sorted(self.PAIR)})
+            for head in self.pair_bilinear_heads.values():
+                nn.init.zeros_(head.weight)
+            self.register_buffer('pair_bilinear_mean', torch.zeros(dim))
+            self.register_buffer('pair_bilinear_scale', torch.ones(dim))
+        if config.get('pair_residue_interaction'):
+            self.pair_residue_interaction = SharedPairResidueInteraction(
+                dim, config['pair_residue_interaction'], self.CLASSES)
+        for task in config.get('token_logmeanexp_heads', []):
+            assert task in self.CLASSES and task not in self.PAIR
+            assert task not in config.get('sequence_windows', [])
+            self.heads[task] = TokenLogMeanExpHead(dim, self.CLASSES[task])
+        if config.get('ss_chain_decoder', False):
+            self.ss_chain_decoder = SSChainDecoder()
+        if config.get('shared_summary_residual'):
+            settings = config['shared_summary_residual']
+            tasks = settings['tasks']
+            assert all(task in config.get('summary_readouts', []) and
+                       isinstance(self.heads[task], NormalizedLinear) for task in tasks)
+            self.summary_residual = SharedSummaryResidual(7*dim, settings['hidden'], settings['dropout'],
+                                                          {task: self.CLASSES[task] for task in tasks})
+
+    def pair_representation(self, task, first, second, base):
+        if task in self.config.get('pair_bilinear_tasks', []):
+            return {'base': base, 'chain_a': first, 'chain_b': second}
+        return base
+
+    def apply_head(self, task, representation):
+        if task in self.config.get('summary_residual_tasks', []):
+            head = self.heads[task]
+            normalized = (representation-head.mean)/head.scale
+            return head(representation) + self.summary_residual(task, normalized)
+        if isinstance(representation, dict) and 'residue_a' in representation:
+            base = {k:v for k,v in representation.items() if k not in ['residue_a', 'residue_b']}
+            original = self.apply_head(task, base if 'chain_a' in base else base['base'])
+            return original + self.pair_residue_interaction(task, representation['residue_a'], representation['residue_b'])
+        if isinstance(representation, dict) and 'chain_a' in representation:
+            first = (representation['chain_a'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            second = (representation['chain_b'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            interaction = self.pair_bilinear_projection(first) * self.pair_bilinear_projection(second)
+            interaction = interaction / math.sqrt(self.config['pair_bilinear_rank'])
+            return self.heads[task](representation['base']) + self.pair_bilinear_heads[task](interaction)
+        return self.heads[task](representation)
+
+    def encode_residues(self, tokens, task):
+        condition = None
+        if self.config.get('task_conditioning', False):
+            ti = 10 if task == 'secondary_structure' else self.task_index[task]
+            condition = self.task_condition[ti]
+        return self.encoder(tokens, condition=condition, depth=self.config.get('task_encoder_layers',{}).get(task),
+                            extension_depth=self.config.get('task_extension_depths',{}).get(task))
+
+    def pool(self, tokens, task):
+        hidden, pad_mask = self.encode_residues(tokens, task)
+        return self.summarize(hidden, tokens, pad_mask, task)
+
+    def summarize(self, hidden, tokens, pad_mask, task):
+        valid = (~pad_mask).unsqueeze(-1)
+        mean = (hidden * valid).sum(1) / valid.sum(1).clamp_min(1)
+        if self.config.get('pooling', 'mean') == 'mean':
+            return mean
+        residues = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+        # Empty/nonstandard-only inputs still produce a finite representation.
+        residues[:, 0] |= ~residues.any(1)
+        keep = residues.unsqueeze(-1)
+        count = keep.sum(1).clamp_min(1)
+        center = (hidden * keep).sum(1) / count
+        position = residues.cumsum(1).to(hidden.dtype) / count.to(hidden.dtype)
+        basis = torch.stack([position, position.square(), torch.sin(position * math.pi),
+                             torch.cos(position * math.pi)], dim=-1)
+        ti = self.task_index[task]
+        scores = torch.einsum('bld,qd->blq', hidden, self.pool_query[ti]) / math.sqrt(hidden.shape[-1])
+        scores = scores + torch.einsum('blp,qp->blq', basis, self.pool_position[ti])
+        scores = scores.masked_fill(~residues.unsqueeze(-1), -1e4)
+        attention = torch.einsum('blq,bld->bqd', scores.softmax(1), hidden)
+        variance = ((hidden - center[:, None]).float().square() * keep).sum(1) / count
+        deviation = (variance + 1e-5).sqrt().to(hidden.dtype)
+        maximum = hidden.masked_fill(~keep, -1e4).amax(1) - center
+        first = residues & (residues.cumsum(1) <= 32)
+        last = residues & ((residues.sum(1, keepdim=True) - residues.cumsum(1)) < 32)
+        prefix = (hidden * first.unsqueeze(-1)).sum(1) / first.sum(1, keepdim=True).clamp_min(1) - center
+        suffix = (hidden * last.unsqueeze(-1)).sum(1) / last.sum(1, keepdim=True).clamp_min(1) - center
+        summary = torch.cat([attention[:, 0] - center, attention[:, 1] - center,
+                             deviation, maximum, prefix, suffix], dim=-1)
+        if task in self.config.get('summary_readouts', []):
+            return torch.cat([mean, summary], dim=-1)
+        if task in self.config.get('pair_summary_readouts', []):
+            return torch.cat([mean + self.pool_fuse(summary), mean, summary], dim=-1)
+        return mean + self.pool_fuse(summary)
+
+    def pool_sequences(self, sequences, task, device, max_len):
+        if self.training and not self.config.get('window_pooling_training', True):
+            tokens=esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device)
+            return self.pool(tokens,task)
+        if task not in self.config.get('sequence_windows', []) or not any(len(s)>max_len-2 for s in sequences):
+            return self.pool(esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device),task)
+        results=[None]*len(sequences)
+        short=[i for i,s in enumerate(sequences) if len(s)<=max_len-2]
+        if short:
+            pooled=self.pool(esm2.pad_batch([esm2.encode(sequences[i],max_len) for i in short],device),task)
+            for j,index in enumerate(short):results[index]=pooled[j]
+        width=max_len-2;stride=min(768,width)
+        if self.training and self.config.get('batch_window_training',False):
+            pieces=[];starts_by_index={};encoded={}
+            for index,sequence in enumerate(sequences):
+                if len(sequence)<=width:continue
+                starts=list(range(0,len(sequence)-width+1,stride))
+                if starts[-1]!=len(sequence)-width:starts.append(len(sequence)-width)
+                starts_by_index[index]=starts
+                pieces.extend((index,start) for start in starts)
+            count=max(1,16384//max_len)
+            for begin in range(0,len(pieces),count):
+                part=pieces[begin:begin+count]
+                tokens=esm2.pad_batch([esm2.encode(sequences[i][s:s+width],max_len) for i,s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,key in enumerate(part):encoded[key]=hidden[j]
+            positions=torch.arange(width,device=device)
+            weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+            for index,starts in starts_by_index.items():
+                sequence=sequences[index];length=len(sequence)
+                total=torch.zeros(length,self.config['dim'],device=device);counts=torch.zeros(length,1,device=device)
+                for start in starts:
+                    total.index_add_(0,positions+start,encoded[index,start][1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+                assembled=torch.cat([encoded[index,starts[0]][0:1],total/counts.clamp_min(1),encoded[index,starts[-1]][width+1:width+2]],dim=0)[None]
+                tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+                results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+            return torch.stack(results)
+        for index,sequence in enumerate(sequences):
+            length=len(sequence)
+            if length<=width:continue
+            starts=list(range(0,length-width+1,stride))
+            if starts[-1]!=length-width:starts.append(length-width)
+            total=torch.zeros(length,self.config['dim'],device=device)
+            counts=torch.zeros(length,1,device=device)
+            first=last=None
+            for begin in range(0,len(starts),max(1,16384//max_len)):
+                part=starts[begin:begin+max(1,16384//max_len)]
+                tokens=esm2.pad_batch([esm2.encode(sequence[s:s+width],max_len) for s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,start in enumerate(part):
+                    if start==0:first=hidden[j,0:1]
+                    if start==starts[-1]:last=hidden[j,width+1:width+2]
+                    positions=torch.arange(width,device=device)
+                    weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+                    total.index_add_(0,positions+start,hidden[j,1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+            assembled=torch.cat([first,total/counts.clamp_min(1),last],dim=0)[None]
+            tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+            results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+        return torch.stack(results)
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.config.get('sequence_composition_readouts', []):
+            from sequence_composition import composition_features
+            sequences=[item['sequence'] for item in batch]
+            pooled=self.pool_sequences(sequences,task,device,max_len)
+            return torch.cat([pooled.float(),composition_features(sequences,device)],-1)
+        if task in self.config.get('token_logmeanexp_heads', []):
+            tokens = esm2.pad_batch([esm2.encode(row['sequence'], max_len) for row in batch], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            valid = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+            valid[:, 0] |= ~valid.any(1)
+            return {'hidden':hidden, 'valid':valid}
+        if task in self.config.get('terminal_summary_readouts', {}):
+            return self.terminal_summary_features(task, [item['sequence'] for item in batch], device, max_len)
+        if task in self.config.get('ss_summary_readouts', []):
+            sequences=[x['sequence'] for x in batch]
+            summary=self.pool_sequences(sequences,task,device,max_len)
+            structure=self.secondary_structure_summary(sequences,device,max_len)
+            return torch.cat([summary.float(),structure],-1)
+        if task in self.config.get('sequence_conv_readouts',{}):
+            tokens=esm2.pad_batch([esm2.encode(x['sequence'],max_len) for x in batch],device)
+            hidden,pad_mask=self.encode_residues(tokens,task)
+            lengths=torch.tensor([min(len(x['sequence']),max_len-2) for x in batch],device=device)
+            width=max(1,int(lengths.max()))
+            valid=torch.arange(width,device=device)[None,:]<lengths[:,None]
+            return {'hidden':hidden[:,1:1+width], 'valid':valid,
+                    'summary':self.summarize(hidden,tokens,pad_mask,task)}
+        if task in self.config.get('residue_readouts', {}):
+            bins = self.config['residue_readouts'][task]['bins']
+            sequences = [x['sequence'] for x in batch]
+            tokens = esm2.pad_batch([esm2.encode(s, max_len) for s in sequences], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            return self.position_features(hidden, [min(len(s), max_len-2) for s in sequences], bins)
+        if task in self.PAIR:
+            a = self.pool_sequences([x['sequence_a'] for x in batch],task,device,max_len)
+            b = self.pool_sequences([x['sequence_b'] for x in batch],task,device,max_len)
+            if task in self.config.get('expanded_pair_readouts', []):
+                if task in self.config.get('symmetric_pair_readouts',[]):
+                    features=torch.cat([(a.float()+b.float())*.5,a*b,(a-b).abs()],dim=-1)
+                else:
+                    features=torch.cat([a,b,a*b,(a-b).abs()],dim=-1)
+                base = F.dropout(features,p=self.config.get('pair_dropout',0.),training=self.training)
+                return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+            output = torch.cat([a, b], dim=-1)
+            if self.config.get('pair_interaction', False):
+                output = output + self.pair_fuse(torch.cat([a * b, (a - b).abs()], dim=-1))
+            base = F.dropout(output, p=self.config.get('pair_dropout', 0.0), training=self.training)
+            return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+        return self.pool_sequences([x['sequence'] for x in batch],task,device,max_len)
+
+    def add_pair_residues(self, task, batch, device, max_len, base):
+        if task not in self.config.get('pair_residue_tasks', []):
+            return base
+        result = dict(base) if isinstance(base, dict) else {'base': base}
+        bins = self.config['pair_residue_interaction']['bins']
+        for role, name in [('a', 'sequence_a'), ('b', 'sequence_b')]:
+            result['residue_'+role] = self.pool_residue_bins(
+                [row[name] for row in batch], task, device, max_len, bins)
+        return result
+
+    def pool_residue_bins(self, sequences, task, device, max_len, bins):
+        """Average every residue into fixed relative bins, with full-chain context."""
+        width = max_len-2
+        assert width > 0 and bins > 0
+        output = [None]*len(sequences)
+        short = [i for i, sequence in enumerate(sequences) if len(sequence) <= width]
+        if short:
+            tokens = esm2.pad_batch([esm2.encode(sequences[i], max_len) for i in short], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            for j, index in enumerate(short):
+                length = len(sequences[index])
+                values = hidden[j, 1:1+length].float()
+                output[index] = (F.adaptive_avg_pool1d(values.T[None], bins)[0].T if length
+                                 else torch.zeros(bins, self.config['dim'], device=device))
+        for index, sequence in enumerate(sequences):
+            if len(sequence) <= width:
+                continue
+            starts = list(range(0, len(sequence)-width+1, min(768, width)))
+            if starts[-1] != len(sequence)-width:
+                starts.append(len(sequence)-width)
+            total = torch.zeros(len(sequence), self.config['dim'], device=device)
+            count = torch.zeros(len(sequence), 1, device=device)
+            position = torch.arange(width, device=device)
+            weight = torch.minimum(torch.minimum(position+1, width-position),
+                                   torch.full_like(position, 128)).float()[:, None]
+            for begin in range(0, len(starts), max(1, 16384//max_len)):
+                part = starts[begin:begin+max(1, 16384//max_len)]
+                tokens = esm2.pad_batch([esm2.encode(sequence[s:s+width], max_len) for s in part], device)
+                hidden, _ = self.encode_residues(tokens, task)
+                for j, start in enumerate(part):
+                    total.index_add_(0, position+start, hidden[j, 1:1+width].float()*weight)
+                    count.index_add_(0, position+start, weight)
+            values = total/count.clamp_min(1)
+            output[index] = F.adaptive_avg_pool1d(values.T[None], bins)[0].T
+        return torch.stack(output)
+
+    @staticmethod
+    def terminal_bins(states, width, bins, align_end=False):
+        """Fixed absolute residue bins; exclude padding from partial-bin means."""
+        assert width > 0 and bins > 0 and width % bins == 0
+        states = (states[-width:] if align_end else states[:width]).float()
+        count = states.shape[0]
+        padded = states.new_zeros(width, states.shape[-1])
+        valid = states.new_zeros(width)
+        offset = width-count if align_end else 0
+        padded[offset:offset+count] = states
+        valid[offset:offset+count] = 1
+        total = padded.reshape(bins, width//bins, -1).sum(1)
+        denominator = valid.reshape(bins, width//bins).sum(1).clamp_min(1)[:, None]
+        return (total/denominator).flatten()
+
+    def terminal_summary_features(self, task, sequences, device, max_len):
+        settings = self.config['terminal_summary_readouts'][task]
+        width = max_len-2
+        assert width >= max(settings['prefix_residues'], settings['suffix_residues'])
+        tokens = esm2.pad_batch([esm2.encode(sequence, max_len) for sequence in sequences], device)
+        hidden, padding = self.encode_residues(tokens, task)
+        summary = self.summarize(hidden, tokens, padding, task)
+        long_ids = [index for index, sequence in enumerate(sequences) if len(sequence) > width]
+        tails = {}
+        if long_ids:
+            tail_tokens = esm2.pad_batch([esm2.encode(sequences[index][-width:], max_len)
+                                         for index in long_ids], device)
+            tail_hidden, _ = self.encode_residues(tail_tokens, task)
+            tails = {index: tail_hidden[local, 1:width+1] for local, index in enumerate(long_ids)}
+        terminals = []
+        for index, sequence in enumerate(sequences):
+            prefix = hidden[index, 1:1+min(len(sequence), width)]
+            suffix = tails.get(index, prefix)
+            terminals.append(torch.cat([
+                self.terminal_bins(prefix, settings['prefix_residues'], settings['bins']),
+                self.terminal_bins(suffix, settings['suffix_residues'], settings['bins'], align_end=True)]))
+        return torch.cat([summary.float(), torch.stack(terminals)], dim=-1)
+
+    @staticmethod
+    def position_features(hidden, lengths, bins):
+        features = []
+        for index, length in enumerate(lengths):
+            if length:
+                states = hidden[index:index+1, 1:1+length].float().transpose(1, 2)
+                features.append(F.interpolate(states, size=bins, mode='linear', align_corners=True).flatten())
+            else:
+                features.append(hidden.new_zeros(hidden.shape[-1] * bins).float())
+        return torch.stack(features)
+
+    def secondary_structure_summary(self, sequences, device, max_len):
+        tokens=esm2.pad_batch([esm2.encode(sequence,max_len) for sequence in sequences],device)
+        hidden,_=self.encode_residues(tokens,'secondary_structure')
+        with torch.autocast(device_type=device.type,enabled=False):
+            probabilities=self.heads['secondary_structure'](hidden.float()).softmax(-1)
+        summaries=[]
+        for index,sequence in enumerate(sequences):
+            length=min(len(sequence),max_len-2)
+            if not length:
+                summaries.append(probabilities.new_zeros(40));continue
+            value=probabilities[index,1:1+length]
+            mean=value.mean(0);std=value.std(0,unbiased=False)
+            transition=(value[:-1,:,None]*value[1:,None,:]).mean(0).flatten() if length>1 else value.new_zeros(9)
+            positions=F.adaptive_avg_pool1d(value.T[None],8).flatten()
+            summaries.append(torch.cat([mean,std,transition,positions,value.new_tensor([math.log1p(length)])]))
+        return torch.stack(summaries)
+
+    def normalize(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return (values - stats['mean']) / stats['std'] if stats else values
+
+    def unscale(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return values * stats['std'] + stats['mean'] if stats else values
+
+    def transfer(self, state, normalized_source=False):
+        """Transfer our own lineage only; retain random init for new parameters."""
+        current = self.state_dict()
+        fitting = {k: v for k, v in state.items() if k in current and v.shape == current[k].shape}
+        missing, unexpected = self.load_state_dict(fitting, strict=False)
+        if not normalized_source:
+            with torch.no_grad():
+                for task, stats in self.config.get('regression_stats', {}).items():
+                    # Preserve predictions when moving a trained head to standardized units.
+                    if f'heads.{task}.3.weight' in fitting:
+                        self.heads[task][3].weight.div_(stats['std'])
+                        self.heads[task][3].bias.sub_(stats['mean']).div_(stats['std'])
+        return {'transferred': len(fitting), 'new_tensors': missing, 'unexpected': unexpected}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S055/PUBLISHED.json

@@ -0,0 +1,5 @@
+{
+  "source": "/run-state/workspace/research/production-dual-summary-subcellular1/candidate/package",
+  "files": 9,
+  "bytes": 555777281
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S055/README.md

@@ -0,0 +1,66 @@
+# Unified PEER protein model
+
+One jointly learned 12-layer, width-512, 8-head transformer supplies all eleven
+tasks. Its original **37,845,535 parameters** are used by every task; two shared
+extension blocks serve beta-lactamase and stability. Exact total:
+**138,135,449 parameters** in one inference state dictionary.
+
+Subcellular localization concatenates seven summaries from this common
+backbone with seven from one 12-layer, width-768, 12-head auxiliary encoder
+(85,079,839 parameters). That encoder was also jointly trained on all eleven
+tasks in this session. Only its active pooling row is included. The subcellular
+head substantially depends on both representations: replacing primary features
+by their fixed fit mean reduces Tune accuracy from 0.7908 to 0.7364; removing
+auxiliary features reduces it to 0.5991. Other tasks retain their existing paths.
+
+All weights originated from random initialization and training in this session.
+The primary encoder received one hour of MLM on mounted decontaminated UniRef50
+(1,713,641,682 token presentations), then joint all-task supervision, task
+conditioning and shared-extension training. The auxiliary received eight hours
+of MLM (10,254,509,402 token presentations) and 8,486 joint supervised updates.
+Only the mounted UniRef50, fit and permitted Tune data were used. No external
+pretrained weights or embeddings were used.
+
+Heads:
+
+- Fluorescence and beta-lactamase: normalized linear heads over interpolated
+  residue positions, trained on rank targets.
+- Fold and solubility: normalized linear heads over seven sequence summaries.
+- Subcellular localization: one fit-normalized linear head over both encoders'
+  summaries, fixed ridge 0.01 and 15 blocks of at most 10 LBFGS iterations.
+- Binary localization: summary head with a shared nonlinear residual jointly
+  trained across solubility and both localization tasks.
+- Stability: MLP and normalized final linear head, with balanced length-group
+  loss and a fixed 50:50 continuation midpoint.
+- Human PPI: ordered summaries, product and absolute difference. Yeast and
+  affinity use symmetric summaries; yeast also uses shared bilinear and residue
+  interaction modules jointly trained across all three PPI tasks.
+- Secondary structure: local convolution and residue MLP, with fit-only
+  supervision and distillation from an own-session jointly trained teacher.
+  Teacher parameters and cached features are absent.
+
+Model selection uses complete fit-only Tune replays and fixed matched controls.
+The new development mean is **0.7200272190**, versus 0.7166638090. Subcellular
+accuracy improves from 0.7538242618 to 0.7908217716 (+104/2,811 cases), with a
+conditional paired 95% difference interval [0.02418, 0.05052]; the other ten
+development prediction files are byte-identical. Both matched single-source
+controls score lower. Only final, predeclared readout endpoints were eligible.
+
+Production retains the five previously accepted extra-label heads: fold,
+fluorescence, beta-lactamase, affinity and stability. Each used fixed two-half
+cross-fit evidence before fitting its full permitted fit+Tune pool. Their
+features and parameters remain exactly unchanged. Their production Tune scores
+and the aggregate are IN-SAMPLE and excluded from development selection.
+The new subcellular head uses fit labels and fit normalization only.
+Complete independent production replay is valid for all eleven tasks. The ten
+other prediction files are byte-identical to previous production, and the new
+subcellular file is byte-identical to the accepted development candidate.
+
+Repeated Tune selection and protein-family dependence limit the conditional
+intervals. Fold generalization remains weak, and PPI validation sets are small.
+SS and PPI use full-chain windows; other tasks retain a 1,022-residue prefix.
+Rank outputs are not calibrated for absolute error. No held-out test results
+are available.
+
+Run `bash infer.sh INPUT_ROOT OUTPUT_ROOT` offline. This single parameter set
+needs no live trainer, research files, lookup tables or test-time fitting.

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S055/config.json

@@ -0,0 +1,142 @@
+{
+  "layers": 12,
+  "dim": 512,
+  "heads": 8,
+  "pooling": "rich",
+  "pair_interaction": true,
+  "ss_context": true,
+  "max_len": 1024,
+  "pair_dropout": 0.0,
+  "architecture": "unified",
+  "full_ss": true,
+  "regression_stats": {
+    "fluorescence": {
+      "mean": 3.180586883940159,
+      "std": 0.8339910288860748
+    },
+    "stability": {
+      "mean": 0.1790524860555312,
+      "std": 0.5662245232305059
+    },
+    "beta_lactamase": {
+      "mean": 0.7383112351980983,
+      "std": 0.31642946622284734
+    },
+    "ppi_affinity": {
+      "mean": -11.654589870742203,
+      "std": 3.0832061340498944
+    }
+  },
+  "residue_readouts": {
+    "fluorescence": {
+      "bins": 256
+    },
+    "beta_lactamase": {
+      "bins": 320
+    }
+  },
+  "fp32_heads": [
+    "beta_lactamase",
+    "binary_localization",
+    "fluorescence",
+    "fold",
+    "human_ppi",
+    "ppi_affinity",
+    "secondary_structure",
+    "solubility",
+    "stability",
+    "subcellular_localization",
+    "yeast_ppi"
+  ],
+  "ss_linear_context": 0,
+  "ss_calibrated": true,
+  "linear_heads": [],
+  "summary_readouts": [
+    "solubility",
+    "subcellular_localization",
+    "binary_localization",
+    "fold"
+  ],
+  "cosine_heads": {},
+  "nonlinear_summary_heads": {},
+  "calibrated_heads": [
+    "stability"
+  ],
+  "sequence_windows": [
+    "yeast_ppi",
+    "human_ppi"
+  ],
+  "expanded_pair_readouts": [
+    "yeast_ppi",
+    "human_ppi",
+    "ppi_affinity"
+  ],
+  "symmetric_pair_readouts": [
+    "yeast_ppi",
+    "ppi_affinity"
+  ],
+  "task_encoder_layers": {},
+  "task_conditioning": true,
+  "pair_summary_readouts": [],
+  "extension_layers": 2,
+  "window_pooling_training": true,
+  "batch_window_training": true,
+  "class_weight_power": {
+    "fold": 0.5
+  },
+  "task_extension_depths": {
+    "beta_lactamase": 2,
+    "binary_localization": 0,
+    "fluorescence": 0,
+    "fold": 0,
+    "human_ppi": 0,
+    "ppi_affinity": 0,
+    "secondary_structure": 0,
+    "solubility": 0,
+    "stability": 2,
+    "subcellular_localization": 0,
+    "yeast_ppi": 0
+  },
+  "task_max_len": {
+    "human_ppi": 1536
+  },
+  "pair_bilinear_rank": 32,
+  "pair_bilinear_tasks": [
+    "yeast_ppi"
+  ],
+  "pair_residue_interaction": {
+    "bins": 64,
+    "projection_dim": 32,
+    "pair_hidden": 32,
+    "pair_channels": 8,
+    "dropout": 0.1
+  },
+  "pair_residue_tasks": [
+    "yeast_ppi"
+  ],
+  "rank_target_tasks": [
+    "fluorescence",
+    "beta_lactamase"
+  ],
+  "ss_summary_readouts": [],
+  "terminal_summary_readouts": {},
+  "residue_lowrank_heads": {},
+  "shared_summary_residual": {
+    "tasks": [
+      "binary_localization"
+    ],
+    "hidden": 128,
+    "dropout": 0.2
+  },
+  "summary_residual_tasks": [
+    "binary_localization"
+  ],
+  "dual_summary": {
+    "layers": 12,
+    "dim": 768,
+    "heads": 12,
+    "tasks": [
+      "subcellular_localization"
+    ]
+  }
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S055/esm2.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""An ESM-2 architecture, trained from scratch, as the reference baseline.
+
+Follows Lin et al. (Science 2023) / facebookresearch/esm in the ways that
+matter for a like-for-like architecture claim:
+
+  * rotary position embeddings, not learned positional embeddings -- this is
+    the defining architectural change from ESM-1b to ESM-2
+  * pre-LayerNorm blocks, GELU feed-forward at 4x expansion
+  * final LayerNorm before the LM head, and the LM head's projection weight
+    tied to the token embedding
+  * the ESM alphabet's special tokens (<cls>/<pad>/<eos>/<mask>) and the same
+    20 standard + rare amino-acid symbols
+
+The published size ladder is reproduced in CONFIGS so the baseline can be named
+by its ESM-2 counterpart rather than by an arbitrary width.
+"""
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ESM-2's alphabet, in its canonical order.
+SPECIALS = ["<cls>", "<pad>", "<eos>", "<unk>"]
+RESIDUES = list("LAGVSERTIDPKQNFYMHWCXBUZO")
+EXTRA = ["<null_1>", "<mask>"]
+ALPHABET = SPECIALS + RESIDUES + EXTRA
+TOKEN = {symbol: index for index, symbol in enumerate(ALPHABET)}
+CLS, PAD, EOS, UNK = TOKEN["<cls>"], TOKEN["<pad>"], TOKEN["<eos>"], TOKEN["<unk>"]
+MASK = TOKEN["<mask>"]
+VOCAB_SIZE = len(ALPHABET)
+FIRST_RESIDUE, LAST_RESIDUE = TOKEN["L"], TOKEN["O"]
+
+# name -> (layers, embed_dim, attention_heads), from the ESM-2 release table.
+CONFIGS = {
+    "esm2_t6_8M":    (6, 320, 20),
+    "esm2_t12_35M":  (12, 480, 20),
+    "esm2_t30_150M": (30, 640, 20),
+    "esm2_t33_650M": (33, 1280, 20),
+}
+
+
+def encode(sequence, max_len=1024):
+    body = [TOKEN.get(c, UNK) for c in sequence[:max_len - 2]]
+    return [CLS] + body + [EOS]
+
+
+def pad_batch(sequences, device):
+    width = max(len(s) for s in sequences)
+    out = torch.full((len(sequences), width), PAD, dtype=torch.long)
+    for row, ids in enumerate(sequences):
+        out[row, :len(ids)] = torch.tensor(ids, dtype=torch.long)
+    return out.to(device, non_blocking=True)
+
+
+class Rotary(nn.Module):
+    """Rotary position embedding, as ESM-2 applies it to q and k."""
+
+    def __init__(self, dim, base=10000):
+        super().__init__()
+        inverse = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inverse", inverse, persistent=False)
+        self._cached_length = 0
+
+    def _tables(self, length, device, dtype):
+        if length != self._cached_length or self._cos.device != device:
+            position = torch.arange(length, device=device, dtype=torch.float)
+            angles = torch.outer(position, self.inverse.to(device))
+            table = torch.cat([angles, angles], dim=-1)
+            self._cos = table.cos()[None, None]
+            self._sin = table.sin()[None, None]
+            self._cached_length = length
+        return self._cos.to(dtype), self._sin.to(dtype)
+
+    @staticmethod
+    def _rotate_half(x):
+        half = x.shape[-1] // 2
+        return torch.cat([-x[..., half:], x[..., :half]], dim=-1)
+
+    def forward(self, q, k):
+        cos, sin = self._tables(q.shape[-2], q.device, q.dtype)
+        return (q * cos + self._rotate_half(q) * sin,
+                k * cos + self._rotate_half(k) * sin)
+
+
+class Attention(nn.Module):
+    def __init__(self, dim, heads):
+        super().__init__()
+        self.heads = heads
+        self.head_dim = dim // heads
+        self.q = nn.Linear(dim, dim)
+        self.k = nn.Linear(dim, dim)
+        self.v = nn.Linear(dim, dim)
+        self.out = nn.Linear(dim, dim)
+        self.rotary = Rotary(self.head_dim)
+
+    def forward(self, x, pad_mask):
+        batch, length, _ = x.shape
+        shape = (batch, length, self.heads, self.head_dim)
+        q = self.q(x).view(shape).transpose(1, 2)
+        k = self.k(x).view(shape).transpose(1, 2)
+        v = self.v(x).view(shape).transpose(1, 2)
+        q, k = self.rotary(q, k)
+        attention_mask = None
+        if pad_mask is not None:
+            attention_mask = (~pad_mask)[:, None, None, :]
+        hidden = F.scaled_dot_product_attention(q, k, v, attn_mask=attention_mask)
+        hidden = hidden.transpose(1, 2).reshape(batch, length, -1)
+        return self.out(hidden)
+
+
+class Block(nn.Module):
+    def __init__(self, dim, heads, ffn):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim)
+        self.attention = Attention(dim, heads)
+        self.norm2 = nn.LayerNorm(dim)
+        self.ffn = nn.Sequential(nn.Linear(dim, ffn), nn.GELU(), nn.Linear(ffn, dim))
+
+    def forward(self, x, pad_mask, condition=None):
+        first = self.norm1(x)
+        if condition is not None:
+            first = first * (1 + condition[0]) + condition[1]
+        x = x + self.attention(first, pad_mask)
+        second = self.norm2(x)
+        if condition is not None:
+            second = second * (1 + condition[2]) + condition[3]
+        return x + self.ffn(second)
+
+
+class Encoder(nn.Module):
+    """The shared backbone. Every task reads from this one parameter set."""
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.dim = dim
+        self.embed = nn.Embedding(VOCAB_SIZE, dim, padding_idx=PAD)
+        self.blocks = nn.ModuleList([Block(dim, heads, dim * 4) for _ in range(layers)])
+        self.norm = nn.LayerNorm(dim)
+        self.lm_bias = nn.Parameter(torch.zeros(VOCAB_SIZE))
+        self.apply(self._init)
+
+    @staticmethod
+    def _init(module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, std=0.02)
+
+    def add_extension(self, layers, heads, before_norm=False):
+        """Append shared residual blocks after the original normalized representation."""
+        assert layers > 0 and not hasattr(self, 'extension')
+        self.extension_before_norm = bool(before_norm)
+        self.extension = nn.ModuleList([Block(self.dim, heads, 4*self.dim) for _ in range(layers)])
+        self.extension.apply(self._init)
+        # Identity at initialization preserves every existing readout exactly.
+        for block in self.extension:
+            nn.init.zeros_(block.attention.out.weight)
+            nn.init.zeros_(block.attention.out.bias)
+            nn.init.zeros_(block.ffn[2].weight)
+            nn.init.zeros_(block.ffn[2].bias)
+
+    def forward(self, tokens, condition=None, depth=None, extension_depth=None):
+        pad_mask = tokens.eq(PAD)
+        hidden = self.embed(tokens)
+        depth=len(self.blocks) if depth is None else int(depth)
+        if not 1<=depth<=len(self.blocks):
+            raise ValueError(f'Encoder depth {depth} is outside 1..{len(self.blocks)}')
+        for index, block in enumerate(self.blocks):
+            if index>=depth:
+                break
+            hidden = block(hidden, pad_mask, condition[index] if condition is not None else None)
+        # Local residue heads must not observe artificial states at padded
+        # positions; otherwise predictions near the C terminus depend on which
+        # other sequences share the batch. Valid transformer states are unchanged.
+        before_norm = getattr(self, 'extension_before_norm', False)
+        if not before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        extension = getattr(self, 'extension', ())
+        extension_depth = len(extension) if extension_depth is None else int(extension_depth)
+        if not 0 <= extension_depth <= len(extension):
+            raise ValueError(f'Extension depth {extension_depth} is outside 0..{len(extension)}')
+        for index, block in enumerate(extension):
+            if index >= extension_depth:
+                break
+            hidden = block(hidden, pad_mask).masked_fill(pad_mask.unsqueeze(-1), 0)
+        if before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        return hidden, pad_mask
+
+    def lm_logits(self, hidden):
+        # Weight tying, as in ESM-2's RobertaLMHead.
+        return F.linear(hidden, self.embed.weight) + self.lm_bias
+
+    def pool(self, tokens):
+        hidden, pad_mask = self.forward(tokens)
+        keep = (~pad_mask).to(hidden.dtype).unsqueeze(-1)
+        return (hidden * keep).sum(1) / keep.sum(1).clamp(min=1)
+
+
+class Model(nn.Module):
+    """ESM-2 backbone plus the eleven PEER task heads."""
+
+    CLASSES = {"solubility": 2, "subcellular_localization": 10,
+               "binary_localization": 2, "fold": 1195,
+               "yeast_ppi": 2, "human_ppi": 2}
+    REGRESSION = ("fluorescence", "stability", "beta_lactamase", "ppi_affinity")
+    PAIR = {"yeast_ppi", "human_ppi", "ppi_affinity"}
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.encoder = Encoder(layers=layers, dim=dim, heads=heads)
+        self.heads = nn.ModuleDict()
+        for task, n in self.CLASSES.items():
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, n))
+        for task in self.REGRESSION:
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 1))
+        self.heads["secondary_structure"] = nn.Sequential(
+            nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.PAIR:
+            a = self.encoder.pool(pad_batch(
+                [encode(x["sequence_a"], max_len) for x in batch], device))
+            b = self.encoder.pool(pad_batch(
+                [encode(x["sequence_b"], max_len) for x in batch], device))
+            return torch.cat([a, b], dim=-1)
+        return self.encoder.pool(pad_batch(
+            [encode(x["sequence"], max_len) for x in batch], device))
+
+
+def build(name="esm2_t12_35M"):
+    layers, dim, heads = CONFIGS[name]
+    model = Model(layers=layers, dim=dim, heads=heads)
+    return model, {"name": name, "layers": layers, "dim": dim, "heads": heads}
+
+
+if __name__ == "__main__":
+    for name in CONFIGS:
+        model, config = build(name)
+        backbone = sum(p.numel() for p in model.encoder.parameters())
+        total = sum(p.numel() for p in model.parameters())
+        print(f"{name:16s} backbone {backbone/1e6:7.2f}M   with heads {total/1e6:7.2f}M")

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S055/infer.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PYTHONDONTWRITEBYTECODE=1
+exec python3 "$(dirname "$0")/replay.py" "$1" "$2"

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S055/replay.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Self-contained replay shared by research evaluation and frozen packages."""
+import contextlib
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+
+import esm2
+
+TASKS = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+         'subcellular_localization', 'binary_localization', 'fold',
+         'secondary_structure', 'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+
+def autocast(device):
+    return torch.autocast('cuda', dtype=torch.bfloat16) if device.type == 'cuda' else contextlib.nullcontext()
+
+
+def head_output(model, task, representation, device, fp32=False):
+    apply = model.apply_head if hasattr(model, 'apply_head') else lambda task, value: model.heads[task](value)
+    if fp32:
+        with torch.autocast(device.type, enabled=False):
+            values={k:v.float() if v.is_floating_point() else v for k,v in representation.items()} if isinstance(representation,dict) else representation.float()
+            return apply(task, values).float()
+    return apply(task, representation).float()
+
+
+def residue_states(model, tokens, task):
+    return model.encode_residues(tokens, task) if hasattr(model, 'encode_residues') else model.encoder(tokens)
+
+
+def windows(length, width=1022, stride=768):
+    if length <= width:
+        return [(0, length)]
+    starts = list(range(0, length - width + 1, stride))
+    if starts[-1] != length - width:
+        starts.append(length - width)
+    return [(s, min(s + width, length)) for s in starts]
+
+
+def batches(rows, task, token_budget=16384, max_len=1024, max_batch=128):
+    lengths = [min(max(map(len, r['features'].values())) + 2, max_len) for r in rows]
+    order = sorted(range(len(rows)), key=lengths.__getitem__)
+    current, width = [], 0
+    for i in order:
+        length = lengths[i]
+        # Pair sequences require two separate passes, but the peak tensor size is unchanged.
+        if current and (max(width, length) * (len(current) + 1) > token_budget or len(current) >= max_batch):
+            yield current
+            current, width = [], 0
+        current.append(i)
+        width = max(width, length)
+    if current:
+        yield current
+
+
+@torch.inference_mode()
+def predict_records(model, rows, task, device, config=None, token_budget=16384):
+    config = config or {}
+    max_len = config.get('task_max_len', {}).get(task, config.get('max_len', 1024))
+    full_ss = config.get('full_ss', True)
+    fp32_option = config.get('fp32_heads', False)
+    fp32_heads = fp32_option is True or (isinstance(fp32_option, list) and task in fp32_option)
+    was_training = model.training
+    model.eval()
+    result = {}
+    for ids in batches(rows, task, token_budget, max_len):
+        chunk = [rows[i] for i in ids]
+        features = [r['features'] for r in chunk]
+        if task == 'secondary_structure':
+            if full_ss and any(len(f['sequence']) > max_len - 2 for f in features):
+                for record in chunk:
+                    seq = record['features']['sequence']
+                    pieces = windows(len(seq), max_len - 2, min(768, max_len - 2))
+                    total = np.zeros((len(seq), 3), dtype=np.float32)
+                    weight_sum = np.zeros((len(seq), 1), dtype=np.float32)
+                    for begin in range(0, len(pieces), max(1, token_budget // max_len)):
+                        part = pieces[begin:begin + max(1, token_budget // max_len)]
+                        tokens = esm2.pad_batch([esm2.encode(seq[s:e], max_len) for s, e in part], device)
+                        with autocast(device):
+                            hidden, _ = residue_states(model, tokens, task)
+                            logits = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                        for j, (s, e) in enumerate(part):
+                            size = e - s
+                            # Smooth boundaries, without discarding any residue.
+                            weight = np.minimum(np.arange(1, size + 1), np.arange(size, 0, -1))
+                            weight = np.minimum(weight, 128).astype(np.float32)[:, None]
+                            total[s:e] += logits[j, 1:1+size] * weight
+                            weight_sum[s:e] += weight
+                    scores = total / np.maximum(weight_sum, 1)
+                    result[record['example_id']] = {'ss3_scores': scores.tolist()}
+            else:
+                tokens = esm2.pad_batch([esm2.encode(f['sequence'], max_len) for f in features], device)
+                with autocast(device):
+                    hidden, _ = residue_states(model, tokens, task)
+                    probabilities = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                for j, record in enumerate(chunk):
+                    length = len(record['features']['sequence'])
+                    used = min(length, max_len - 2)
+                    scores = probabilities[j, 1:1+used].tolist()
+                    scores.extend([[1.0, 1.0, 1.0] for _ in range(length-used)])
+                    result[record['example_id']] = {'ss3_scores': scores}
+            continue
+        with autocast(device):
+            representation = model.represent(task, features, device, max_len)
+            output = head_output(model, task, representation, device, fp32_heads)
+            if task in model.CLASSES:
+                output = output.softmax(-1)
+            if task in config.get('symmetric_pairs', []):
+                swapped = [{'sequence_a': f['sequence_b'], 'sequence_b': f['sequence_a']} for f in features]
+                swapped_rep = model.represent(task, swapped, device, max_len)
+                second = head_output(model, task, swapped_rep, device, fp32_heads)
+                if task in model.CLASSES:
+                    second = second.softmax(-1)
+                output = (output + second) * 0.5
+            if task in model.CLASSES:
+                output = output.clamp_min(1e-9)
+            elif hasattr(model, 'unscale'):
+                output = model.unscale(task, output)
+        values = output.cpu().tolist()
+        for record, value in zip(chunk, values):
+            result[record['example_id']] = {'scores': value} if task in model.CLASSES else {'value': value[0]}
+    if task == 'secondary_structure' and hasattr(model, 'ss_chain_decoder'):
+        # Decode complete chains only after all overlapping-window probabilities
+        # have been aggregated. No labels or parameter updates enter replay.
+        identifiers = [record['example_id'] for record in rows]
+        probabilities = [result[identifier]['ss3_scores'] for identifier in identifiers]
+        decoded = model.ss_chain_decoder.decode(probabilities)
+        for identifier, scores in zip(identifiers, decoded):
+            result[identifier] = {'ss3_scores': scores.tolist()}
+    model.train(was_training)
+    return result
+
+
+def load_model(package, device):
+    config = json.loads((package / 'config.json').read_text())
+    if config.get('architecture') == 'unified':
+        from unified import UnifiedModel
+        model = UnifiedModel(config)
+    else:
+        model = esm2.Model(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+    model.load_state_dict(torch.load(package / 'model.pt', map_location='cpu', weights_only=True))
+    return model.to(device).eval(), config
+
+
+def main():
+    if len(sys.argv) != 3:
+        raise SystemExit('usage: replay.py INPUT_ROOT OUTPUT_ROOT')
+    torch.set_num_threads(6)
+    source, destination = Path(sys.argv[1]), Path(sys.argv[2]) / 'predictions'
+    destination.mkdir(parents=True, exist_ok=True)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model, config = load_model(Path(__file__).resolve().parent, device)
+    for task in TASKS:
+        rows = [json.loads(line) for line in (source / f'{task}.jsonl').open()]
+        predictions = predict_records(model, rows, task, device, config)
+        with (destination / f'{task}.jsonl').open('w') as sink:
+            for row in rows:
+                sink.write(json.dumps({'example_id': row['example_id'], 'prediction': predictions[row['example_id']]}, separators=(',', ':')) + '\n')
+
+
+if __name__ == '__main__':
+    main()

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S055/selection.json

@@ -0,0 +1,180 @@
+{
+  "score_kind": "tune_labels_used_for_fold_fluorescence_beta_lactamase_ppi_affinity_and_stability",
+  "tasks_reusing_tune_labels": [
+    "beta_lactamase",
+    "fluorescence",
+    "fold",
+    "ppi_affinity",
+    "stability"
+  ],
+  "production_aggregate_excluded_from_selection": true,
+  "fit_only_development_reference": {
+    "reward": 0.720027219000325,
+    "tasks": {
+      "beta_lactamase": {
+        "invalid_reason": null,
+        "reward": 0.8851158090618965,
+        "spearman": 0.8851158090618965
+      },
+      "binary_localization": {
+        "accuracy": 0.9462116830537883,
+        "balanced_accuracy": 0.9419155998103367,
+        "invalid_reason": null,
+        "macro_f1": 0.9439947337349208,
+        "reward": 0.9462116830537883
+      },
+      "fluorescence": {
+        "invalid_reason": null,
+        "reward": 0.826705913429907,
+        "spearman": 0.826705913429907
+      },
+      "fold": {
+        "accuracy": 0.24864130434782608,
+        "balanced_accuracy": 0.16124022176653757,
+        "invalid_reason": null,
+        "macro_f1": 0.03846637235687955,
+        "reward": 0.24864130434782608
+      },
+      "human_ppi": {
+        "accuracy": 0.7968253968253968,
+        "balanced_accuracy": 0.8005952380952381,
+        "invalid_reason": null,
+        "macro_f1": 0.7968233491897122,
+        "reward": 0.7968253968253968
+      },
+      "ppi_affinity": {
+        "invalid_reason": null,
+        "reward": 0.5341420012716276,
+        "rmse": 1.9334586965956642,
+        "spearman": 0.7162121646852028
+      },
+      "secondary_structure": {
+        "accuracy": 0.7441316787896526,
+        "invalid_reason": null,
+        "reward": 0.7441316787896526,
+        "valid_residues": 556931
+      },
+      "solubility": {
+        "accuracy": 0.7533851915874388,
+        "balanced_accuracy": 0.7392508255204544,
+        "invalid_reason": null,
+        "macro_f1": 0.742264399722415,
+        "reward": 0.7533851915874388
+      },
+      "stability": {
+        "invalid_reason": null,
+        "reward": 0.7311607642876724,
+        "spearman": 0.7311607642876724
+      },
+      "subcellular_localization": {
+        "accuracy": 0.7908217716115261,
+        "balanced_accuracy": 0.6999121500389823,
+        "invalid_reason": null,
+        "macro_f1": 0.7198401417205603,
+        "reward": 0.7908217716115261
+      },
+      "yeast_ppi": {
+        "accuracy": 0.6631578947368421,
+        "balanced_accuracy": 0.6597985347985349,
+        "invalid_reason": null,
+        "macro_f1": 0.6567299006323397,
+        "reward": 0.6631578947368421
+      }
+    },
+    "package": "/workspace/research/dual-summary-subcellular1-replay/candidate/package",
+    "report": "/workspace/research/dual-summary-subcellular1-replay/candidate/report.json",
+    "model_sha256": "1b5b390aae06941e5a43cfd8ea681df090499e916750d08604e32963da54a1da",
+    "inference_assets_sha256": {
+      "model.pt": "1b5b390aae06941e5a43cfd8ea681df090499e916750d08604e32963da54a1da",
+      "config.json": "9a737008935673cd4bbfc6df460d7805737a9eabfd77bae76dfaa6e72ac26d9f",
+      "esm2.py": "d4d512296047ebbd0f9a26dc1390107f72762cb5de011eefc9fecb18118a9be9",
+      "unified.py": "c5d22277c0153f0e83cf73324ac87bc0f89160e7a082fd7e8b9eca7ca2639bf3",
+      "replay.py": "9c5add2d3fb117470241cf63f621e4797a16962cddadbaad6de2cfb481e7fa85",
+      "infer.sh": "60f55b73f5b39a35a61df84026abed9a127b1cc035d650c9e1ca62f54fc2b468"
+    },
+    "parameters": 138135449,
+    "score_kind": "fit_only_development_tune_selection",
+    "decision": "/workspace/research/dual-summary-subcellular1-replay/decision.json"
+  },
+  "new_fit_only_selection_evidence": {
+    "kind": "fit_only_complete_native_tune_replay",
+    "task": "subcellular_localization",
+    "before": 0.7538242618285308,
+    "after": 0.7908217716115261,
+    "delta": 0.03699750978299532,
+    "conditional95": [
+      0.024181785841337605,
+      0.05052472429740305
+    ],
+    "mean_delta": 0.0033634099802724027,
+    "conditional_mean95": [
+      0.0021983441673943276,
+      0.004593156754309368
+    ],
+    "case_gain": 104,
+    "examples": 2811,
+    "matched_controls": {
+      "full_minus_parent": {
+        "delta": 0.036997509782995375,
+        "conditional95": [
+          0.024181785841337605,
+          0.05052472429740305
+        ]
+      },
+      "full_minus_primary": {
+        "delta": 0.03948772678762007,
+        "conditional95": [
+          0.026680896478121666,
+          0.05407328352899324
+        ]
+      },
+      "full_minus_auxiliary": {
+        "delta": 0.013162575595873355,
+        "conditional95": [
+          0.002845962290999644,
+          0.022767698327997153
+        ]
+      }
+    },
+    "native_dependency": {
+      "native_accuracy": 0.7908217716115261,
+      "normal_replay_bit_exact": true,
+      "primary_ablated": {
+        "accuracy": 0.736392742796158,
+        "accuracy_drop": 0.054429028815368194,
+        "conditional95_drop": [
+          0.04054606901458555,
+          0.06794734969761651
+        ],
+        "prediction_changes": 464
+      },
+      "auxiliary_ablated": {
+        "accuracy": 0.5990750622554251,
+        "accuracy_drop": 0.19174670935610102,
+        "conditional95_drop": [
+          0.17467093561010316,
+          0.20988971896122377
+        ],
+        "prediction_changes": 899
+      }
+    },
+    "task_deltas": {
+      "beta_lactamase": 0.0,
+      "binary_localization": 0.0,
+      "fluorescence": 0.0,
+      "fold": 0.0,
+      "human_ppi": 0.0,
+      "ppi_affinity": 0.0,
+      "secondary_structure": 0.0,
+      "solubility": 0.0,
+      "stability": 0.0,
+      "subcellular_localization": 0.03699750978299532,
+      "yeast_ppi": 0.0
+    },
+    "ten_other_prediction_files_byte_exact": true,
+    "limitations": "Conditional paired-example bootstrap after repeated Tune selection; not corrected for protein-family dependence. Feature removal is a dependence diagnostic, not an in-distribution intervention."
+  },
+  "production_replay_pending": false,
+  "all11_native_valid": true,
+  "all11_prediction_references_exact": true
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S055/unified.py

@@ -0,0 +1,695 @@
+"""One jointly learned protein encoder, shared pooling, and eleven small heads."""
+import math
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import esm2
+
+
+class NormalizedLinear(nn.Module):
+    def __init__(self, width, outputs=1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs)
+
+    def forward(self, values):
+        return self.linear((values - self.mean) / self.scale)
+
+
+class LowRankPositionHead(nn.Module):
+    """A shared residue projection followed by an ordered position readout."""
+    def __init__(self, dim, bins, rank, outputs=1):
+        super().__init__()
+        assert 0 < rank <= min(dim, bins)
+        self.dim = dim
+        self.project = nn.Linear(dim, rank, bias=False)
+        self.output = nn.Linear(bins * rank, outputs)
+
+    def forward(self, values):
+        residues = values.reshape(values.shape[0], -1, self.dim)
+        return self.output(self.project(residues).flatten(1))
+
+
+class NormalizedCosine(nn.Module):
+    def __init__(self, width, outputs, temperature=20.):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs, bias=False)
+        self.temperature = temperature
+
+    def forward(self, values):
+        features = F.normalize((values-self.mean)/self.scale, dim=-1)
+        return F.linear(features, F.normalize(self.linear.weight, dim=-1))*self.temperature
+
+
+class NormalizedMLP(nn.Module):
+    def __init__(self, width, outputs, hidden=128, dropout=.1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(), nn.LayerNorm(hidden),
+                                     nn.Dropout(dropout), nn.Linear(hidden, outputs))
+
+    def forward(self, values):
+        return self.network((values-self.mean)/self.scale)
+
+
+class SharedSummaryResidual(nn.Module):
+    """One nonlinear summary map jointly used by several classification heads."""
+    def __init__(self, width, hidden, dropout, classes):
+        super().__init__()
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(),
+                                     nn.LayerNorm(hidden), nn.Dropout(dropout),
+                                     nn.Linear(hidden, hidden), nn.GELU(), nn.Dropout(dropout))
+        self.heads = nn.ModuleDict({task: nn.Linear(hidden, outputs)
+                                   for task, outputs in sorted(classes.items())})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, normalized_summary):
+        return self.heads[task](self.network(normalized_summary))
+
+
+class NormalizedResidueLinear(nn.Module):
+    def __init__(self, dim, kernel=9):
+        super().__init__()
+        assert kernel > 0 and kernel % 2 == 1
+        self.kernel = kernel
+        self.readout = NormalizedLinear(dim * kernel, 3)
+
+    @staticmethod
+    def features(hidden, kernel):
+        padded = F.pad(hidden.float().transpose(1, 2), (kernel // 2, kernel // 2))
+        return padded.unfold(-1, kernel, 1).transpose(1, 2).flatten(2)
+
+    def forward(self, hidden):
+        return self.readout(self.features(hidden, self.kernel))
+
+
+class LocalResidueHead(nn.Sequential):
+    """Preserve the original four head parameter names; add a local residual."""
+    def __init__(self, dim):
+        super().__init__(nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+        self.context = nn.Sequential(nn.Conv1d(dim, dim, 9, padding=4, groups=dim),
+                                     nn.GELU(), nn.Conv1d(dim, dim, 1))
+        nn.init.zeros_(self.context[-1].weight)
+        nn.init.zeros_(self.context[-1].bias)
+
+    def forward(self, x):
+        x = x + self.context(x.transpose(1, 2)).transpose(1, 2)
+        for i in range(4):
+            x = self[i](x)
+        return x
+
+
+class CalibratedLocalResidueHead(LocalResidueHead):
+    def __init__(self, dim):
+        super().__init__(dim)
+        self[3] = NormalizedLinear(dim, 3)
+
+
+class ResidualSequenceConvHead(nn.Module):
+    """Learn local sequence motifs alongside the retained summary classifier."""
+    def __init__(self, dim, outputs, channels=128, dropout=.2, retain_summary=True):
+        super().__init__()
+        self.base = NormalizedLinear(7 * dim, outputs) if retain_summary else None
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, channels)
+        self.convs = nn.ModuleList([nn.Conv1d(channels, channels, k, padding=k//2) for k in (3,9)])
+        self.norms = nn.ModuleList([nn.LayerNorm(channels) for _ in self.convs])
+        self.output = nn.Linear(4 * channels, outputs)
+        nn.init.zeros_(self.output.weight);nn.init.zeros_(self.output.bias)
+        self.dropout = dropout
+
+    def forward(self, features):
+        valid = features['valid'].bool().unsqueeze(-1)
+        x = F.gelu(self.project((features['hidden']-self.mean)/self.scale)) * valid
+        summaries = []
+        for conv,norm in zip(self.convs,self.norms):
+            y = norm(F.gelu(conv(x.transpose(1,2)).transpose(1,2)))
+            center = (y*valid).sum(1)/valid.sum(1).clamp_min(1)
+            maximum = y.masked_fill(~valid,-1e4).amax(1)
+            maximum = torch.where(valid.any(1),maximum,torch.zeros_like(maximum))
+            summaries.extend([center,maximum])
+        pooled = F.dropout(torch.cat(summaries,dim=-1),self.dropout,self.training)
+        logits=self.output(pooled)
+        return self.base(features['summary']) + logits if self.base is not None else logits
+
+
+class TokenLogMeanExpHead(nn.Module):
+    """Class-specific local evidence, pooled without sequence-length bias."""
+    def __init__(self, dim, outputs):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.linear = nn.Linear(dim, outputs)
+
+    def forward(self, representation):
+        values, valid = representation['hidden'].float(), representation['valid']
+        logits = self.linear((values-self.mean)/self.scale)
+        logits = logits.masked_fill(~valid.unsqueeze(-1), -torch.inf)
+        return torch.logsumexp(logits, 1)-valid.sum(1).clamp_min(1).float().log()[:, None]
+
+    def packed(self, values, lengths):
+        """Equivalent unpadded computation for frozen-feature readout fitting."""
+        logits = self.linear((values.float()-self.mean)/self.scale)
+        # The stabilizing maximum cancels in the derivative; detach avoids
+        # retaining another large token-by-class gradient path.
+        maximum = torch.segment_reduce(logits.detach(), 'max', lengths=lengths)
+        index = torch.repeat_interleave(torch.arange(len(lengths), device=lengths.device), lengths,
+                                        output_size=len(values))
+        exponent = (logits-maximum[index]).exp()
+        total = torch.segment_reduce(exponent, 'sum', lengths=lengths)
+        return maximum+total.log()-lengths.float().log()[:, None]
+
+
+class SharedPairResidueInteraction(nn.Module):
+    """A shared nonlinear comparison of local states from both protein chains."""
+    def __init__(self, dim, settings, classes):
+        super().__init__()
+        width, hidden, channels = (settings[k] for k in ['projection_dim', 'pair_hidden', 'pair_channels'])
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, width)
+        self.compare = nn.Sequential(nn.Linear(2*width, hidden), nn.GELU(),
+                                     nn.Linear(hidden, channels), nn.GELU())
+        self.dropout = settings['dropout']
+        self.heads = nn.ModuleDict({task: nn.Linear(2*channels, classes.get(task, 1))
+                                   for task in sorted(esm2.Model.PAIR)})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, first, second):
+        first = F.gelu(self.project((first-self.mean)/self.scale))
+        second = F.gelu(self.project((second-self.mean)/self.scale))
+        first = F.dropout(first, self.dropout, self.training)
+        second = F.dropout(second, self.dropout, self.training)
+        pair = torch.cat([(first[:, :, None]-second[:, None, :]).abs(),
+                          first[:, :, None]*second[:, None, :]], dim=-1)
+        local = self.compare(pair)
+        summary = torch.cat([local.mean((1, 2)), local.amax((1, 2))], dim=-1)
+        return self.heads[task](summary)
+
+
+class SSChainDecoder(nn.Module):
+    """Small learned label-compatibility model, applied to frozen residue unaries."""
+    def __init__(self):
+        super().__init__()
+        self.transition = nn.Parameter(torch.empty(3, 3))
+        self.start = nn.Parameter(torch.empty(3))
+        self.end = nn.Parameter(torch.empty(3))
+        for parameter in self.parameters():
+            nn.init.normal_(parameter, std=.01)
+
+    def decode(self, probabilities):
+        from ss_chain import decode_probabilities
+        values = [parameter.detach().double().cpu().numpy()
+                  for parameter in (self.transition, self.start, self.end)]
+        return decode_probabilities(probabilities, *values)
+
+
+class UnifiedModel(esm2.Model):
+    TASK_ORDER = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+                  'subcellular_localization', 'binary_localization', 'fold',
+                  'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+    def __init__(self, config):
+        super().__init__(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+        self.config = config
+        self.task_index = {t: i for i, t in enumerate(self.TASK_ORDER)}
+        dim = config['dim']
+        if config.get('extension_layers', 0):
+            self.encoder.add_extension(config['extension_layers'], config['heads'],
+                                       before_norm=config.get('extension_before_norm', False))
+        if config.get('task_conditioning', False):
+            self.task_condition = nn.Parameter(torch.zeros(11, config['layers'], 4, dim))
+        if config.get('pooling', 'mean') == 'rich':
+            self.pool_query = nn.Parameter(torch.randn(len(self.TASK_ORDER), 2, dim) * 0.02)
+            self.pool_position = nn.Parameter(torch.zeros(len(self.TASK_ORDER), 2, 4))
+            # Shared across tasks, with a zero initial residual for safe lineage transfer.
+            self.pool_fuse = nn.Linear(6 * dim, dim)
+            nn.init.zeros_(self.pool_fuse.weight)
+            nn.init.zeros_(self.pool_fuse.bias)
+        if config.get('pair_interaction', False):
+            self.pair_fuse = nn.Linear(2 * dim, 2 * dim)
+            nn.init.zeros_(self.pair_fuse.weight)
+            nn.init.zeros_(self.pair_fuse.bias)
+        if config.get('ss_context', False):
+            self.heads['secondary_structure'] = LocalResidueHead(dim)
+        for task in config.get('linear_heads', []):
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(nn.Linear(width, self.CLASSES.get(task, 1)))
+        for task, settings in config.get('residue_readouts', {}).items():
+            self.heads[task] = NormalizedLinear(settings['bins'] * dim, self.CLASSES.get(task, 1))
+        for task, rank in config.get('residue_lowrank_heads', {}).items():
+            bins = config['residue_readouts'][task]['bins']
+            self.heads[task] = LowRankPositionHead(dim, bins, rank, self.CLASSES.get(task, 1))
+        for task in config.get('summary_readouts', []):
+            assert task not in self.PAIR and config.get('pooling') == 'rich'
+            self.heads[task] = NormalizedLinear(7 * dim, self.CLASSES.get(task, 1))
+        for task in config.get('sequence_composition_readouts', []):
+            from sequence_composition import WIDTH
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES
+            assert all(task not in config.get(key,[]) for key in
+                       ['cosine_heads','nonlinear_summary_heads','ss_summary_readouts',
+                        'sequence_conv_readouts','terminal_summary_readouts','token_logmeanexp_heads'])
+            self.heads[task] = NormalizedLinear(7 * dim + WIDTH, self.CLASSES[task])
+        for task, temperature in config.get('cosine_heads', {}).items():
+            assert task in config.get('summary_readouts', [])
+            self.heads[task] = NormalizedCosine(7*dim, self.CLASSES[task], temperature)
+        for task, settings in config.get('nonlinear_summary_heads', {}).items():
+            assert task in config.get('summary_readouts', []) and task not in config.get('cosine_heads', {})
+            self.heads[task] = NormalizedMLP(7*dim, self.CLASSES.get(task,1), settings['hidden'], settings['dropout'])
+        for task in config.get('calibrated_heads', []):
+            assert task not in config.get('summary_readouts', []) and task not in config.get('residue_readouts', {})
+            assert task not in config.get('linear_heads', [])
+            self.heads[task][3] = NormalizedLinear(dim, self.CLASSES.get(task,1))
+        for task in config.get('expanded_pair_readouts', []):
+            assert task in self.PAIR
+            width=3 if task in config.get('symmetric_pair_readouts',[]) else 4
+            if task in config.get('pair_summary_readouts', []):
+                assert config.get('pooling') == 'rich'
+                width *= 8
+            self.heads[task] = NormalizedLinear(width*dim, self.CLASSES.get(task,1))
+        if config.get('ss_linear_context'):
+            self.heads['secondary_structure'] = NormalizedResidueLinear(dim, config['ss_linear_context'])
+        if config.get('ss_calibrated'):
+            assert not config.get('ss_linear_context')
+            self.heads['secondary_structure'] = CalibratedLocalResidueHead(dim)
+        for task in config.get('ss_summary_readouts', []):
+            assert task in config.get('summary_readouts', []) and task not in self.PAIR
+            self.heads[task] = NormalizedLinear(7*dim+40, self.CLASSES[task])
+        for task,settings in config.get('sequence_conv_readouts',{}).items():
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES and task not in self.PAIR
+            self.heads[task] = ResidualSequenceConvHead(dim,self.CLASSES[task],settings['channels'],settings['dropout'],settings.get('retain_summary',True))
+        for task, settings in config.get('terminal_summary_readouts', {}).items():
+            assert task in config.get('summary_readouts', []) and task in self.CLASSES and task not in self.PAIR
+            assert all(task not in config.get(key, {}) for key in
+                       ['cosine_heads', 'nonlinear_summary_heads', 'ss_summary_readouts', 'sequence_conv_readouts'])
+            bins = settings['bins']
+            assert bins > 0 and all(settings[key] > 0 and settings[key] % bins == 0
+                                    for key in ['prefix_residues', 'suffix_residues'])
+            self.heads[task] = NormalizedLinear((7+2*bins)*dim, self.CLASSES[task])
+        if config.get('pair_bilinear_rank', 0):
+            rank = config['pair_bilinear_rank']
+            assert not config.get('pair_summary_readouts')
+            self.pair_bilinear_projection = nn.Linear(dim, rank, bias=False)
+            nn.init.normal_(self.pair_bilinear_projection.weight, std=dim ** -.5)
+            with torch.no_grad():
+                self.pair_bilinear_projection.weight.copy_(F.normalize(self.pair_bilinear_projection.weight, dim=1))
+            self.pair_bilinear_heads = nn.ModuleDict({
+                task: nn.Linear(rank, self.CLASSES.get(task, 1), bias=False)
+                for task in sorted(self.PAIR)})
+            for head in self.pair_bilinear_heads.values():
+                nn.init.zeros_(head.weight)
+            self.register_buffer('pair_bilinear_mean', torch.zeros(dim))
+            self.register_buffer('pair_bilinear_scale', torch.ones(dim))
+        if config.get('pair_residue_interaction'):
+            self.pair_residue_interaction = SharedPairResidueInteraction(
+                dim, config['pair_residue_interaction'], self.CLASSES)
+        for task in config.get('token_logmeanexp_heads', []):
+            assert task in self.CLASSES and task not in self.PAIR
+            assert task not in config.get('sequence_windows', [])
+            self.heads[task] = TokenLogMeanExpHead(dim, self.CLASSES[task])
+        if config.get('ss_chain_decoder', False):
+            self.ss_chain_decoder = SSChainDecoder()
+        if config.get('shared_summary_residual'):
+            settings = config['shared_summary_residual']
+            tasks = settings['tasks']
+            assert all(task in config.get('summary_readouts', []) and
+                       isinstance(self.heads[task], NormalizedLinear) for task in tasks)
+            self.summary_residual = SharedSummaryResidual(7*dim, settings['hidden'], settings['dropout'],
+                                                          {task: self.CLASSES[task] for task in tasks})
+
+        if config.get('dual_summary'):
+            settings = config['dual_summary']
+            tasks = settings['tasks']
+            assert tasks and len(tasks) == len(set(tasks))
+            assert config.get('pooling') == 'rich'
+            assert all(task in config.get('summary_readouts', []) and task not in self.PAIR for task in tasks)
+            assert all(task not in config.get(key, {}) for task in tasks for key in
+                       ['cosine_heads', 'nonlinear_summary_heads', 'ss_summary_readouts',
+                        'sequence_conv_readouts', 'terminal_summary_readouts', 'token_logmeanexp_heads',
+                        'summary_residual_tasks', 'sequence_composition_readouts'])
+            self.auxiliary_summary_encoder = esm2.Encoder(settings['layers'], settings['dim'], settings['heads'])
+            self.auxiliary_summary_index = {task: i for i, task in enumerate(tasks)}
+            self.auxiliary_pool_query = nn.Parameter(torch.randn(len(tasks), 2, settings['dim']) * .02)
+            self.auxiliary_pool_position = nn.Parameter(torch.zeros(len(tasks), 2, 4))
+            for task in tasks:
+                self.heads[task] = NormalizedLinear(7*(dim+settings['dim']), self.CLASSES[task])
+
+    def pair_representation(self, task, first, second, base):
+        if task in self.config.get('pair_bilinear_tasks', []):
+            return {'base': base, 'chain_a': first, 'chain_b': second}
+        return base
+
+    def apply_head(self, task, representation):
+        if task in self.config.get('summary_residual_tasks', []):
+            head = self.heads[task]
+            normalized = (representation-head.mean)/head.scale
+            return head(representation) + self.summary_residual(task, normalized)
+        if isinstance(representation, dict) and 'residue_a' in representation:
+            base = {k:v for k,v in representation.items() if k not in ['residue_a', 'residue_b']}
+            original = self.apply_head(task, base if 'chain_a' in base else base['base'])
+            return original + self.pair_residue_interaction(task, representation['residue_a'], representation['residue_b'])
+        if isinstance(representation, dict) and 'chain_a' in representation:
+            first = (representation['chain_a'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            second = (representation['chain_b'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            interaction = self.pair_bilinear_projection(first) * self.pair_bilinear_projection(second)
+            interaction = interaction / math.sqrt(self.config['pair_bilinear_rank'])
+            return self.heads[task](representation['base']) + self.pair_bilinear_heads[task](interaction)
+        return self.heads[task](representation)
+
+    def encode_residues(self, tokens, task):
+        condition = None
+        if self.config.get('task_conditioning', False):
+            ti = 10 if task == 'secondary_structure' else self.task_index[task]
+            condition = self.task_condition[ti]
+        return self.encoder(tokens, condition=condition, depth=self.config.get('task_encoder_layers',{}).get(task),
+                            extension_depth=self.config.get('task_extension_depths',{}).get(task))
+
+    def pool(self, tokens, task):
+        hidden, pad_mask = self.encode_residues(tokens, task)
+        primary = self.summarize(hidden, tokens, pad_mask, task)
+        if task in self.config.get('dual_summary', {}).get('tasks', []):
+            auxiliary, auxiliary_mask = self.auxiliary_summary_encoder(tokens)
+            secondary = self.auxiliary_summarize(auxiliary, tokens, auxiliary_mask, task)
+            return torch.cat([primary, secondary], dim=-1)
+        return primary
+
+    def summarize(self, hidden, tokens, pad_mask, task):
+        valid = (~pad_mask).unsqueeze(-1)
+        mean = (hidden * valid).sum(1) / valid.sum(1).clamp_min(1)
+        if self.config.get('pooling', 'mean') == 'mean':
+            return mean
+        residues = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+        # Empty/nonstandard-only inputs still produce a finite representation.
+        residues[:, 0] |= ~residues.any(1)
+        keep = residues.unsqueeze(-1)
+        count = keep.sum(1).clamp_min(1)
+        center = (hidden * keep).sum(1) / count
+        position = residues.cumsum(1).to(hidden.dtype) / count.to(hidden.dtype)
+        basis = torch.stack([position, position.square(), torch.sin(position * math.pi),
+                             torch.cos(position * math.pi)], dim=-1)
+        ti = self.task_index[task]
+        scores = torch.einsum('bld,qd->blq', hidden, self.pool_query[ti]) / math.sqrt(hidden.shape[-1])
+        scores = scores + torch.einsum('blp,qp->blq', basis, self.pool_position[ti])
+        scores = scores.masked_fill(~residues.unsqueeze(-1), -1e4)
+        attention = torch.einsum('blq,bld->bqd', scores.softmax(1), hidden)
+        variance = ((hidden - center[:, None]).float().square() * keep).sum(1) / count
+        deviation = (variance + 1e-5).sqrt().to(hidden.dtype)
+        maximum = hidden.masked_fill(~keep, -1e4).amax(1) - center
+        first = residues & (residues.cumsum(1) <= 32)
+        last = residues & ((residues.sum(1, keepdim=True) - residues.cumsum(1)) < 32)
+        prefix = (hidden * first.unsqueeze(-1)).sum(1) / first.sum(1, keepdim=True).clamp_min(1) - center
+        suffix = (hidden * last.unsqueeze(-1)).sum(1) / last.sum(1, keepdim=True).clamp_min(1) - center
+        summary = torch.cat([attention[:, 0] - center, attention[:, 1] - center,
+                             deviation, maximum, prefix, suffix], dim=-1)
+        if task in self.config.get('summary_readouts', []):
+            return torch.cat([mean, summary], dim=-1)
+        if task in self.config.get('pair_summary_readouts', []):
+            return torch.cat([mean + self.pool_fuse(summary), mean, summary], dim=-1)
+        return mean + self.pool_fuse(summary)
+
+    def auxiliary_summarize(self, hidden, tokens, pad_mask, task):
+        valid = (~pad_mask).unsqueeze(-1)
+        mean = (hidden * valid).sum(1) / valid.sum(1).clamp_min(1)
+        if self.config.get('pooling', 'mean') == 'mean':
+            return mean
+        residues = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+        # Empty/nonstandard-only inputs still produce a finite representation.
+        residues[:, 0] |= ~residues.any(1)
+        keep = residues.unsqueeze(-1)
+        count = keep.sum(1).clamp_min(1)
+        center = (hidden * keep).sum(1) / count
+        position = residues.cumsum(1).to(hidden.dtype) / count.to(hidden.dtype)
+        basis = torch.stack([position, position.square(), torch.sin(position * math.pi),
+                             torch.cos(position * math.pi)], dim=-1)
+        ti = self.auxiliary_summary_index[task]
+        scores = torch.einsum('bld,qd->blq', hidden, self.auxiliary_pool_query[ti]) / math.sqrt(hidden.shape[-1])
+        scores = scores + torch.einsum('blp,qp->blq', basis, self.auxiliary_pool_position[ti])
+        scores = scores.masked_fill(~residues.unsqueeze(-1), -1e4)
+        attention = torch.einsum('blq,bld->bqd', scores.softmax(1), hidden)
+        variance = ((hidden - center[:, None]).float().square() * keep).sum(1) / count
+        deviation = (variance + 1e-5).sqrt().to(hidden.dtype)
+        maximum = hidden.masked_fill(~keep, -1e4).amax(1) - center
+        first = residues & (residues.cumsum(1) <= 32)
+        last = residues & ((residues.sum(1, keepdim=True) - residues.cumsum(1)) < 32)
+        prefix = (hidden * first.unsqueeze(-1)).sum(1) / first.sum(1, keepdim=True).clamp_min(1) - center
+        suffix = (hidden * last.unsqueeze(-1)).sum(1) / last.sum(1, keepdim=True).clamp_min(1) - center
+        summary = torch.cat([attention[:, 0] - center, attention[:, 1] - center,
+                             deviation, maximum, prefix, suffix], dim=-1)
+        return torch.cat([mean, summary], dim=-1)
+
+    def pool_sequences(self, sequences, task, device, max_len):
+        if self.training and not self.config.get('window_pooling_training', True):
+            tokens=esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device)
+            return self.pool(tokens,task)
+        if task not in self.config.get('sequence_windows', []) or not any(len(s)>max_len-2 for s in sequences):
+            return self.pool(esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device),task)
+        results=[None]*len(sequences)
+        short=[i for i,s in enumerate(sequences) if len(s)<=max_len-2]
+        if short:
+            pooled=self.pool(esm2.pad_batch([esm2.encode(sequences[i],max_len) for i in short],device),task)
+            for j,index in enumerate(short):results[index]=pooled[j]
+        width=max_len-2;stride=min(768,width)
+        if self.training and self.config.get('batch_window_training',False):
+            pieces=[];starts_by_index={};encoded={}
+            for index,sequence in enumerate(sequences):
+                if len(sequence)<=width:continue
+                starts=list(range(0,len(sequence)-width+1,stride))
+                if starts[-1]!=len(sequence)-width:starts.append(len(sequence)-width)
+                starts_by_index[index]=starts
+                pieces.extend((index,start) for start in starts)
+            count=max(1,16384//max_len)
+            for begin in range(0,len(pieces),count):
+                part=pieces[begin:begin+count]
+                tokens=esm2.pad_batch([esm2.encode(sequences[i][s:s+width],max_len) for i,s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,key in enumerate(part):encoded[key]=hidden[j]
+            positions=torch.arange(width,device=device)
+            weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+            for index,starts in starts_by_index.items():
+                sequence=sequences[index];length=len(sequence)
+                total=torch.zeros(length,self.config['dim'],device=device);counts=torch.zeros(length,1,device=device)
+                for start in starts:
+                    total.index_add_(0,positions+start,encoded[index,start][1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+                assembled=torch.cat([encoded[index,starts[0]][0:1],total/counts.clamp_min(1),encoded[index,starts[-1]][width+1:width+2]],dim=0)[None]
+                tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+                results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+            return torch.stack(results)
+        for index,sequence in enumerate(sequences):
+            length=len(sequence)
+            if length<=width:continue
+            starts=list(range(0,length-width+1,stride))
+            if starts[-1]!=length-width:starts.append(length-width)
+            total=torch.zeros(length,self.config['dim'],device=device)
+            counts=torch.zeros(length,1,device=device)
+            first=last=None
+            for begin in range(0,len(starts),max(1,16384//max_len)):
+                part=starts[begin:begin+max(1,16384//max_len)]
+                tokens=esm2.pad_batch([esm2.encode(sequence[s:s+width],max_len) for s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,start in enumerate(part):
+                    if start==0:first=hidden[j,0:1]
+                    if start==starts[-1]:last=hidden[j,width+1:width+2]
+                    positions=torch.arange(width,device=device)
+                    weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+                    total.index_add_(0,positions+start,hidden[j,1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+            assembled=torch.cat([first,total/counts.clamp_min(1),last],dim=0)[None]
+            tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+            results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+        return torch.stack(results)
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.config.get('sequence_composition_readouts', []):
+            from sequence_composition import composition_features
+            sequences=[item['sequence'] for item in batch]
+            pooled=self.pool_sequences(sequences,task,device,max_len)
+            return torch.cat([pooled.float(),composition_features(sequences,device)],-1)
+        if task in self.config.get('token_logmeanexp_heads', []):
+            tokens = esm2.pad_batch([esm2.encode(row['sequence'], max_len) for row in batch], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            valid = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+            valid[:, 0] |= ~valid.any(1)
+            return {'hidden':hidden, 'valid':valid}
+        if task in self.config.get('terminal_summary_readouts', {}):
+            return self.terminal_summary_features(task, [item['sequence'] for item in batch], device, max_len)
+        if task in self.config.get('ss_summary_readouts', []):
+            sequences=[x['sequence'] for x in batch]
+            summary=self.pool_sequences(sequences,task,device,max_len)
+            structure=self.secondary_structure_summary(sequences,device,max_len)
+            return torch.cat([summary.float(),structure],-1)
+        if task in self.config.get('sequence_conv_readouts',{}):
+            tokens=esm2.pad_batch([esm2.encode(x['sequence'],max_len) for x in batch],device)
+            hidden,pad_mask=self.encode_residues(tokens,task)
+            lengths=torch.tensor([min(len(x['sequence']),max_len-2) for x in batch],device=device)
+            width=max(1,int(lengths.max()))
+            valid=torch.arange(width,device=device)[None,:]<lengths[:,None]
+            return {'hidden':hidden[:,1:1+width], 'valid':valid,
+                    'summary':self.summarize(hidden,tokens,pad_mask,task)}
+        if task in self.config.get('residue_readouts', {}):
+            bins = self.config['residue_readouts'][task]['bins']
+            sequences = [x['sequence'] for x in batch]
+            tokens = esm2.pad_batch([esm2.encode(s, max_len) for s in sequences], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            return self.position_features(hidden, [min(len(s), max_len-2) for s in sequences], bins)
+        if task in self.PAIR:
+            a = self.pool_sequences([x['sequence_a'] for x in batch],task,device,max_len)
+            b = self.pool_sequences([x['sequence_b'] for x in batch],task,device,max_len)
+            if task in self.config.get('expanded_pair_readouts', []):
+                if task in self.config.get('symmetric_pair_readouts',[]):
+                    features=torch.cat([(a.float()+b.float())*.5,a*b,(a-b).abs()],dim=-1)
+                else:
+                    features=torch.cat([a,b,a*b,(a-b).abs()],dim=-1)
+                base = F.dropout(features,p=self.config.get('pair_dropout',0.),training=self.training)
+                return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+            output = torch.cat([a, b], dim=-1)
+            if self.config.get('pair_interaction', False):
+                output = output + self.pair_fuse(torch.cat([a * b, (a - b).abs()], dim=-1))
+            base = F.dropout(output, p=self.config.get('pair_dropout', 0.0), training=self.training)
+            return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+        return self.pool_sequences([x['sequence'] for x in batch],task,device,max_len)
+
+    def add_pair_residues(self, task, batch, device, max_len, base):
+        if task not in self.config.get('pair_residue_tasks', []):
+            return base
+        result = dict(base) if isinstance(base, dict) else {'base': base}
+        bins = self.config['pair_residue_interaction']['bins']
+        for role, name in [('a', 'sequence_a'), ('b', 'sequence_b')]:
+            result['residue_'+role] = self.pool_residue_bins(
+                [row[name] for row in batch], task, device, max_len, bins)
+        return result
+
+    def pool_residue_bins(self, sequences, task, device, max_len, bins):
+        """Average every residue into fixed relative bins, with full-chain context."""
+        width = max_len-2
+        assert width > 0 and bins > 0
+        output = [None]*len(sequences)
+        short = [i for i, sequence in enumerate(sequences) if len(sequence) <= width]
+        if short:
+            tokens = esm2.pad_batch([esm2.encode(sequences[i], max_len) for i in short], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            for j, index in enumerate(short):
+                length = len(sequences[index])
+                values = hidden[j, 1:1+length].float()
+                output[index] = (F.adaptive_avg_pool1d(values.T[None], bins)[0].T if length
+                                 else torch.zeros(bins, self.config['dim'], device=device))
+        for index, sequence in enumerate(sequences):
+            if len(sequence) <= width:
+                continue
+            starts = list(range(0, len(sequence)-width+1, min(768, width)))
+            if starts[-1] != len(sequence)-width:
+                starts.append(len(sequence)-width)
+            total = torch.zeros(len(sequence), self.config['dim'], device=device)
+            count = torch.zeros(len(sequence), 1, device=device)
+            position = torch.arange(width, device=device)
+            weight = torch.minimum(torch.minimum(position+1, width-position),
+                                   torch.full_like(position, 128)).float()[:, None]
+            for begin in range(0, len(starts), max(1, 16384//max_len)):
+                part = starts[begin:begin+max(1, 16384//max_len)]
+                tokens = esm2.pad_batch([esm2.encode(sequence[s:s+width], max_len) for s in part], device)
+                hidden, _ = self.encode_residues(tokens, task)
+                for j, start in enumerate(part):
+                    total.index_add_(0, position+start, hidden[j, 1:1+width].float()*weight)
+                    count.index_add_(0, position+start, weight)
+            values = total/count.clamp_min(1)
+            output[index] = F.adaptive_avg_pool1d(values.T[None], bins)[0].T
+        return torch.stack(output)
+
+    @staticmethod
+    def terminal_bins(states, width, bins, align_end=False):
+        """Fixed absolute residue bins; exclude padding from partial-bin means."""
+        assert width > 0 and bins > 0 and width % bins == 0
+        states = (states[-width:] if align_end else states[:width]).float()
+        count = states.shape[0]
+        padded = states.new_zeros(width, states.shape[-1])
+        valid = states.new_zeros(width)
+        offset = width-count if align_end else 0
+        padded[offset:offset+count] = states
+        valid[offset:offset+count] = 1
+        total = padded.reshape(bins, width//bins, -1).sum(1)
+        denominator = valid.reshape(bins, width//bins).sum(1).clamp_min(1)[:, None]
+        return (total/denominator).flatten()
+
+    def terminal_summary_features(self, task, sequences, device, max_len):
+        settings = self.config['terminal_summary_readouts'][task]
+        width = max_len-2
+        assert width >= max(settings['prefix_residues'], settings['suffix_residues'])
+        tokens = esm2.pad_batch([esm2.encode(sequence, max_len) for sequence in sequences], device)
+        hidden, padding = self.encode_residues(tokens, task)
+        summary = self.summarize(hidden, tokens, padding, task)
+        long_ids = [index for index, sequence in enumerate(sequences) if len(sequence) > width]
+        tails = {}
+        if long_ids:
+            tail_tokens = esm2.pad_batch([esm2.encode(sequences[index][-width:], max_len)
+                                         for index in long_ids], device)
+            tail_hidden, _ = self.encode_residues(tail_tokens, task)
+            tails = {index: tail_hidden[local, 1:width+1] for local, index in enumerate(long_ids)}
+        terminals = []
+        for index, sequence in enumerate(sequences):
+            prefix = hidden[index, 1:1+min(len(sequence), width)]
+            suffix = tails.get(index, prefix)
+            terminals.append(torch.cat([
+                self.terminal_bins(prefix, settings['prefix_residues'], settings['bins']),
+                self.terminal_bins(suffix, settings['suffix_residues'], settings['bins'], align_end=True)]))
+        return torch.cat([summary.float(), torch.stack(terminals)], dim=-1)
+
+    @staticmethod
+    def position_features(hidden, lengths, bins):
+        features = []
+        for index, length in enumerate(lengths):
+            if length:
+                states = hidden[index:index+1, 1:1+length].float().transpose(1, 2)
+                features.append(F.interpolate(states, size=bins, mode='linear', align_corners=True).flatten())
+            else:
+                features.append(hidden.new_zeros(hidden.shape[-1] * bins).float())
+        return torch.stack(features)
+
+    def secondary_structure_summary(self, sequences, device, max_len):
+        tokens=esm2.pad_batch([esm2.encode(sequence,max_len) for sequence in sequences],device)
+        hidden,_=self.encode_residues(tokens,'secondary_structure')
+        with torch.autocast(device_type=device.type,enabled=False):
+            probabilities=self.heads['secondary_structure'](hidden.float()).softmax(-1)
+        summaries=[]
+        for index,sequence in enumerate(sequences):
+            length=min(len(sequence),max_len-2)
+            if not length:
+                summaries.append(probabilities.new_zeros(40));continue
+            value=probabilities[index,1:1+length]
+            mean=value.mean(0);std=value.std(0,unbiased=False)
+            transition=(value[:-1,:,None]*value[1:,None,:]).mean(0).flatten() if length>1 else value.new_zeros(9)
+            positions=F.adaptive_avg_pool1d(value.T[None],8).flatten()
+            summaries.append(torch.cat([mean,std,transition,positions,value.new_tensor([math.log1p(length)])]))
+        return torch.stack(summaries)
+
+    def normalize(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return (values - stats['mean']) / stats['std'] if stats else values
+
+    def unscale(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return values * stats['std'] + stats['mean'] if stats else values
+
+    def transfer(self, state, normalized_source=False):
+        """Transfer our own lineage only; retain random init for new parameters."""
+        current = self.state_dict()
+        fitting = {k: v for k, v in state.items() if k in current and v.shape == current[k].shape}
+        missing, unexpected = self.load_state_dict(fitting, strict=False)
+        if not normalized_source:
+            with torch.no_grad():
+                for task, stats in self.config.get('regression_stats', {}).items():
+                    # Preserve predictions when moving a trained head to standardized units.
+                    if f'heads.{task}.3.weight' in fitting:
+                        self.heads[task][3].weight.div_(stats['std'])
+                        self.heads[task][3].bias.sub_(stats['mean']).div_(stats['std'])
+        return {'transferred': len(fitting), 'new_tensors': missing, 'unexpected': unexpected}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S056/PUBLISHED.json

@@ -0,0 +1,5 @@
+{
+  "source": "/run-state/workspace/research/production-shared-fusion8h-ss1/candidate/package",
+  "files": 9,
+  "bytes": 558590100
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S056/README.md

@@ -0,0 +1,68 @@
+# Unified PEER protein model
+
+Exact total: **138,597,529 parameters**, in one inference state dictionary.
+A jointly learned 12-layer, width-512, 8-head transformer supplies all eleven
+tasks. Its original **37,845,535 parameters** remain common to every task;
+two shared extension blocks serve beta-lactamase and stability.
+
+One 12-layer, width-768, 12-head auxiliary encoder (85,079,839 parameters)
+supplies subcellular summaries and secondary-structure fusion. It was also
+jointly trained on all eleven tasks here and is stored once. Subcellular uses
+one normalized linear head over both encoders' seven summaries. SS adds a
+shared 462,080-parameter residue map: LayerNorm(1280), Linear(1280,256), GELU,
+Linear(256,512), with a residual connection to the primary representation.
+This map received 4,000 joint all-task fit updates with frozen encoders and
+heads. Only SS enables it in this package; one final EMA state is used.
+
+All weights originated from random initialization and training in this session.
+The primary received one hour of MLM on mounted decontaminated UniRef50
+(1,713,641,682 token presentations), followed by joint fit supervision,
+task conditioning and shared-extension training. The auxiliary received eight
+hours of MLM (10,254,509,402 token presentations) and 8,486 joint supervised
+updates. Only mounted UniRef50, fit and permitted Tune data were used.
+
+Heads:
+
+- Fluorescence/beta-lactamase: normalized linear heads over interpolated residue
+  positions, trained on rank targets.
+- Fold/solubility: normalized linear heads over seven sequence summaries.
+- Subcellular: one fit-normalized combined-summary linear head, ridge 0.01.
+- Binary localization: summary head plus a nonlinear residual jointly trained
+  across solubility and both localization tasks.
+- Stability: MLP and normalized final linear head, balanced length-group loss,
+  and a fixed 50:50 continuation midpoint.
+- Human PPI: ordered summaries, product and absolute difference. Yeast/affinity
+  use symmetric summaries; yeast also uses shared bilinear and residue modules
+  jointly trained across all three PPI tasks.
+- Secondary structure: the shared residue fusion followed by a local convolution
+  and residue MLP. Its earlier head distillation used an own-session teacher;
+  teacher parameters and feature caches are absent.
+
+The fit-only development reference scores **0.7214368926** across all eleven
+Tune tasks. Subcellular accuracy is 0.7908217716, versus its previous 0.7538242618.
+The new SS accuracy is 0.7596380880, versus 0.7441316788 (+8,636 valid residues);
+its conditional paired-protein 95% difference interval is [0.01431, 0.01673].
+A matched zero-auxiliary fusion control scored 0.7439539189. Same data, CPU/CUDA
+RNG and optimizer clocks were verified; only final 4,000-update EMA weights
+were eligible. Ten other production prediction files are byte-identical to the
+previous package. Complete offline replay is valid for all eleven tasks.
+
+SS substantially uses the common primary backbone: zeroing primary residues
+reduces accuracy to 0.6834275700; zeroing auxiliary residues gives 0.7315897301.
+Subcellular primary-feature removal gives 0.7363927428, and auxiliary-feature
+removal gives 0.5990750623. These are frozen-feature diagnostics, not fitting.
+
+Production retains five previously accepted fit+Tune heads: fold, fluorescence,
+beta-lactamase, affinity and stability. Each recipe used positive fixed two-half
+cross-fit evidence before fitting the full permitted pool. Their feature paths
+and parameters are unchanged here. Their production Tune scores and aggregate
+are IN-SAMPLE and excluded from development selection. All other heads and
+shared encoders use fit-only supervised gradients.
+
+Repeated Tune selection and protein-family dependence limit the intervals.
+Fold generalization remains weak, and PPI validation sets are small. SS/PPI use
+full-chain windows; other tasks retain a 1,022-residue prefix. Rank outputs are
+not calibrated for absolute error. No held-out test result is available.
+
+Run `bash infer.sh INPUT_ROOT OUTPUT_ROOT` offline. No live trainer, research
+files, external weights, lookup table or test-time fitting is required.

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S056/config.json

@@ -0,0 +1,153 @@
+{
+  "layers": 12,
+  "dim": 512,
+  "heads": 8,
+  "pooling": "rich",
+  "pair_interaction": true,
+  "ss_context": true,
+  "max_len": 1024,
+  "pair_dropout": 0.0,
+  "architecture": "unified",
+  "full_ss": true,
+  "regression_stats": {
+    "fluorescence": {
+      "mean": 3.180586883940159,
+      "std": 0.8339910288860748
+    },
+    "stability": {
+      "mean": 0.1790524860555312,
+      "std": 0.5662245232305059
+    },
+    "beta_lactamase": {
+      "mean": 0.7383112351980983,
+      "std": 0.31642946622284734
+    },
+    "ppi_affinity": {
+      "mean": -11.654589870742203,
+      "std": 3.0832061340498944
+    }
+  },
+  "residue_readouts": {
+    "fluorescence": {
+      "bins": 256
+    },
+    "beta_lactamase": {
+      "bins": 320
+    }
+  },
+  "fp32_heads": [
+    "beta_lactamase",
+    "binary_localization",
+    "fluorescence",
+    "fold",
+    "human_ppi",
+    "ppi_affinity",
+    "secondary_structure",
+    "solubility",
+    "stability",
+    "subcellular_localization",
+    "yeast_ppi"
+  ],
+  "ss_linear_context": 0,
+  "ss_calibrated": true,
+  "linear_heads": [],
+  "summary_readouts": [
+    "solubility",
+    "subcellular_localization",
+    "binary_localization",
+    "fold"
+  ],
+  "cosine_heads": {},
+  "nonlinear_summary_heads": {},
+  "calibrated_heads": [
+    "stability"
+  ],
+  "sequence_windows": [
+    "yeast_ppi",
+    "human_ppi"
+  ],
+  "expanded_pair_readouts": [
+    "yeast_ppi",
+    "human_ppi",
+    "ppi_affinity"
+  ],
+  "symmetric_pair_readouts": [
+    "yeast_ppi",
+    "ppi_affinity"
+  ],
+  "task_encoder_layers": {},
+  "task_conditioning": true,
+  "pair_summary_readouts": [],
+  "extension_layers": 2,
+  "window_pooling_training": true,
+  "batch_window_training": true,
+  "class_weight_power": {
+    "fold": 0.5
+  },
+  "task_extension_depths": {
+    "beta_lactamase": 2,
+    "binary_localization": 0,
+    "fluorescence": 0,
+    "fold": 0,
+    "human_ppi": 0,
+    "ppi_affinity": 0,
+    "secondary_structure": 0,
+    "solubility": 0,
+    "stability": 2,
+    "subcellular_localization": 0,
+    "yeast_ppi": 0
+  },
+  "task_max_len": {
+    "human_ppi": 1536
+  },
+  "pair_bilinear_rank": 32,
+  "pair_bilinear_tasks": [
+    "yeast_ppi"
+  ],
+  "pair_residue_interaction": {
+    "bins": 64,
+    "projection_dim": 32,
+    "pair_hidden": 32,
+    "pair_channels": 8,
+    "dropout": 0.1
+  },
+  "pair_residue_tasks": [
+    "yeast_ppi"
+  ],
+  "rank_target_tasks": [
+    "fluorescence",
+    "beta_lactamase"
+  ],
+  "ss_summary_readouts": [],
+  "terminal_summary_readouts": {},
+  "residue_lowrank_heads": {},
+  "shared_summary_residual": {
+    "tasks": [
+      "binary_localization"
+    ],
+    "hidden": 128,
+    "dropout": 0.2
+  },
+  "summary_residual_tasks": [
+    "binary_localization"
+  ],
+  "dual_summary": {
+    "layers": 12,
+    "dim": 768,
+    "heads": 12,
+    "tasks": [
+      "subcellular_localization"
+    ]
+  },
+  "shared_fusion": {
+    "layers": 12,
+    "dim": 768,
+    "heads": 12,
+    "hidden": 256,
+    "conditioned": false,
+    "auxiliary_input": true
+  },
+  "shared_fusion_tasks": [
+    "secondary_structure"
+  ]
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S056/esm2.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""An ESM-2 architecture, trained from scratch, as the reference baseline.
+
+Follows Lin et al. (Science 2023) / facebookresearch/esm in the ways that
+matter for a like-for-like architecture claim:
+
+  * rotary position embeddings, not learned positional embeddings -- this is
+    the defining architectural change from ESM-1b to ESM-2
+  * pre-LayerNorm blocks, GELU feed-forward at 4x expansion
+  * final LayerNorm before the LM head, and the LM head's projection weight
+    tied to the token embedding
+  * the ESM alphabet's special tokens (<cls>/<pad>/<eos>/<mask>) and the same
+    20 standard + rare amino-acid symbols
+
+The published size ladder is reproduced in CONFIGS so the baseline can be named
+by its ESM-2 counterpart rather than by an arbitrary width.
+"""
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ESM-2's alphabet, in its canonical order.
+SPECIALS = ["<cls>", "<pad>", "<eos>", "<unk>"]
+RESIDUES = list("LAGVSERTIDPKQNFYMHWCXBUZO")
+EXTRA = ["<null_1>", "<mask>"]
+ALPHABET = SPECIALS + RESIDUES + EXTRA
+TOKEN = {symbol: index for index, symbol in enumerate(ALPHABET)}
+CLS, PAD, EOS, UNK = TOKEN["<cls>"], TOKEN["<pad>"], TOKEN["<eos>"], TOKEN["<unk>"]
+MASK = TOKEN["<mask>"]
+VOCAB_SIZE = len(ALPHABET)
+FIRST_RESIDUE, LAST_RESIDUE = TOKEN["L"], TOKEN["O"]
+
+# name -> (layers, embed_dim, attention_heads), from the ESM-2 release table.
+CONFIGS = {
+    "esm2_t6_8M":    (6, 320, 20),
+    "esm2_t12_35M":  (12, 480, 20),
+    "esm2_t30_150M": (30, 640, 20),
+    "esm2_t33_650M": (33, 1280, 20),
+}
+
+
+def encode(sequence, max_len=1024):
+    body = [TOKEN.get(c, UNK) for c in sequence[:max_len - 2]]
+    return [CLS] + body + [EOS]
+
+
+def pad_batch(sequences, device):
+    width = max(len(s) for s in sequences)
+    out = torch.full((len(sequences), width), PAD, dtype=torch.long)
+    for row, ids in enumerate(sequences):
+        out[row, :len(ids)] = torch.tensor(ids, dtype=torch.long)
+    return out.to(device, non_blocking=True)
+
+
+class Rotary(nn.Module):
+    """Rotary position embedding, as ESM-2 applies it to q and k."""
+
+    def __init__(self, dim, base=10000):
+        super().__init__()
+        inverse = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inverse", inverse, persistent=False)
+        self._cached_length = 0
+
+    def _tables(self, length, device, dtype):
+        if length != self._cached_length or self._cos.device != device:
+            position = torch.arange(length, device=device, dtype=torch.float)
+            angles = torch.outer(position, self.inverse.to(device))
+            table = torch.cat([angles, angles], dim=-1)
+            self._cos = table.cos()[None, None]
+            self._sin = table.sin()[None, None]
+            self._cached_length = length
+        return self._cos.to(dtype), self._sin.to(dtype)
+
+    @staticmethod
+    def _rotate_half(x):
+        half = x.shape[-1] // 2
+        return torch.cat([-x[..., half:], x[..., :half]], dim=-1)
+
+    def forward(self, q, k):
+        cos, sin = self._tables(q.shape[-2], q.device, q.dtype)
+        return (q * cos + self._rotate_half(q) * sin,
+                k * cos + self._rotate_half(k) * sin)
+
+
+class Attention(nn.Module):
+    def __init__(self, dim, heads):
+        super().__init__()
+        self.heads = heads
+        self.head_dim = dim // heads
+        self.q = nn.Linear(dim, dim)
+        self.k = nn.Linear(dim, dim)
+        self.v = nn.Linear(dim, dim)
+        self.out = nn.Linear(dim, dim)
+        self.rotary = Rotary(self.head_dim)
+
+    def forward(self, x, pad_mask):
+        batch, length, _ = x.shape
+        shape = (batch, length, self.heads, self.head_dim)
+        q = self.q(x).view(shape).transpose(1, 2)
+        k = self.k(x).view(shape).transpose(1, 2)
+        v = self.v(x).view(shape).transpose(1, 2)
+        q, k = self.rotary(q, k)
+        attention_mask = None
+        if pad_mask is not None:
+            attention_mask = (~pad_mask)[:, None, None, :]
+        hidden = F.scaled_dot_product_attention(q, k, v, attn_mask=attention_mask)
+        hidden = hidden.transpose(1, 2).reshape(batch, length, -1)
+        return self.out(hidden)
+
+
+class Block(nn.Module):
+    def __init__(self, dim, heads, ffn):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim)
+        self.attention = Attention(dim, heads)
+        self.norm2 = nn.LayerNorm(dim)
+        self.ffn = nn.Sequential(nn.Linear(dim, ffn), nn.GELU(), nn.Linear(ffn, dim))
+
+    def forward(self, x, pad_mask, condition=None):
+        first = self.norm1(x)
+        if condition is not None:
+            first = first * (1 + condition[0]) + condition[1]
+        x = x + self.attention(first, pad_mask)
+        second = self.norm2(x)
+        if condition is not None:
+            second = second * (1 + condition[2]) + condition[3]
+        return x + self.ffn(second)
+
+
+class Encoder(nn.Module):
+    """The shared backbone. Every task reads from this one parameter set."""
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.dim = dim
+        self.embed = nn.Embedding(VOCAB_SIZE, dim, padding_idx=PAD)
+        self.blocks = nn.ModuleList([Block(dim, heads, dim * 4) for _ in range(layers)])
+        self.norm = nn.LayerNorm(dim)
+        self.lm_bias = nn.Parameter(torch.zeros(VOCAB_SIZE))
+        self.apply(self._init)
+
+    @staticmethod
+    def _init(module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, std=0.02)
+
+    def add_extension(self, layers, heads, before_norm=False):
+        """Append shared residual blocks after the original normalized representation."""
+        assert layers > 0 and not hasattr(self, 'extension')
+        self.extension_before_norm = bool(before_norm)
+        self.extension = nn.ModuleList([Block(self.dim, heads, 4*self.dim) for _ in range(layers)])
+        self.extension.apply(self._init)
+        # Identity at initialization preserves every existing readout exactly.
+        for block in self.extension:
+            nn.init.zeros_(block.attention.out.weight)
+            nn.init.zeros_(block.attention.out.bias)
+            nn.init.zeros_(block.ffn[2].weight)
+            nn.init.zeros_(block.ffn[2].bias)
+
+    def forward(self, tokens, condition=None, depth=None, extension_depth=None):
+        pad_mask = tokens.eq(PAD)
+        hidden = self.embed(tokens)
+        depth=len(self.blocks) if depth is None else int(depth)
+        if not 1<=depth<=len(self.blocks):
+            raise ValueError(f'Encoder depth {depth} is outside 1..{len(self.blocks)}')
+        for index, block in enumerate(self.blocks):
+            if index>=depth:
+                break
+            hidden = block(hidden, pad_mask, condition[index] if condition is not None else None)
+        # Local residue heads must not observe artificial states at padded
+        # positions; otherwise predictions near the C terminus depend on which
+        # other sequences share the batch. Valid transformer states are unchanged.
+        before_norm = getattr(self, 'extension_before_norm', False)
+        if not before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        extension = getattr(self, 'extension', ())
+        extension_depth = len(extension) if extension_depth is None else int(extension_depth)
+        if not 0 <= extension_depth <= len(extension):
+            raise ValueError(f'Extension depth {extension_depth} is outside 0..{len(extension)}')
+        for index, block in enumerate(extension):
+            if index >= extension_depth:
+                break
+            hidden = block(hidden, pad_mask).masked_fill(pad_mask.unsqueeze(-1), 0)
+        if before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        return hidden, pad_mask
+
+    def lm_logits(self, hidden):
+        # Weight tying, as in ESM-2's RobertaLMHead.
+        return F.linear(hidden, self.embed.weight) + self.lm_bias
+
+    def pool(self, tokens):
+        hidden, pad_mask = self.forward(tokens)
+        keep = (~pad_mask).to(hidden.dtype).unsqueeze(-1)
+        return (hidden * keep).sum(1) / keep.sum(1).clamp(min=1)
+
+
+class Model(nn.Module):
+    """ESM-2 backbone plus the eleven PEER task heads."""
+
+    CLASSES = {"solubility": 2, "subcellular_localization": 10,
+               "binary_localization": 2, "fold": 1195,
+               "yeast_ppi": 2, "human_ppi": 2}
+    REGRESSION = ("fluorescence", "stability", "beta_lactamase", "ppi_affinity")
+    PAIR = {"yeast_ppi", "human_ppi", "ppi_affinity"}
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.encoder = Encoder(layers=layers, dim=dim, heads=heads)
+        self.heads = nn.ModuleDict()
+        for task, n in self.CLASSES.items():
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, n))
+        for task in self.REGRESSION:
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 1))
+        self.heads["secondary_structure"] = nn.Sequential(
+            nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.PAIR:
+            a = self.encoder.pool(pad_batch(
+                [encode(x["sequence_a"], max_len) for x in batch], device))
+            b = self.encoder.pool(pad_batch(
+                [encode(x["sequence_b"], max_len) for x in batch], device))
+            return torch.cat([a, b], dim=-1)
+        return self.encoder.pool(pad_batch(
+            [encode(x["sequence"], max_len) for x in batch], device))
+
+
+def build(name="esm2_t12_35M"):
+    layers, dim, heads = CONFIGS[name]
+    model = Model(layers=layers, dim=dim, heads=heads)
+    return model, {"name": name, "layers": layers, "dim": dim, "heads": heads}
+
+
+if __name__ == "__main__":
+    for name in CONFIGS:
+        model, config = build(name)
+        backbone = sum(p.numel() for p in model.encoder.parameters())
+        total = sum(p.numel() for p in model.parameters())
+        print(f"{name:16s} backbone {backbone/1e6:7.2f}M   with heads {total/1e6:7.2f}M")

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S056/infer.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PYTHONDONTWRITEBYTECODE=1
+exec python3 "$(dirname "$0")/replay.py" "$1" "$2"

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S056/replay.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Self-contained replay shared by research evaluation and frozen packages."""
+import contextlib
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+
+import esm2
+
+TASKS = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+         'subcellular_localization', 'binary_localization', 'fold',
+         'secondary_structure', 'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+
+def autocast(device):
+    return torch.autocast('cuda', dtype=torch.bfloat16) if device.type == 'cuda' else contextlib.nullcontext()
+
+
+def head_output(model, task, representation, device, fp32=False):
+    apply = model.apply_head if hasattr(model, 'apply_head') else lambda task, value: model.heads[task](value)
+    if fp32:
+        with torch.autocast(device.type, enabled=False):
+            values={k:v.float() if v.is_floating_point() else v for k,v in representation.items()} if isinstance(representation,dict) else representation.float()
+            return apply(task, values).float()
+    return apply(task, representation).float()
+
+
+def residue_states(model, tokens, task):
+    return model.encode_residues(tokens, task) if hasattr(model, 'encode_residues') else model.encoder(tokens)
+
+
+def windows(length, width=1022, stride=768):
+    if length <= width:
+        return [(0, length)]
+    starts = list(range(0, length - width + 1, stride))
+    if starts[-1] != length - width:
+        starts.append(length - width)
+    return [(s, min(s + width, length)) for s in starts]
+
+
+def batches(rows, task, token_budget=16384, max_len=1024, max_batch=128):
+    lengths = [min(max(map(len, r['features'].values())) + 2, max_len) for r in rows]
+    order = sorted(range(len(rows)), key=lengths.__getitem__)
+    current, width = [], 0
+    for i in order:
+        length = lengths[i]
+        # Pair sequences require two separate passes, but the peak tensor size is unchanged.
+        if current and (max(width, length) * (len(current) + 1) > token_budget or len(current) >= max_batch):
+            yield current
+            current, width = [], 0
+        current.append(i)
+        width = max(width, length)
+    if current:
+        yield current
+
+
+@torch.inference_mode()
+def predict_records(model, rows, task, device, config=None, token_budget=16384):
+    config = config or {}
+    max_len = config.get('task_max_len', {}).get(task, config.get('max_len', 1024))
+    full_ss = config.get('full_ss', True)
+    fp32_option = config.get('fp32_heads', False)
+    fp32_heads = fp32_option is True or (isinstance(fp32_option, list) and task in fp32_option)
+    was_training = model.training
+    model.eval()
+    result = {}
+    for ids in batches(rows, task, token_budget, max_len):
+        chunk = [rows[i] for i in ids]
+        features = [r['features'] for r in chunk]
+        if task == 'secondary_structure':
+            if full_ss and any(len(f['sequence']) > max_len - 2 for f in features):
+                for record in chunk:
+                    seq = record['features']['sequence']
+                    pieces = windows(len(seq), max_len - 2, min(768, max_len - 2))
+                    total = np.zeros((len(seq), 3), dtype=np.float32)
+                    weight_sum = np.zeros((len(seq), 1), dtype=np.float32)
+                    for begin in range(0, len(pieces), max(1, token_budget // max_len)):
+                        part = pieces[begin:begin + max(1, token_budget // max_len)]
+                        tokens = esm2.pad_batch([esm2.encode(seq[s:e], max_len) for s, e in part], device)
+                        with autocast(device):
+                            hidden, _ = residue_states(model, tokens, task)
+                            logits = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                        for j, (s, e) in enumerate(part):
+                            size = e - s
+                            # Smooth boundaries, without discarding any residue.
+                            weight = np.minimum(np.arange(1, size + 1), np.arange(size, 0, -1))
+                            weight = np.minimum(weight, 128).astype(np.float32)[:, None]
+                            total[s:e] += logits[j, 1:1+size] * weight
+                            weight_sum[s:e] += weight
+                    scores = total / np.maximum(weight_sum, 1)
+                    result[record['example_id']] = {'ss3_scores': scores.tolist()}
+            else:
+                tokens = esm2.pad_batch([esm2.encode(f['sequence'], max_len) for f in features], device)
+                with autocast(device):
+                    hidden, _ = residue_states(model, tokens, task)
+                    probabilities = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                for j, record in enumerate(chunk):
+                    length = len(record['features']['sequence'])
+                    used = min(length, max_len - 2)
+                    scores = probabilities[j, 1:1+used].tolist()
+                    scores.extend([[1.0, 1.0, 1.0] for _ in range(length-used)])
+                    result[record['example_id']] = {'ss3_scores': scores}
+            continue
+        with autocast(device):
+            representation = model.represent(task, features, device, max_len)
+            output = head_output(model, task, representation, device, fp32_heads)
+            if task in model.CLASSES:
+                output = output.softmax(-1)
+            if task in config.get('symmetric_pairs', []):
+                swapped = [{'sequence_a': f['sequence_b'], 'sequence_b': f['sequence_a']} for f in features]
+                swapped_rep = model.represent(task, swapped, device, max_len)
+                second = head_output(model, task, swapped_rep, device, fp32_heads)
+                if task in model.CLASSES:
+                    second = second.softmax(-1)
+                output = (output + second) * 0.5
+            if task in model.CLASSES:
+                output = output.clamp_min(1e-9)
+            elif hasattr(model, 'unscale'):
+                output = model.unscale(task, output)
+        values = output.cpu().tolist()
+        for record, value in zip(chunk, values):
+            result[record['example_id']] = {'scores': value} if task in model.CLASSES else {'value': value[0]}
+    if task == 'secondary_structure' and hasattr(model, 'ss_chain_decoder'):
+        # Decode complete chains only after all overlapping-window probabilities
+        # have been aggregated. No labels or parameter updates enter replay.
+        identifiers = [record['example_id'] for record in rows]
+        probabilities = [result[identifier]['ss3_scores'] for identifier in identifiers]
+        decoded = model.ss_chain_decoder.decode(probabilities)
+        for identifier, scores in zip(identifiers, decoded):
+            result[identifier] = {'ss3_scores': scores.tolist()}
+    model.train(was_training)
+    return result
+
+
+def load_model(package, device):
+    config = json.loads((package / 'config.json').read_text())
+    if config.get('architecture') == 'unified':
+        from unified import UnifiedModel
+        model = UnifiedModel(config)
+    else:
+        model = esm2.Model(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+    model.load_state_dict(torch.load(package / 'model.pt', map_location='cpu', weights_only=True))
+    return model.to(device).eval(), config
+
+
+def main():
+    if len(sys.argv) != 3:
+        raise SystemExit('usage: replay.py INPUT_ROOT OUTPUT_ROOT')
+    torch.set_num_threads(6)
+    source, destination = Path(sys.argv[1]), Path(sys.argv[2]) / 'predictions'
+    destination.mkdir(parents=True, exist_ok=True)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model, config = load_model(Path(__file__).resolve().parent, device)
+    for task in TASKS:
+        rows = [json.loads(line) for line in (source / f'{task}.jsonl').open()]
+        predictions = predict_records(model, rows, task, device, config)
+        with (destination / f'{task}.jsonl').open('w') as sink:
+            for row in rows:
+                sink.write(json.dumps({'example_id': row['example_id'], 'prediction': predictions[row['example_id']]}, separators=(',', ':')) + '\n')
+
+
+if __name__ == '__main__':
+    main()

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S056/selection.json

@@ -0,0 +1,489 @@
+{
+  "score_kind": "tune_labels_used_for_fold_fluorescence_beta_lactamase_ppi_affinity_and_stability",
+  "tasks_reusing_tune_labels": [
+    "fold",
+    "fluorescence",
+    "beta_lactamase",
+    "ppi_affinity",
+    "stability"
+  ],
+  "production_aggregate_excluded_from_selection": true,
+  "fit_only_development_reference": {
+    "reward": 0.7214368925668725,
+    "tasks": {
+      "beta_lactamase": {
+        "invalid_reason": null,
+        "reward": 0.8851158090618965,
+        "spearman": 0.8851158090618965
+      },
+      "binary_localization": {
+        "accuracy": 0.9462116830537883,
+        "balanced_accuracy": 0.9419155998103367,
+        "invalid_reason": null,
+        "macro_f1": 0.9439947337349208,
+        "reward": 0.9462116830537883
+      },
+      "fluorescence": {
+        "invalid_reason": null,
+        "reward": 0.826705913429907,
+        "spearman": 0.826705913429907
+      },
+      "fold": {
+        "accuracy": 0.24864130434782608,
+        "balanced_accuracy": 0.16124022176653757,
+        "invalid_reason": null,
+        "macro_f1": 0.03846637235687955,
+        "reward": 0.24864130434782608
+      },
+      "human_ppi": {
+        "accuracy": 0.7968253968253968,
+        "balanced_accuracy": 0.8005952380952381,
+        "invalid_reason": null,
+        "macro_f1": 0.7968233491897122,
+        "reward": 0.7968253968253968
+      },
+      "ppi_affinity": {
+        "invalid_reason": null,
+        "reward": 0.5341420012716276,
+        "rmse": 1.9334586965956642,
+        "spearman": 0.7162121646852028
+      },
+      "secondary_structure": {
+        "accuracy": 0.759638088021676,
+        "invalid_reason": null,
+        "reward": 0.759638088021676,
+        "valid_residues": 556931
+      },
+      "solubility": {
+        "accuracy": 0.7533851915874388,
+        "balanced_accuracy": 0.7392508255204544,
+        "invalid_reason": null,
+        "macro_f1": 0.742264399722415,
+        "reward": 0.7533851915874388
+      },
+      "stability": {
+        "invalid_reason": null,
+        "reward": 0.7311607642876724,
+        "spearman": 0.7311607642876724
+      },
+      "subcellular_localization": {
+        "accuracy": 0.7908217716115261,
+        "balanced_accuracy": 0.6999121500389823,
+        "invalid_reason": null,
+        "macro_f1": 0.7198401417205603,
+        "reward": 0.7908217716115261
+      },
+      "yeast_ppi": {
+        "accuracy": 0.6631578947368421,
+        "balanced_accuracy": 0.6597985347985349,
+        "invalid_reason": null,
+        "macro_f1": 0.6567299006323397,
+        "reward": 0.6631578947368421
+      }
+    },
+    "package": "/workspace/research/shared-fusion8h-selected-replay/candidate/package",
+    "report": "/workspace/research/shared-fusion8h-selected-replay/candidate/report.json",
+    "model_sha256": "8ce3336ad317cf13cf739101485bec029683a2a781f11443887372704e75e8f1",
+    "inference_assets_sha256": {
+      "model.pt": "8ce3336ad317cf13cf739101485bec029683a2a781f11443887372704e75e8f1",
+      "config.json": "b70e96d927ab3daeac46fbb18f190b04ac05d070fe40850c9f8872b7d5e796b0",
+      "esm2.py": "d4d512296047ebbd0f9a26dc1390107f72762cb5de011eefc9fecb18118a9be9",
+      "unified.py": "adbd895246362ab23497425b9f906685c1a95560116563fefa07bfff75bfe45b",
+      "replay.py": "9c5add2d3fb117470241cf63f621e4797a16962cddadbaad6de2cfb481e7fa85",
+      "infer.sh": "60f55b73f5b39a35a61df84026abed9a127b1cc035d650c9e1ca62f54fc2b468"
+    },
+    "parameters": 138597529,
+    "score_kind": "fit_only_development_tune_selection",
+    "decision": "/workspace/research/shared-fusion8h-selected-replay/decision.json"
+  },
+  "pending_independent_replay": false,
+  "evidence": {
+    "full_original_study": {
+      "status": "selected_pending_assembly_ablations_and_native_review",
+      "chosen_arm": "full",
+      "candidates": {
+        "zero": {
+          "enabled_tasks": [],
+          "routed_mean": 0.7166638090200526,
+          "mean_gain": 0.0,
+          "conditional95": [
+            0.0,
+            0.0
+          ],
+          "eligible": false
+        },
+        "full": {
+          "enabled_tasks": [
+            "secondary_structure",
+            "subcellular_localization"
+          ],
+          "routed_mean": 0.7188819946010887,
+          "mean_gain": 0.002218185581036117,
+          "conditional95": [
+            0.0015618427916501052,
+            0.0029223180172046797
+          ],
+          "eligible": true,
+          "same_routes_control_comparison": {
+            "mean_delta": 0.002266686052709703,
+            "conditional95": [
+              0.00163301878385431,
+              0.0028783273901904533
+            ],
+            "definition": "Treatment-enabled routes only; all other task deltas zero. Both states are final4000EMA."
+          }
+        }
+      },
+      "tasks": {
+        "beta_lactamase": {
+          "examples": 520,
+          "parent": 0.8851158090618965,
+          "zero": 0.8848969852420536,
+          "full": 0.8845439568759146,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.00021882381984283938,
+              "conditional95": [
+                -0.0019190809982984557,
+                0.001469238318171373
+              ]
+            },
+            "full_minus_parent": {
+              "delta": -0.0005718521859818804,
+              "conditional95": [
+                -0.002610170059700731,
+                0.0012711578290376243
+              ]
+            },
+            "full_minus_zero": {
+              "delta": -0.000353028366139041,
+              "conditional95": [
+                -0.001745614993564945,
+                0.0009405445898092214
+              ]
+            }
+          }
+        },
+        "binary_localization": {
+          "examples": 1729,
+          "parent": 0.9462116830537883,
+          "zero": 0.945054945054945,
+          "full": 0.945054945054945,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.0011567379988433046,
+              "conditional95": [
+                -0.0046269519953731075,
+                0.002313475997686501
+              ]
+            },
+            "full_minus_parent": {
+              "delta": -0.0011567379988433046,
+              "conditional95": [
+                -0.0063620589936379535,
+                0.003470213996529803
+              ]
+            },
+            "full_minus_zero": {
+              "delta": 0.0,
+              "conditional95": [
+                -0.004048582995951344,
+                0.004048582995951344
+              ]
+            }
+          }
+        },
+        "fluorescence": {
+          "examples": 5362,
+          "parent": 0.826705913429907,
+          "zero": 0.8261891093573827,
+          "full": 0.8261173562838637,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.0005168040725243017,
+              "conditional95": [
+                -0.0009074676903033013,
+                -0.00010004212525541478
+              ]
+            },
+            "full_minus_parent": {
+              "delta": -0.0005885571460432226,
+              "conditional95": [
+                -0.001125277545181083,
+                -5.1938701607648406e-05
+              ]
+            },
+            "full_minus_zero": {
+              "delta": -7.175307351892091e-05,
+              "conditional95": [
+                -0.0005318636811548316,
+                0.0003805983773495475
+              ]
+            }
+          }
+        },
+        "fold": {
+          "examples": 736,
+          "parent": 0.24864130434782608,
+          "zero": 0.24320652173913043,
+          "full": 0.24592391304347827,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.0054347826086956486,
+              "conditional95": [
+                -0.014945652173913027,
+                0.002717391304347838
+              ]
+            },
+            "full_minus_parent": {
+              "delta": -0.0027173913043478104,
+              "conditional95": [
+                -0.012228260869565244,
+                0.008152173913043459
+              ]
+            },
+            "full_minus_zero": {
+              "delta": 0.002717391304347838,
+              "conditional95": [
+                -0.005434782608695676,
+                0.012228260869565216
+              ]
+            }
+          }
+        },
+        "human_ppi": {
+          "examples": 315,
+          "parent": 0.7968253968253968,
+          "zero": 0.7841269841269841,
+          "full": 0.780952380952381,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.012698412698412653,
+              "conditional95": [
+                -0.03492063492063491,
+                0.009523809523809493
+              ]
+            },
+            "full_minus_parent": {
+              "delta": -0.015873015873015817,
+              "conditional95": [
+                -0.0444444444444444,
+                0.012698412698412764
+              ]
+            },
+            "full_minus_zero": {
+              "delta": -0.0031746031746031633,
+              "conditional95": [
+                -0.022222222222222254,
+                0.015873015873015817
+              ]
+            }
+          }
+        },
+        "ppi_affinity": {
+          "examples": 203,
+          "parent": 0.5341420012716276,
+          "zero": 0.5189355347334772,
+          "full": 0.5250420716238517,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.015206466538150387,
+              "conditional95": [
+                -0.027845041079411027,
+                -0.004519207693363675
+              ]
+            },
+            "full_minus_parent": {
+              "delta": -0.00909992964777584,
+              "conditional95": [
+                -0.01808313521817929,
+                -0.0005967466520302408
+              ]
+            },
+            "full_minus_zero": {
+              "delta": 0.006106536890374548,
+              "conditional95": [
+                0.0007892307088291708,
+                0.012730268854570593
+              ]
+            }
+          }
+        },
+        "secondary_structure": {
+          "examples": 2170,
+          "parent": 0.7441316787896526,
+          "zero": 0.7439539188876181,
+          "full": 0.759638088021676,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.0001777599020345022,
+              "conditional95": [
+                -0.0004337054552560532,
+                8.817027773533869e-05
+              ]
+            },
+            "full_minus_parent": {
+              "delta": 0.0155064092320234,
+              "conditional95": [
+                0.014309663742752683,
+                0.016726396557557775
+              ]
+            },
+            "full_minus_zero": {
+              "delta": 0.0156841691340579,
+              "conditional95": [
+                0.014499037971929394,
+                0.01689329854300642
+              ]
+            }
+          }
+        },
+        "solubility": {
+          "examples": 6942,
+          "parent": 0.7533851915874388,
+          "zero": 0.7492077211178335,
+          "full": 0.7539613944108327,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.00417747046960526,
+              "conditional95": [
+                -0.007202535292422985,
+                -0.0008643042350907626
+              ]
+            },
+            "full_minus_parent": {
+              "delta": 0.0005762028233938787,
+              "conditional95": [
+                -0.003892970325554695,
+                0.005189426678190781
+              ]
+            },
+            "full_minus_zero": {
+              "delta": 0.004753673292999139,
+              "conditional95": [
+                0.0004321521175453258,
+                0.00907519446845284
+              ]
+            }
+          }
+        },
+        "stability": {
+          "examples": 2512,
+          "parent": 0.7311607642876724,
+          "zero": 0.730056227683189,
+          "full": 0.7329317436395436,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.001104536604483397,
+              "conditional95": [
+                -0.0028202937870095784,
+                0.0005720436213680235
+              ]
+            },
+            "full_minus_parent": {
+              "delta": 0.0017709793518712047,
+              "conditional95": [
+                -0.0009297756963640934,
+                0.004598901782002785
+              ]
+            },
+            "full_minus_zero": {
+              "delta": 0.0028755159563546018,
+              "conditional95": [
+                0.0007289400154873922,
+                0.005253062278283147
+              ]
+            }
+          }
+        },
+        "subcellular_localization": {
+          "examples": 2811,
+          "parent": 0.7538242618285308,
+          "zero": 0.7534685165421559,
+          "full": 0.7627178939879047,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.0003557452863749422,
+              "conditional95": [
+                -0.00570081821415867,
+                0.004980434009249302
+              ]
+            },
+            "full_minus_parent": {
+              "delta": 0.008893632159373888,
+              "conditional95": [
+                0.0010672358591249376,
+                0.016364283173248007
+              ]
+            },
+            "full_minus_zero": {
+              "delta": 0.00924937744574883,
+              "conditional95": [
+                0.0024902170046247063,
+                0.015652792600498015
+              ]
+            }
+          }
+        },
+        "yeast_ppi": {
+          "examples": 95,
+          "parent": 0.6631578947368421,
+          "zero": 0.6421052631578947,
+          "full": 0.6421052631578947,
+          "comparisons": {
+            "zero_minus_parent": {
+              "delta": -0.021052631578947323,
+              "conditional95": [
+                -0.0736842105263158,
+                0.03157894736842104
+              ]
+            },
+            "full_minus_parent": {
+              "delta": -0.021052631578947323,
+              "conditional95": [
+                -0.0736842105263158,
+                0.021315789473684035
+              ]
+            },
+            "full_minus_zero": {
+              "delta": 0.0,
+              "conditional95": [
+                -0.03157894736842104,
+                0.03157894736842104
+              ]
+            }
+          }
+        }
+      },
+      "one_final_EMA_state_per_arm": true,
+      "mixed_shared_weights": false,
+      "bootstrap_draws": 1000,
+      "bootstrap_seed": 20261111,
+      "sampling": "Paired examples per task; SS by protein. Same resamples for all three predictions.",
+      "limitations": "Repeated tune selection; conditional intervals do not correct selection or protein-family dependence. Zero auxiliary changes joint LayerNorm input distribution.",
+      "published": false,
+      "next": "If eligible, use one complete shared state, prove primary dependency, prune unused auxiliary for zero, native replay and compare current selected. Renew extra-label evidence on changed feature routes."
+    },
+    "retained_dual_tasks": [
+      "subcellular_localization"
+    ],
+    "active_fusion_tasks": [
+      "secondary_structure"
+    ],
+    "remaining_full_minus_zero_conditional95": [
+      0.014499037971929394,
+      0.01689329854300642
+    ],
+    "SS_gain": {
+      "delta": 0.0155064092320234,
+      "conditional95": [
+        0.014309663742752683,
+        0.016726396557557775
+      ]
+    },
+    "production_extra_label_feature_paths_unchanged": true,
+    "limitations": "Conditional paired protein intervals after repeated Tune selection; not corrected for protein-family dependence."
+  },
+  "all11_native_valid": true,
+  "all11_prediction_references_exact": true
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S056/unified.py

@@ -0,0 +1,718 @@
+"""One jointly learned protein encoder, shared pooling, and eleven small heads."""
+import math
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import esm2
+
+
+class NormalizedLinear(nn.Module):
+    def __init__(self, width, outputs=1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs)
+
+    def forward(self, values):
+        return self.linear((values - self.mean) / self.scale)
+
+
+class LowRankPositionHead(nn.Module):
+    """A shared residue projection followed by an ordered position readout."""
+    def __init__(self, dim, bins, rank, outputs=1):
+        super().__init__()
+        assert 0 < rank <= min(dim, bins)
+        self.dim = dim
+        self.project = nn.Linear(dim, rank, bias=False)
+        self.output = nn.Linear(bins * rank, outputs)
+
+    def forward(self, values):
+        residues = values.reshape(values.shape[0], -1, self.dim)
+        return self.output(self.project(residues).flatten(1))
+
+
+class NormalizedCosine(nn.Module):
+    def __init__(self, width, outputs, temperature=20.):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs, bias=False)
+        self.temperature = temperature
+
+    def forward(self, values):
+        features = F.normalize((values-self.mean)/self.scale, dim=-1)
+        return F.linear(features, F.normalize(self.linear.weight, dim=-1))*self.temperature
+
+
+class NormalizedMLP(nn.Module):
+    def __init__(self, width, outputs, hidden=128, dropout=.1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(), nn.LayerNorm(hidden),
+                                     nn.Dropout(dropout), nn.Linear(hidden, outputs))
+
+    def forward(self, values):
+        return self.network((values-self.mean)/self.scale)
+
+
+class SharedSummaryResidual(nn.Module):
+    """One nonlinear summary map jointly used by several classification heads."""
+    def __init__(self, width, hidden, dropout, classes):
+        super().__init__()
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(),
+                                     nn.LayerNorm(hidden), nn.Dropout(dropout),
+                                     nn.Linear(hidden, hidden), nn.GELU(), nn.Dropout(dropout))
+        self.heads = nn.ModuleDict({task: nn.Linear(hidden, outputs)
+                                   for task, outputs in sorted(classes.items())})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, normalized_summary):
+        return self.heads[task](self.network(normalized_summary))
+
+
+class NormalizedResidueLinear(nn.Module):
+    def __init__(self, dim, kernel=9):
+        super().__init__()
+        assert kernel > 0 and kernel % 2 == 1
+        self.kernel = kernel
+        self.readout = NormalizedLinear(dim * kernel, 3)
+
+    @staticmethod
+    def features(hidden, kernel):
+        padded = F.pad(hidden.float().transpose(1, 2), (kernel // 2, kernel // 2))
+        return padded.unfold(-1, kernel, 1).transpose(1, 2).flatten(2)
+
+    def forward(self, hidden):
+        return self.readout(self.features(hidden, self.kernel))
+
+
+class LocalResidueHead(nn.Sequential):
+    """Preserve the original four head parameter names; add a local residual."""
+    def __init__(self, dim):
+        super().__init__(nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+        self.context = nn.Sequential(nn.Conv1d(dim, dim, 9, padding=4, groups=dim),
+                                     nn.GELU(), nn.Conv1d(dim, dim, 1))
+        nn.init.zeros_(self.context[-1].weight)
+        nn.init.zeros_(self.context[-1].bias)
+
+    def forward(self, x):
+        x = x + self.context(x.transpose(1, 2)).transpose(1, 2)
+        for i in range(4):
+            x = self[i](x)
+        return x
+
+
+class CalibratedLocalResidueHead(LocalResidueHead):
+    def __init__(self, dim):
+        super().__init__(dim)
+        self[3] = NormalizedLinear(dim, 3)
+
+
+class ResidualSequenceConvHead(nn.Module):
+    """Learn local sequence motifs alongside the retained summary classifier."""
+    def __init__(self, dim, outputs, channels=128, dropout=.2, retain_summary=True):
+        super().__init__()
+        self.base = NormalizedLinear(7 * dim, outputs) if retain_summary else None
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, channels)
+        self.convs = nn.ModuleList([nn.Conv1d(channels, channels, k, padding=k//2) for k in (3,9)])
+        self.norms = nn.ModuleList([nn.LayerNorm(channels) for _ in self.convs])
+        self.output = nn.Linear(4 * channels, outputs)
+        nn.init.zeros_(self.output.weight);nn.init.zeros_(self.output.bias)
+        self.dropout = dropout
+
+    def forward(self, features):
+        valid = features['valid'].bool().unsqueeze(-1)
+        x = F.gelu(self.project((features['hidden']-self.mean)/self.scale)) * valid
+        summaries = []
+        for conv,norm in zip(self.convs,self.norms):
+            y = norm(F.gelu(conv(x.transpose(1,2)).transpose(1,2)))
+            center = (y*valid).sum(1)/valid.sum(1).clamp_min(1)
+            maximum = y.masked_fill(~valid,-1e4).amax(1)
+            maximum = torch.where(valid.any(1),maximum,torch.zeros_like(maximum))
+            summaries.extend([center,maximum])
+        pooled = F.dropout(torch.cat(summaries,dim=-1),self.dropout,self.training)
+        logits=self.output(pooled)
+        return self.base(features['summary']) + logits if self.base is not None else logits
+
+
+class TokenLogMeanExpHead(nn.Module):
+    """Class-specific local evidence, pooled without sequence-length bias."""
+    def __init__(self, dim, outputs):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.linear = nn.Linear(dim, outputs)
+
+    def forward(self, representation):
+        values, valid = representation['hidden'].float(), representation['valid']
+        logits = self.linear((values-self.mean)/self.scale)
+        logits = logits.masked_fill(~valid.unsqueeze(-1), -torch.inf)
+        return torch.logsumexp(logits, 1)-valid.sum(1).clamp_min(1).float().log()[:, None]
+
+    def packed(self, values, lengths):
+        """Equivalent unpadded computation for frozen-feature readout fitting."""
+        logits = self.linear((values.float()-self.mean)/self.scale)
+        # The stabilizing maximum cancels in the derivative; detach avoids
+        # retaining another large token-by-class gradient path.
+        maximum = torch.segment_reduce(logits.detach(), 'max', lengths=lengths)
+        index = torch.repeat_interleave(torch.arange(len(lengths), device=lengths.device), lengths,
+                                        output_size=len(values))
+        exponent = (logits-maximum[index]).exp()
+        total = torch.segment_reduce(exponent, 'sum', lengths=lengths)
+        return maximum+total.log()-lengths.float().log()[:, None]
+
+
+class SharedPairResidueInteraction(nn.Module):
+    """A shared nonlinear comparison of local states from both protein chains."""
+    def __init__(self, dim, settings, classes):
+        super().__init__()
+        width, hidden, channels = (settings[k] for k in ['projection_dim', 'pair_hidden', 'pair_channels'])
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, width)
+        self.compare = nn.Sequential(nn.Linear(2*width, hidden), nn.GELU(),
+                                     nn.Linear(hidden, channels), nn.GELU())
+        self.dropout = settings['dropout']
+        self.heads = nn.ModuleDict({task: nn.Linear(2*channels, classes.get(task, 1))
+                                   for task in sorted(esm2.Model.PAIR)})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, first, second):
+        first = F.gelu(self.project((first-self.mean)/self.scale))
+        second = F.gelu(self.project((second-self.mean)/self.scale))
+        first = F.dropout(first, self.dropout, self.training)
+        second = F.dropout(second, self.dropout, self.training)
+        pair = torch.cat([(first[:, :, None]-second[:, None, :]).abs(),
+                          first[:, :, None]*second[:, None, :]], dim=-1)
+        local = self.compare(pair)
+        summary = torch.cat([local.mean((1, 2)), local.amax((1, 2))], dim=-1)
+        return self.heads[task](summary)
+
+
+class SSChainDecoder(nn.Module):
+    """Small learned label-compatibility model, applied to frozen residue unaries."""
+    def __init__(self):
+        super().__init__()
+        self.transition = nn.Parameter(torch.empty(3, 3))
+        self.start = nn.Parameter(torch.empty(3))
+        self.end = nn.Parameter(torch.empty(3))
+        for parameter in self.parameters():
+            nn.init.normal_(parameter, std=.01)
+
+    def decode(self, probabilities):
+        from ss_chain import decode_probabilities
+        values = [parameter.detach().double().cpu().numpy()
+                  for parameter in (self.transition, self.start, self.end)]
+        return decode_probabilities(probabilities, *values)
+
+
+class UnifiedModel(esm2.Model):
+    TASK_ORDER = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+                  'subcellular_localization', 'binary_localization', 'fold',
+                  'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+    def __init__(self, config):
+        super().__init__(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+        self.config = config
+        self.task_index = {t: i for i, t in enumerate(self.TASK_ORDER)}
+        dim = config['dim']
+        if config.get('extension_layers', 0):
+            self.encoder.add_extension(config['extension_layers'], config['heads'],
+                                       before_norm=config.get('extension_before_norm', False))
+        if config.get('task_conditioning', False):
+            self.task_condition = nn.Parameter(torch.zeros(11, config['layers'], 4, dim))
+        if config.get('pooling', 'mean') == 'rich':
+            self.pool_query = nn.Parameter(torch.randn(len(self.TASK_ORDER), 2, dim) * 0.02)
+            self.pool_position = nn.Parameter(torch.zeros(len(self.TASK_ORDER), 2, 4))
+            # Shared across tasks, with a zero initial residual for safe lineage transfer.
+            self.pool_fuse = nn.Linear(6 * dim, dim)
+            nn.init.zeros_(self.pool_fuse.weight)
+            nn.init.zeros_(self.pool_fuse.bias)
+        if config.get('pair_interaction', False):
+            self.pair_fuse = nn.Linear(2 * dim, 2 * dim)
+            nn.init.zeros_(self.pair_fuse.weight)
+            nn.init.zeros_(self.pair_fuse.bias)
+        if config.get('ss_context', False):
+            self.heads['secondary_structure'] = LocalResidueHead(dim)
+        for task in config.get('linear_heads', []):
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(nn.Linear(width, self.CLASSES.get(task, 1)))
+        for task, settings in config.get('residue_readouts', {}).items():
+            self.heads[task] = NormalizedLinear(settings['bins'] * dim, self.CLASSES.get(task, 1))
+        for task, rank in config.get('residue_lowrank_heads', {}).items():
+            bins = config['residue_readouts'][task]['bins']
+            self.heads[task] = LowRankPositionHead(dim, bins, rank, self.CLASSES.get(task, 1))
+        for task in config.get('summary_readouts', []):
+            assert task not in self.PAIR and config.get('pooling') == 'rich'
+            self.heads[task] = NormalizedLinear(7 * dim, self.CLASSES.get(task, 1))
+        for task in config.get('sequence_composition_readouts', []):
+            from sequence_composition import WIDTH
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES
+            assert all(task not in config.get(key,[]) for key in
+                       ['cosine_heads','nonlinear_summary_heads','ss_summary_readouts',
+                        'sequence_conv_readouts','terminal_summary_readouts','token_logmeanexp_heads'])
+            self.heads[task] = NormalizedLinear(7 * dim + WIDTH, self.CLASSES[task])
+        for task, temperature in config.get('cosine_heads', {}).items():
+            assert task in config.get('summary_readouts', [])
+            self.heads[task] = NormalizedCosine(7*dim, self.CLASSES[task], temperature)
+        for task, settings in config.get('nonlinear_summary_heads', {}).items():
+            assert task in config.get('summary_readouts', []) and task not in config.get('cosine_heads', {})
+            self.heads[task] = NormalizedMLP(7*dim, self.CLASSES.get(task,1), settings['hidden'], settings['dropout'])
+        for task in config.get('calibrated_heads', []):
+            assert task not in config.get('summary_readouts', []) and task not in config.get('residue_readouts', {})
+            assert task not in config.get('linear_heads', [])
+            self.heads[task][3] = NormalizedLinear(dim, self.CLASSES.get(task,1))
+        for task in config.get('expanded_pair_readouts', []):
+            assert task in self.PAIR
+            width=3 if task in config.get('symmetric_pair_readouts',[]) else 4
+            if task in config.get('pair_summary_readouts', []):
+                assert config.get('pooling') == 'rich'
+                width *= 8
+            self.heads[task] = NormalizedLinear(width*dim, self.CLASSES.get(task,1))
+        if config.get('ss_linear_context'):
+            self.heads['secondary_structure'] = NormalizedResidueLinear(dim, config['ss_linear_context'])
+        if config.get('ss_calibrated'):
+            assert not config.get('ss_linear_context')
+            self.heads['secondary_structure'] = CalibratedLocalResidueHead(dim)
+        for task in config.get('ss_summary_readouts', []):
+            assert task in config.get('summary_readouts', []) and task not in self.PAIR
+            self.heads[task] = NormalizedLinear(7*dim+40, self.CLASSES[task])
+        for task,settings in config.get('sequence_conv_readouts',{}).items():
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES and task not in self.PAIR
+            self.heads[task] = ResidualSequenceConvHead(dim,self.CLASSES[task],settings['channels'],settings['dropout'],settings.get('retain_summary',True))
+        for task, settings in config.get('terminal_summary_readouts', {}).items():
+            assert task in config.get('summary_readouts', []) and task in self.CLASSES and task not in self.PAIR
+            assert all(task not in config.get(key, {}) for key in
+                       ['cosine_heads', 'nonlinear_summary_heads', 'ss_summary_readouts', 'sequence_conv_readouts'])
+            bins = settings['bins']
+            assert bins > 0 and all(settings[key] > 0 and settings[key] % bins == 0
+                                    for key in ['prefix_residues', 'suffix_residues'])
+            self.heads[task] = NormalizedLinear((7+2*bins)*dim, self.CLASSES[task])
+        if config.get('pair_bilinear_rank', 0):
+            rank = config['pair_bilinear_rank']
+            assert not config.get('pair_summary_readouts')
+            self.pair_bilinear_projection = nn.Linear(dim, rank, bias=False)
+            nn.init.normal_(self.pair_bilinear_projection.weight, std=dim ** -.5)
+            with torch.no_grad():
+                self.pair_bilinear_projection.weight.copy_(F.normalize(self.pair_bilinear_projection.weight, dim=1))
+            self.pair_bilinear_heads = nn.ModuleDict({
+                task: nn.Linear(rank, self.CLASSES.get(task, 1), bias=False)
+                for task in sorted(self.PAIR)})
+            for head in self.pair_bilinear_heads.values():
+                nn.init.zeros_(head.weight)
+            self.register_buffer('pair_bilinear_mean', torch.zeros(dim))
+            self.register_buffer('pair_bilinear_scale', torch.ones(dim))
+        if config.get('pair_residue_interaction'):
+            self.pair_residue_interaction = SharedPairResidueInteraction(
+                dim, config['pair_residue_interaction'], self.CLASSES)
+        for task in config.get('token_logmeanexp_heads', []):
+            assert task in self.CLASSES and task not in self.PAIR
+            assert task not in config.get('sequence_windows', [])
+            self.heads[task] = TokenLogMeanExpHead(dim, self.CLASSES[task])
+        if config.get('ss_chain_decoder', False):
+            self.ss_chain_decoder = SSChainDecoder()
+        if config.get('shared_summary_residual'):
+            settings = config['shared_summary_residual']
+            tasks = settings['tasks']
+            assert all(task in config.get('summary_readouts', []) and
+                       isinstance(self.heads[task], NormalizedLinear) for task in tasks)
+            self.summary_residual = SharedSummaryResidual(7*dim, settings['hidden'], settings['dropout'],
+                                                          {task: self.CLASSES[task] for task in tasks})
+
+        if config.get('dual_summary'):
+            settings = config['dual_summary']
+            tasks = settings['tasks']
+            assert tasks and len(tasks) == len(set(tasks))
+            assert config.get('pooling') == 'rich'
+            assert all(task in config.get('summary_readouts', []) and task not in self.PAIR for task in tasks)
+            assert all(task not in config.get(key, {}) for task in tasks for key in
+                       ['cosine_heads', 'nonlinear_summary_heads', 'ss_summary_readouts',
+                        'sequence_conv_readouts', 'terminal_summary_readouts', 'token_logmeanexp_heads',
+                        'summary_residual_tasks', 'sequence_composition_readouts'])
+            self.auxiliary_summary_encoder = esm2.Encoder(settings['layers'], settings['dim'], settings['heads'])
+            self.auxiliary_summary_index = {task: i for i, task in enumerate(tasks)}
+            self.auxiliary_pool_query = nn.Parameter(torch.randn(len(tasks), 2, settings['dim']) * .02)
+            self.auxiliary_pool_position = nn.Parameter(torch.zeros(len(tasks), 2, 4))
+            for task in tasks:
+                self.heads[task] = NormalizedLinear(7*(dim+settings['dim']), self.CLASSES[task])
+
+        if config.get('shared_fusion'):
+            settings = config['shared_fusion']
+            dual = config['dual_summary']
+            assert not settings.get('conditioned', True)
+            assert all(settings[k] == dual[k] for k in ['layers', 'dim', 'heads'])
+            active = config['shared_fusion_tasks']
+            assert active and not set(active).intersection(dual['tasks'])
+            # One auxiliary module supplies both uses; never register a duplicate alias.
+            width = dim + settings['dim']
+            self.shared_fusion = nn.Sequential(nn.LayerNorm(width), nn.Linear(width, settings['hidden']),
+                                              nn.GELU(), nn.Linear(settings['hidden'], dim))
+            nn.init.normal_(self.shared_fusion[1].weight, std=.02)
+            nn.init.zeros_(self.shared_fusion[1].bias)
+            nn.init.zeros_(self.shared_fusion[3].weight)
+            nn.init.zeros_(self.shared_fusion[3].bias)
+
+    def pair_representation(self, task, first, second, base):
+        if task in self.config.get('pair_bilinear_tasks', []):
+            return {'base': base, 'chain_a': first, 'chain_b': second}
+        return base
+
+    def apply_head(self, task, representation):
+        if task in self.config.get('summary_residual_tasks', []):
+            head = self.heads[task]
+            normalized = (representation-head.mean)/head.scale
+            return head(representation) + self.summary_residual(task, normalized)
+        if isinstance(representation, dict) and 'residue_a' in representation:
+            base = {k:v for k,v in representation.items() if k not in ['residue_a', 'residue_b']}
+            original = self.apply_head(task, base if 'chain_a' in base else base['base'])
+            return original + self.pair_residue_interaction(task, representation['residue_a'], representation['residue_b'])
+        if isinstance(representation, dict) and 'chain_a' in representation:
+            first = (representation['chain_a'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            second = (representation['chain_b'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            interaction = self.pair_bilinear_projection(first) * self.pair_bilinear_projection(second)
+            interaction = interaction / math.sqrt(self.config['pair_bilinear_rank'])
+            return self.heads[task](representation['base']) + self.pair_bilinear_heads[task](interaction)
+        return self.heads[task](representation)
+
+    def encode_residues(self, tokens, task):
+        condition = None
+        if self.config.get('task_conditioning', False):
+            ti = 10 if task == 'secondary_structure' else self.task_index[task]
+            condition = self.task_condition[ti]
+        hidden, padding = self.encoder(tokens, condition=condition, depth=self.config.get('task_encoder_layers',{}).get(task),
+                                       extension_depth=self.config.get('task_extension_depths',{}).get(task))
+        if self.config.get('shared_fusion') and task in self.config['shared_fusion_tasks']:
+            auxiliary, auxiliary_padding = self.auxiliary_summary_encoder(tokens)
+            if not self.config['shared_fusion'].get('auxiliary_input', True):
+                auxiliary = torch.zeros_like(auxiliary)
+            correction = self.shared_fusion(torch.cat([hidden, auxiliary], -1))
+            hidden = (hidden + correction).masked_fill(padding.unsqueeze(-1), 0)
+        return hidden, padding
+
+    def pool(self, tokens, task):
+        hidden, pad_mask = self.encode_residues(tokens, task)
+        primary = self.summarize(hidden, tokens, pad_mask, task)
+        if task in self.config.get('dual_summary', {}).get('tasks', []):
+            auxiliary, auxiliary_mask = self.auxiliary_summary_encoder(tokens)
+            secondary = self.auxiliary_summarize(auxiliary, tokens, auxiliary_mask, task)
+            return torch.cat([primary, secondary], dim=-1)
+        return primary
+
+    def summarize(self, hidden, tokens, pad_mask, task):
+        valid = (~pad_mask).unsqueeze(-1)
+        mean = (hidden * valid).sum(1) / valid.sum(1).clamp_min(1)
+        if self.config.get('pooling', 'mean') == 'mean':
+            return mean
+        residues = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+        # Empty/nonstandard-only inputs still produce a finite representation.
+        residues[:, 0] |= ~residues.any(1)
+        keep = residues.unsqueeze(-1)
+        count = keep.sum(1).clamp_min(1)
+        center = (hidden * keep).sum(1) / count
+        position = residues.cumsum(1).to(hidden.dtype) / count.to(hidden.dtype)
+        basis = torch.stack([position, position.square(), torch.sin(position * math.pi),
+                             torch.cos(position * math.pi)], dim=-1)
+        ti = self.task_index[task]
+        scores = torch.einsum('bld,qd->blq', hidden, self.pool_query[ti]) / math.sqrt(hidden.shape[-1])
+        scores = scores + torch.einsum('blp,qp->blq', basis, self.pool_position[ti])
+        scores = scores.masked_fill(~residues.unsqueeze(-1), -1e4)
+        attention = torch.einsum('blq,bld->bqd', scores.softmax(1), hidden)
+        variance = ((hidden - center[:, None]).float().square() * keep).sum(1) / count
+        deviation = (variance + 1e-5).sqrt().to(hidden.dtype)
+        maximum = hidden.masked_fill(~keep, -1e4).amax(1) - center
+        first = residues & (residues.cumsum(1) <= 32)
+        last = residues & ((residues.sum(1, keepdim=True) - residues.cumsum(1)) < 32)
+        prefix = (hidden * first.unsqueeze(-1)).sum(1) / first.sum(1, keepdim=True).clamp_min(1) - center
+        suffix = (hidden * last.unsqueeze(-1)).sum(1) / last.sum(1, keepdim=True).clamp_min(1) - center
+        summary = torch.cat([attention[:, 0] - center, attention[:, 1] - center,
+                             deviation, maximum, prefix, suffix], dim=-1)
+        if task in self.config.get('summary_readouts', []):
+            return torch.cat([mean, summary], dim=-1)
+        if task in self.config.get('pair_summary_readouts', []):
+            return torch.cat([mean + self.pool_fuse(summary), mean, summary], dim=-1)
+        return mean + self.pool_fuse(summary)
+
+    def auxiliary_summarize(self, hidden, tokens, pad_mask, task):
+        valid = (~pad_mask).unsqueeze(-1)
+        mean = (hidden * valid).sum(1) / valid.sum(1).clamp_min(1)
+        if self.config.get('pooling', 'mean') == 'mean':
+            return mean
+        residues = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+        # Empty/nonstandard-only inputs still produce a finite representation.
+        residues[:, 0] |= ~residues.any(1)
+        keep = residues.unsqueeze(-1)
+        count = keep.sum(1).clamp_min(1)
+        center = (hidden * keep).sum(1) / count
+        position = residues.cumsum(1).to(hidden.dtype) / count.to(hidden.dtype)
+        basis = torch.stack([position, position.square(), torch.sin(position * math.pi),
+                             torch.cos(position * math.pi)], dim=-1)
+        ti = self.auxiliary_summary_index[task]
+        scores = torch.einsum('bld,qd->blq', hidden, self.auxiliary_pool_query[ti]) / math.sqrt(hidden.shape[-1])
+        scores = scores + torch.einsum('blp,qp->blq', basis, self.auxiliary_pool_position[ti])
+        scores = scores.masked_fill(~residues.unsqueeze(-1), -1e4)
+        attention = torch.einsum('blq,bld->bqd', scores.softmax(1), hidden)
+        variance = ((hidden - center[:, None]).float().square() * keep).sum(1) / count
+        deviation = (variance + 1e-5).sqrt().to(hidden.dtype)
+        maximum = hidden.masked_fill(~keep, -1e4).amax(1) - center
+        first = residues & (residues.cumsum(1) <= 32)
+        last = residues & ((residues.sum(1, keepdim=True) - residues.cumsum(1)) < 32)
+        prefix = (hidden * first.unsqueeze(-1)).sum(1) / first.sum(1, keepdim=True).clamp_min(1) - center
+        suffix = (hidden * last.unsqueeze(-1)).sum(1) / last.sum(1, keepdim=True).clamp_min(1) - center
+        summary = torch.cat([attention[:, 0] - center, attention[:, 1] - center,
+                             deviation, maximum, prefix, suffix], dim=-1)
+        return torch.cat([mean, summary], dim=-1)
+
+    def pool_sequences(self, sequences, task, device, max_len):
+        if self.training and not self.config.get('window_pooling_training', True):
+            tokens=esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device)
+            return self.pool(tokens,task)
+        if task not in self.config.get('sequence_windows', []) or not any(len(s)>max_len-2 for s in sequences):
+            return self.pool(esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device),task)
+        results=[None]*len(sequences)
+        short=[i for i,s in enumerate(sequences) if len(s)<=max_len-2]
+        if short:
+            pooled=self.pool(esm2.pad_batch([esm2.encode(sequences[i],max_len) for i in short],device),task)
+            for j,index in enumerate(short):results[index]=pooled[j]
+        width=max_len-2;stride=min(768,width)
+        if self.training and self.config.get('batch_window_training',False):
+            pieces=[];starts_by_index={};encoded={}
+            for index,sequence in enumerate(sequences):
+                if len(sequence)<=width:continue
+                starts=list(range(0,len(sequence)-width+1,stride))
+                if starts[-1]!=len(sequence)-width:starts.append(len(sequence)-width)
+                starts_by_index[index]=starts
+                pieces.extend((index,start) for start in starts)
+            count=max(1,16384//max_len)
+            for begin in range(0,len(pieces),count):
+                part=pieces[begin:begin+count]
+                tokens=esm2.pad_batch([esm2.encode(sequences[i][s:s+width],max_len) for i,s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,key in enumerate(part):encoded[key]=hidden[j]
+            positions=torch.arange(width,device=device)
+            weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+            for index,starts in starts_by_index.items():
+                sequence=sequences[index];length=len(sequence)
+                total=torch.zeros(length,self.config['dim'],device=device);counts=torch.zeros(length,1,device=device)
+                for start in starts:
+                    total.index_add_(0,positions+start,encoded[index,start][1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+                assembled=torch.cat([encoded[index,starts[0]][0:1],total/counts.clamp_min(1),encoded[index,starts[-1]][width+1:width+2]],dim=0)[None]
+                tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+                results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+            return torch.stack(results)
+        for index,sequence in enumerate(sequences):
+            length=len(sequence)
+            if length<=width:continue
+            starts=list(range(0,length-width+1,stride))
+            if starts[-1]!=length-width:starts.append(length-width)
+            total=torch.zeros(length,self.config['dim'],device=device)
+            counts=torch.zeros(length,1,device=device)
+            first=last=None
+            for begin in range(0,len(starts),max(1,16384//max_len)):
+                part=starts[begin:begin+max(1,16384//max_len)]
+                tokens=esm2.pad_batch([esm2.encode(sequence[s:s+width],max_len) for s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,start in enumerate(part):
+                    if start==0:first=hidden[j,0:1]
+                    if start==starts[-1]:last=hidden[j,width+1:width+2]
+                    positions=torch.arange(width,device=device)
+                    weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+                    total.index_add_(0,positions+start,hidden[j,1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+            assembled=torch.cat([first,total/counts.clamp_min(1),last],dim=0)[None]
+            tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+            results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+        return torch.stack(results)
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.config.get('sequence_composition_readouts', []):
+            from sequence_composition import composition_features
+            sequences=[item['sequence'] for item in batch]
+            pooled=self.pool_sequences(sequences,task,device,max_len)
+            return torch.cat([pooled.float(),composition_features(sequences,device)],-1)
+        if task in self.config.get('token_logmeanexp_heads', []):
+            tokens = esm2.pad_batch([esm2.encode(row['sequence'], max_len) for row in batch], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            valid = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+            valid[:, 0] |= ~valid.any(1)
+            return {'hidden':hidden, 'valid':valid}
+        if task in self.config.get('terminal_summary_readouts', {}):
+            return self.terminal_summary_features(task, [item['sequence'] for item in batch], device, max_len)
+        if task in self.config.get('ss_summary_readouts', []):
+            sequences=[x['sequence'] for x in batch]
+            summary=self.pool_sequences(sequences,task,device,max_len)
+            structure=self.secondary_structure_summary(sequences,device,max_len)
+            return torch.cat([summary.float(),structure],-1)
+        if task in self.config.get('sequence_conv_readouts',{}):
+            tokens=esm2.pad_batch([esm2.encode(x['sequence'],max_len) for x in batch],device)
+            hidden,pad_mask=self.encode_residues(tokens,task)
+            lengths=torch.tensor([min(len(x['sequence']),max_len-2) for x in batch],device=device)
+            width=max(1,int(lengths.max()))
+            valid=torch.arange(width,device=device)[None,:]<lengths[:,None]
+            return {'hidden':hidden[:,1:1+width], 'valid':valid,
+                    'summary':self.summarize(hidden,tokens,pad_mask,task)}
+        if task in self.config.get('residue_readouts', {}):
+            bins = self.config['residue_readouts'][task]['bins']
+            sequences = [x['sequence'] for x in batch]
+            tokens = esm2.pad_batch([esm2.encode(s, max_len) for s in sequences], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            return self.position_features(hidden, [min(len(s), max_len-2) for s in sequences], bins)
+        if task in self.PAIR:
+            a = self.pool_sequences([x['sequence_a'] for x in batch],task,device,max_len)
+            b = self.pool_sequences([x['sequence_b'] for x in batch],task,device,max_len)
+            if task in self.config.get('expanded_pair_readouts', []):
+                if task in self.config.get('symmetric_pair_readouts',[]):
+                    features=torch.cat([(a.float()+b.float())*.5,a*b,(a-b).abs()],dim=-1)
+                else:
+                    features=torch.cat([a,b,a*b,(a-b).abs()],dim=-1)
+                base = F.dropout(features,p=self.config.get('pair_dropout',0.),training=self.training)
+                return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+            output = torch.cat([a, b], dim=-1)
+            if self.config.get('pair_interaction', False):
+                output = output + self.pair_fuse(torch.cat([a * b, (a - b).abs()], dim=-1))
+            base = F.dropout(output, p=self.config.get('pair_dropout', 0.0), training=self.training)
+            return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+        return self.pool_sequences([x['sequence'] for x in batch],task,device,max_len)
+
+    def add_pair_residues(self, task, batch, device, max_len, base):
+        if task not in self.config.get('pair_residue_tasks', []):
+            return base
+        result = dict(base) if isinstance(base, dict) else {'base': base}
+        bins = self.config['pair_residue_interaction']['bins']
+        for role, name in [('a', 'sequence_a'), ('b', 'sequence_b')]:
+            result['residue_'+role] = self.pool_residue_bins(
+                [row[name] for row in batch], task, device, max_len, bins)
+        return result
+
+    def pool_residue_bins(self, sequences, task, device, max_len, bins):
+        """Average every residue into fixed relative bins, with full-chain context."""
+        width = max_len-2
+        assert width > 0 and bins > 0
+        output = [None]*len(sequences)
+        short = [i for i, sequence in enumerate(sequences) if len(sequence) <= width]
+        if short:
+            tokens = esm2.pad_batch([esm2.encode(sequences[i], max_len) for i in short], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            for j, index in enumerate(short):
+                length = len(sequences[index])
+                values = hidden[j, 1:1+length].float()
+                output[index] = (F.adaptive_avg_pool1d(values.T[None], bins)[0].T if length
+                                 else torch.zeros(bins, self.config['dim'], device=device))
+        for index, sequence in enumerate(sequences):
+            if len(sequence) <= width:
+                continue
+            starts = list(range(0, len(sequence)-width+1, min(768, width)))
+            if starts[-1] != len(sequence)-width:
+                starts.append(len(sequence)-width)
+            total = torch.zeros(len(sequence), self.config['dim'], device=device)
+            count = torch.zeros(len(sequence), 1, device=device)
+            position = torch.arange(width, device=device)
+            weight = torch.minimum(torch.minimum(position+1, width-position),
+                                   torch.full_like(position, 128)).float()[:, None]
+            for begin in range(0, len(starts), max(1, 16384//max_len)):
+                part = starts[begin:begin+max(1, 16384//max_len)]
+                tokens = esm2.pad_batch([esm2.encode(sequence[s:s+width], max_len) for s in part], device)
+                hidden, _ = self.encode_residues(tokens, task)
+                for j, start in enumerate(part):
+                    total.index_add_(0, position+start, hidden[j, 1:1+width].float()*weight)
+                    count.index_add_(0, position+start, weight)
+            values = total/count.clamp_min(1)
+            output[index] = F.adaptive_avg_pool1d(values.T[None], bins)[0].T
+        return torch.stack(output)
+
+    @staticmethod
+    def terminal_bins(states, width, bins, align_end=False):
+        """Fixed absolute residue bins; exclude padding from partial-bin means."""
+        assert width > 0 and bins > 0 and width % bins == 0
+        states = (states[-width:] if align_end else states[:width]).float()
+        count = states.shape[0]
+        padded = states.new_zeros(width, states.shape[-1])
+        valid = states.new_zeros(width)
+        offset = width-count if align_end else 0
+        padded[offset:offset+count] = states
+        valid[offset:offset+count] = 1
+        total = padded.reshape(bins, width//bins, -1).sum(1)
+        denominator = valid.reshape(bins, width//bins).sum(1).clamp_min(1)[:, None]
+        return (total/denominator).flatten()
+
+    def terminal_summary_features(self, task, sequences, device, max_len):
+        settings = self.config['terminal_summary_readouts'][task]
+        width = max_len-2
+        assert width >= max(settings['prefix_residues'], settings['suffix_residues'])
+        tokens = esm2.pad_batch([esm2.encode(sequence, max_len) for sequence in sequences], device)
+        hidden, padding = self.encode_residues(tokens, task)
+        summary = self.summarize(hidden, tokens, padding, task)
+        long_ids = [index for index, sequence in enumerate(sequences) if len(sequence) > width]
+        tails = {}
+        if long_ids:
+            tail_tokens = esm2.pad_batch([esm2.encode(sequences[index][-width:], max_len)
+                                         for index in long_ids], device)
+            tail_hidden, _ = self.encode_residues(tail_tokens, task)
+            tails = {index: tail_hidden[local, 1:width+1] for local, index in enumerate(long_ids)}
+        terminals = []
+        for index, sequence in enumerate(sequences):
+            prefix = hidden[index, 1:1+min(len(sequence), width)]
+            suffix = tails.get(index, prefix)
+            terminals.append(torch.cat([
+                self.terminal_bins(prefix, settings['prefix_residues'], settings['bins']),
+                self.terminal_bins(suffix, settings['suffix_residues'], settings['bins'], align_end=True)]))
+        return torch.cat([summary.float(), torch.stack(terminals)], dim=-1)
+
+    @staticmethod
+    def position_features(hidden, lengths, bins):
+        features = []
+        for index, length in enumerate(lengths):
+            if length:
+                states = hidden[index:index+1, 1:1+length].float().transpose(1, 2)
+                features.append(F.interpolate(states, size=bins, mode='linear', align_corners=True).flatten())
+            else:
+                features.append(hidden.new_zeros(hidden.shape[-1] * bins).float())
+        return torch.stack(features)
+
+    def secondary_structure_summary(self, sequences, device, max_len):
+        tokens=esm2.pad_batch([esm2.encode(sequence,max_len) for sequence in sequences],device)
+        hidden,_=self.encode_residues(tokens,'secondary_structure')
+        with torch.autocast(device_type=device.type,enabled=False):
+            probabilities=self.heads['secondary_structure'](hidden.float()).softmax(-1)
+        summaries=[]
+        for index,sequence in enumerate(sequences):
+            length=min(len(sequence),max_len-2)
+            if not length:
+                summaries.append(probabilities.new_zeros(40));continue
+            value=probabilities[index,1:1+length]
+            mean=value.mean(0);std=value.std(0,unbiased=False)
+            transition=(value[:-1,:,None]*value[1:,None,:]).mean(0).flatten() if length>1 else value.new_zeros(9)
+            positions=F.adaptive_avg_pool1d(value.T[None],8).flatten()
+            summaries.append(torch.cat([mean,std,transition,positions,value.new_tensor([math.log1p(length)])]))
+        return torch.stack(summaries)
+
+    def normalize(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return (values - stats['mean']) / stats['std'] if stats else values
+
+    def unscale(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return values * stats['std'] + stats['mean'] if stats else values
+
+    def transfer(self, state, normalized_source=False):
+        """Transfer our own lineage only; retain random init for new parameters."""
+        current = self.state_dict()
+        fitting = {k: v for k, v in state.items() if k in current and v.shape == current[k].shape}
+        missing, unexpected = self.load_state_dict(fitting, strict=False)
+        if not normalized_source:
+            with torch.no_grad():
+                for task, stats in self.config.get('regression_stats', {}).items():
+                    # Preserve predictions when moving a trained head to standardized units.
+                    if f'heads.{task}.3.weight' in fitting:
+                        self.heads[task][3].weight.div_(stats['std'])
+                        self.heads[task][3].bias.sub_(stats['mean']).div_(stats['std'])
+        return {'transferred': len(fitting), 'new_tensors': missing, 'unexpected': unexpected}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S057/PUBLISHED.json

@@ -0,0 +1,5 @@
+{
+  "source": "/run-state/workspace/research/production-dual-residue-ss1/candidate/package",
+  "files": 9,
+  "bytes": 561974415
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S057/README.md

@@ -0,0 +1,53 @@
+# Unified PEER protein model
+
+Exact total: **139,328,153 parameters** in one state dictionary. The same jointly
+learned 12-layer, width-512, 8-head primary transformer supplies all eleven
+tasks; its original **37,845,535 parameters** remain common to every task.
+Two shared extension blocks serve beta-lactamase and stability. One 12-layer,
+width-768, 12-head auxiliary encoder supplies subcellular summaries and SS
+residue features. It was also jointly trained on all eleven tasks here and is
+stored once.
+
+SS concatenates frozen local convolution/MLP features from the primary and
+auxiliary residues, followed by one fit-normalized 1280-to-3 linear readout.
+Subcellular retains the accepted combined seven-summary head. Remaining heads
+retain their existing paths: rank-target position readouts for fluorescence
+and beta-lactamase; summary heads for fold/solubility/binary localization;
+the stability MLP; and paired summary heads with retained shared interaction
+modules for PPI. Binary retains its shared summary residual. The SS local
+prefixes remain fixed; the previous optional SS residue-fusion map is absent.
+
+Every parameter originated from random initialization and training in this
+session. The primary received one hour of mounted UniRef50 MLM followed by
+joint fit supervision, conditioning and extension training. The auxiliary
+received eight hours of MLM (10,254,509,402 token presentations) and 8,486 joint
+fit updates. The primary SS prefix includes earlier own-teacher distillation.
+No external weights, embeddings or data were used.
+
+The new head compares three same-width primary-only, auxiliary-only and full
+readouts on the same fixed 500,000 valid fit residues, including each native
+overlapping-window view. Fixed seed 20270212, ridge 0.01, fit mean/std, FP32
+LBFGS, and 12 blocks of at most 10 iterations are used. Only final endpoints
+were eligible. All three CUDA interrupted/resumed checks passed. Native source
+feature caches reproduce valid Tune argmax exactly and are absent here.
+
+Native SS accuracy is 0.7674307948 versus 0.7596380880 for the previous fusion
+reference and 0.7654377293 for the matched auxiliary-only control. The paired
+protein 95% improvement intervals are [0.00698,0.00868] and [0.00139,0.00262].
+Primary-feature removal reduces accuracy to 0.7548798684; auxiliary removal
+gives 0.6333926465. Complete consolidated native replay and every readout/dependence gate passed.
+The fit-only development mean is **0.7221453205**. Ten other production
+prediction files are byte-identical to the previous package; SS matches the
+accepted development candidate exactly. Both encoders remain shared, with
+one auxiliary copy and one trained SS readout.
+
+The five existing production fit+Tune heads (fold, fluorescence, beta-lactamase, affinity and stability) and their feature paths remain exact. Their production Tune scores and aggregate are in-sample and excluded from selection.
+
+Repeated Tune selection and protein-family dependence limit the intervals.
+Fold remains weak, PPI validation sets are small, and feature ablation is an
+out-of-distribution diagnostic. SS and PPI use full-chain windows; remaining
+tasks retain a 1022-residue prefix. Rank outputs lack absolute calibration.
+No held-out test measurement is available.
+
+Run `bash infer.sh INPUT_ROOT OUTPUT_ROOT` offline. No live trainer, cached
+features, sequence lookup, external weights or test-time fitting are needed.

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S057/config.json

@@ -0,0 +1,146 @@
+{
+  "layers": 12,
+  "dim": 512,
+  "heads": 8,
+  "pooling": "rich",
+  "pair_interaction": true,
+  "ss_context": true,
+  "max_len": 1024,
+  "pair_dropout": 0.0,
+  "architecture": "unified",
+  "full_ss": true,
+  "regression_stats": {
+    "fluorescence": {
+      "mean": 3.180586883940159,
+      "std": 0.8339910288860748
+    },
+    "stability": {
+      "mean": 0.1790524860555312,
+      "std": 0.5662245232305059
+    },
+    "beta_lactamase": {
+      "mean": 0.7383112351980983,
+      "std": 0.31642946622284734
+    },
+    "ppi_affinity": {
+      "mean": -11.654589870742203,
+      "std": 3.0832061340498944
+    }
+  },
+  "residue_readouts": {
+    "fluorescence": {
+      "bins": 256
+    },
+    "beta_lactamase": {
+      "bins": 320
+    }
+  },
+  "fp32_heads": [
+    "beta_lactamase",
+    "binary_localization",
+    "fluorescence",
+    "fold",
+    "human_ppi",
+    "ppi_affinity",
+    "secondary_structure",
+    "solubility",
+    "stability",
+    "subcellular_localization",
+    "yeast_ppi"
+  ],
+  "ss_linear_context": 0,
+  "ss_calibrated": true,
+  "linear_heads": [],
+  "summary_readouts": [
+    "solubility",
+    "subcellular_localization",
+    "binary_localization",
+    "fold"
+  ],
+  "cosine_heads": {},
+  "nonlinear_summary_heads": {},
+  "calibrated_heads": [
+    "stability"
+  ],
+  "sequence_windows": [
+    "yeast_ppi",
+    "human_ppi"
+  ],
+  "expanded_pair_readouts": [
+    "yeast_ppi",
+    "human_ppi",
+    "ppi_affinity"
+  ],
+  "symmetric_pair_readouts": [
+    "yeast_ppi",
+    "ppi_affinity"
+  ],
+  "task_encoder_layers": {},
+  "task_conditioning": true,
+  "pair_summary_readouts": [],
+  "extension_layers": 2,
+  "window_pooling_training": true,
+  "batch_window_training": true,
+  "class_weight_power": {
+    "fold": 0.5
+  },
+  "task_extension_depths": {
+    "beta_lactamase": 2,
+    "binary_localization": 0,
+    "fluorescence": 0,
+    "fold": 0,
+    "human_ppi": 0,
+    "ppi_affinity": 0,
+    "secondary_structure": 0,
+    "solubility": 0,
+    "stability": 2,
+    "subcellular_localization": 0,
+    "yeast_ppi": 0
+  },
+  "task_max_len": {
+    "human_ppi": 1536
+  },
+  "pair_bilinear_rank": 32,
+  "pair_bilinear_tasks": [
+    "yeast_ppi"
+  ],
+  "pair_residue_interaction": {
+    "bins": 64,
+    "projection_dim": 32,
+    "pair_hidden": 32,
+    "pair_channels": 8,
+    "dropout": 0.1
+  },
+  "pair_residue_tasks": [
+    "yeast_ppi"
+  ],
+  "rank_target_tasks": [
+    "fluorescence",
+    "beta_lactamase"
+  ],
+  "ss_summary_readouts": [],
+  "terminal_summary_readouts": {},
+  "residue_lowrank_heads": {},
+  "shared_summary_residual": {
+    "tasks": [
+      "binary_localization"
+    ],
+    "hidden": 128,
+    "dropout": 0.2
+  },
+  "summary_residual_tasks": [
+    "binary_localization"
+  ],
+  "dual_summary": {
+    "layers": 12,
+    "dim": 768,
+    "heads": 12,
+    "tasks": [
+      "subcellular_localization"
+    ]
+  },
+  "dual_residue": {
+    "task": "secondary_structure",
+    "features": "two_frozen_local_prefixes"
+  }
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S057/esm2.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""An ESM-2 architecture, trained from scratch, as the reference baseline.
+
+Follows Lin et al. (Science 2023) / facebookresearch/esm in the ways that
+matter for a like-for-like architecture claim:
+
+  * rotary position embeddings, not learned positional embeddings -- this is
+    the defining architectural change from ESM-1b to ESM-2
+  * pre-LayerNorm blocks, GELU feed-forward at 4x expansion
+  * final LayerNorm before the LM head, and the LM head's projection weight
+    tied to the token embedding
+  * the ESM alphabet's special tokens (<cls>/<pad>/<eos>/<mask>) and the same
+    20 standard + rare amino-acid symbols
+
+The published size ladder is reproduced in CONFIGS so the baseline can be named
+by its ESM-2 counterpart rather than by an arbitrary width.
+"""
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ESM-2's alphabet, in its canonical order.
+SPECIALS = ["<cls>", "<pad>", "<eos>", "<unk>"]
+RESIDUES = list("LAGVSERTIDPKQNFYMHWCXBUZO")
+EXTRA = ["<null_1>", "<mask>"]
+ALPHABET = SPECIALS + RESIDUES + EXTRA
+TOKEN = {symbol: index for index, symbol in enumerate(ALPHABET)}
+CLS, PAD, EOS, UNK = TOKEN["<cls>"], TOKEN["<pad>"], TOKEN["<eos>"], TOKEN["<unk>"]
+MASK = TOKEN["<mask>"]
+VOCAB_SIZE = len(ALPHABET)
+FIRST_RESIDUE, LAST_RESIDUE = TOKEN["L"], TOKEN["O"]
+
+# name -> (layers, embed_dim, attention_heads), from the ESM-2 release table.
+CONFIGS = {
+    "esm2_t6_8M":    (6, 320, 20),
+    "esm2_t12_35M":  (12, 480, 20),
+    "esm2_t30_150M": (30, 640, 20),
+    "esm2_t33_650M": (33, 1280, 20),
+}
+
+
+def encode(sequence, max_len=1024):
+    body = [TOKEN.get(c, UNK) for c in sequence[:max_len - 2]]
+    return [CLS] + body + [EOS]
+
+
+def pad_batch(sequences, device):
+    width = max(len(s) for s in sequences)
+    out = torch.full((len(sequences), width), PAD, dtype=torch.long)
+    for row, ids in enumerate(sequences):
+        out[row, :len(ids)] = torch.tensor(ids, dtype=torch.long)
+    return out.to(device, non_blocking=True)
+
+
+class Rotary(nn.Module):
+    """Rotary position embedding, as ESM-2 applies it to q and k."""
+
+    def __init__(self, dim, base=10000):
+        super().__init__()
+        inverse = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inverse", inverse, persistent=False)
+        self._cached_length = 0
+
+    def _tables(self, length, device, dtype):
+        if length != self._cached_length or self._cos.device != device:
+            position = torch.arange(length, device=device, dtype=torch.float)
+            angles = torch.outer(position, self.inverse.to(device))
+            table = torch.cat([angles, angles], dim=-1)
+            self._cos = table.cos()[None, None]
+            self._sin = table.sin()[None, None]
+            self._cached_length = length
+        return self._cos.to(dtype), self._sin.to(dtype)
+
+    @staticmethod
+    def _rotate_half(x):
+        half = x.shape[-1] // 2
+        return torch.cat([-x[..., half:], x[..., :half]], dim=-1)
+
+    def forward(self, q, k):
+        cos, sin = self._tables(q.shape[-2], q.device, q.dtype)
+        return (q * cos + self._rotate_half(q) * sin,
+                k * cos + self._rotate_half(k) * sin)
+
+
+class Attention(nn.Module):
+    def __init__(self, dim, heads):
+        super().__init__()
+        self.heads = heads
+        self.head_dim = dim // heads
+        self.q = nn.Linear(dim, dim)
+        self.k = nn.Linear(dim, dim)
+        self.v = nn.Linear(dim, dim)
+        self.out = nn.Linear(dim, dim)
+        self.rotary = Rotary(self.head_dim)
+
+    def forward(self, x, pad_mask):
+        batch, length, _ = x.shape
+        shape = (batch, length, self.heads, self.head_dim)
+        q = self.q(x).view(shape).transpose(1, 2)
+        k = self.k(x).view(shape).transpose(1, 2)
+        v = self.v(x).view(shape).transpose(1, 2)
+        q, k = self.rotary(q, k)
+        attention_mask = None
+        if pad_mask is not None:
+            attention_mask = (~pad_mask)[:, None, None, :]
+        hidden = F.scaled_dot_product_attention(q, k, v, attn_mask=attention_mask)
+        hidden = hidden.transpose(1, 2).reshape(batch, length, -1)
+        return self.out(hidden)
+
+
+class Block(nn.Module):
+    def __init__(self, dim, heads, ffn):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim)
+        self.attention = Attention(dim, heads)
+        self.norm2 = nn.LayerNorm(dim)
+        self.ffn = nn.Sequential(nn.Linear(dim, ffn), nn.GELU(), nn.Linear(ffn, dim))
+
+    def forward(self, x, pad_mask, condition=None):
+        first = self.norm1(x)
+        if condition is not None:
+            first = first * (1 + condition[0]) + condition[1]
+        x = x + self.attention(first, pad_mask)
+        second = self.norm2(x)
+        if condition is not None:
+            second = second * (1 + condition[2]) + condition[3]
+        return x + self.ffn(second)
+
+
+class Encoder(nn.Module):
+    """The shared backbone. Every task reads from this one parameter set."""
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.dim = dim
+        self.embed = nn.Embedding(VOCAB_SIZE, dim, padding_idx=PAD)
+        self.blocks = nn.ModuleList([Block(dim, heads, dim * 4) for _ in range(layers)])
+        self.norm = nn.LayerNorm(dim)
+        self.lm_bias = nn.Parameter(torch.zeros(VOCAB_SIZE))
+        self.apply(self._init)
+
+    @staticmethod
+    def _init(module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, std=0.02)
+
+    def add_extension(self, layers, heads, before_norm=False):
+        """Append shared residual blocks after the original normalized representation."""
+        assert layers > 0 and not hasattr(self, 'extension')
+        self.extension_before_norm = bool(before_norm)
+        self.extension = nn.ModuleList([Block(self.dim, heads, 4*self.dim) for _ in range(layers)])
+        self.extension.apply(self._init)
+        # Identity at initialization preserves every existing readout exactly.
+        for block in self.extension:
+            nn.init.zeros_(block.attention.out.weight)
+            nn.init.zeros_(block.attention.out.bias)
+            nn.init.zeros_(block.ffn[2].weight)
+            nn.init.zeros_(block.ffn[2].bias)
+
+    def forward(self, tokens, condition=None, depth=None, extension_depth=None):
+        pad_mask = tokens.eq(PAD)
+        hidden = self.embed(tokens)
+        depth=len(self.blocks) if depth is None else int(depth)
+        if not 1<=depth<=len(self.blocks):
+            raise ValueError(f'Encoder depth {depth} is outside 1..{len(self.blocks)}')
+        for index, block in enumerate(self.blocks):
+            if index>=depth:
+                break
+            hidden = block(hidden, pad_mask, condition[index] if condition is not None else None)
+        # Local residue heads must not observe artificial states at padded
+        # positions; otherwise predictions near the C terminus depend on which
+        # other sequences share the batch. Valid transformer states are unchanged.
+        before_norm = getattr(self, 'extension_before_norm', False)
+        if not before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        extension = getattr(self, 'extension', ())
+        extension_depth = len(extension) if extension_depth is None else int(extension_depth)
+        if not 0 <= extension_depth <= len(extension):
+            raise ValueError(f'Extension depth {extension_depth} is outside 0..{len(extension)}')
+        for index, block in enumerate(extension):
+            if index >= extension_depth:
+                break
+            hidden = block(hidden, pad_mask).masked_fill(pad_mask.unsqueeze(-1), 0)
+        if before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        return hidden, pad_mask
+
+    def lm_logits(self, hidden):
+        # Weight tying, as in ESM-2's RobertaLMHead.
+        return F.linear(hidden, self.embed.weight) + self.lm_bias
+
+    def pool(self, tokens):
+        hidden, pad_mask = self.forward(tokens)
+        keep = (~pad_mask).to(hidden.dtype).unsqueeze(-1)
+        return (hidden * keep).sum(1) / keep.sum(1).clamp(min=1)
+
+
+class Model(nn.Module):
+    """ESM-2 backbone plus the eleven PEER task heads."""
+
+    CLASSES = {"solubility": 2, "subcellular_localization": 10,
+               "binary_localization": 2, "fold": 1195,
+               "yeast_ppi": 2, "human_ppi": 2}
+    REGRESSION = ("fluorescence", "stability", "beta_lactamase", "ppi_affinity")
+    PAIR = {"yeast_ppi", "human_ppi", "ppi_affinity"}
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.encoder = Encoder(layers=layers, dim=dim, heads=heads)
+        self.heads = nn.ModuleDict()
+        for task, n in self.CLASSES.items():
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, n))
+        for task in self.REGRESSION:
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 1))
+        self.heads["secondary_structure"] = nn.Sequential(
+            nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.PAIR:
+            a = self.encoder.pool(pad_batch(
+                [encode(x["sequence_a"], max_len) for x in batch], device))
+            b = self.encoder.pool(pad_batch(
+                [encode(x["sequence_b"], max_len) for x in batch], device))
+            return torch.cat([a, b], dim=-1)
+        return self.encoder.pool(pad_batch(
+            [encode(x["sequence"], max_len) for x in batch], device))
+
+
+def build(name="esm2_t12_35M"):
+    layers, dim, heads = CONFIGS[name]
+    model = Model(layers=layers, dim=dim, heads=heads)
+    return model, {"name": name, "layers": layers, "dim": dim, "heads": heads}
+
+
+if __name__ == "__main__":
+    for name in CONFIGS:
+        model, config = build(name)
+        backbone = sum(p.numel() for p in model.encoder.parameters())
+        total = sum(p.numel() for p in model.parameters())
+        print(f"{name:16s} backbone {backbone/1e6:7.2f}M   with heads {total/1e6:7.2f}M")

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S057/infer.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PYTHONDONTWRITEBYTECODE=1
+exec python3 "$(dirname "$0")/replay.py" "$1" "$2"

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S057/replay.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Self-contained replay shared by research evaluation and frozen packages."""
+import contextlib
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import torch
+
+import esm2
+
+TASKS = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+         'subcellular_localization', 'binary_localization', 'fold',
+         'secondary_structure', 'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+
+def autocast(device):
+    return torch.autocast('cuda', dtype=torch.bfloat16) if device.type == 'cuda' else contextlib.nullcontext()
+
+
+def head_output(model, task, representation, device, fp32=False):
+    apply = model.apply_head if hasattr(model, 'apply_head') else lambda task, value: model.heads[task](value)
+    if fp32:
+        with torch.autocast(device.type, enabled=False):
+            values={k:v.float() if v.is_floating_point() else v for k,v in representation.items()} if isinstance(representation,dict) else representation.float()
+            return apply(task, values).float()
+    return apply(task, representation).float()
+
+
+def residue_states(model, tokens, task):
+    return model.encode_residues(tokens, task) if hasattr(model, 'encode_residues') else model.encoder(tokens)
+
+
+def windows(length, width=1022, stride=768):
+    if length <= width:
+        return [(0, length)]
+    starts = list(range(0, length - width + 1, stride))
+    if starts[-1] != length - width:
+        starts.append(length - width)
+    return [(s, min(s + width, length)) for s in starts]
+
+
+def batches(rows, task, token_budget=16384, max_len=1024, max_batch=128):
+    lengths = [min(max(map(len, r['features'].values())) + 2, max_len) for r in rows]
+    order = sorted(range(len(rows)), key=lengths.__getitem__)
+    current, width = [], 0
+    for i in order:
+        length = lengths[i]
+        # Pair sequences require two separate passes, but the peak tensor size is unchanged.
+        if current and (max(width, length) * (len(current) + 1) > token_budget or len(current) >= max_batch):
+            yield current
+            current, width = [], 0
+        current.append(i)
+        width = max(width, length)
+    if current:
+        yield current
+
+
+@torch.inference_mode()
+def predict_records(model, rows, task, device, config=None, token_budget=16384):
+    config = config or {}
+    max_len = config.get('task_max_len', {}).get(task, config.get('max_len', 1024))
+    full_ss = config.get('full_ss', True)
+    fp32_option = config.get('fp32_heads', False)
+    fp32_heads = fp32_option is True or (isinstance(fp32_option, list) and task in fp32_option)
+    was_training = model.training
+    model.eval()
+    result = {}
+    for ids in batches(rows, task, token_budget, max_len):
+        chunk = [rows[i] for i in ids]
+        features = [r['features'] for r in chunk]
+        if task == 'secondary_structure':
+            if full_ss and any(len(f['sequence']) > max_len - 2 for f in features):
+                for record in chunk:
+                    seq = record['features']['sequence']
+                    pieces = windows(len(seq), max_len - 2, min(768, max_len - 2))
+                    total = np.zeros((len(seq), 3), dtype=np.float32)
+                    weight_sum = np.zeros((len(seq), 1), dtype=np.float32)
+                    for begin in range(0, len(pieces), max(1, token_budget // max_len)):
+                        part = pieces[begin:begin + max(1, token_budget // max_len)]
+                        tokens = esm2.pad_batch([esm2.encode(seq[s:e], max_len) for s, e in part], device)
+                        with autocast(device):
+                            hidden, _ = residue_states(model, tokens, task)
+                            logits = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                        for j, (s, e) in enumerate(part):
+                            size = e - s
+                            # Smooth boundaries, without discarding any residue.
+                            weight = np.minimum(np.arange(1, size + 1), np.arange(size, 0, -1))
+                            weight = np.minimum(weight, 128).astype(np.float32)[:, None]
+                            total[s:e] += logits[j, 1:1+size] * weight
+                            weight_sum[s:e] += weight
+                    scores = total / np.maximum(weight_sum, 1)
+                    result[record['example_id']] = {'ss3_scores': scores.tolist()}
+            else:
+                tokens = esm2.pad_batch([esm2.encode(f['sequence'], max_len) for f in features], device)
+                with autocast(device):
+                    hidden, _ = residue_states(model, tokens, task)
+                    probabilities = head_output(model, task, hidden, device, fp32_heads).softmax(-1).cpu().numpy()
+                for j, record in enumerate(chunk):
+                    length = len(record['features']['sequence'])
+                    used = min(length, max_len - 2)
+                    scores = probabilities[j, 1:1+used].tolist()
+                    scores.extend([[1.0, 1.0, 1.0] for _ in range(length-used)])
+                    result[record['example_id']] = {'ss3_scores': scores}
+            continue
+        with autocast(device):
+            representation = model.represent(task, features, device, max_len)
+            output = head_output(model, task, representation, device, fp32_heads)
+            if task in model.CLASSES:
+                output = output.softmax(-1)
+            if task in config.get('symmetric_pairs', []):
+                swapped = [{'sequence_a': f['sequence_b'], 'sequence_b': f['sequence_a']} for f in features]
+                swapped_rep = model.represent(task, swapped, device, max_len)
+                second = head_output(model, task, swapped_rep, device, fp32_heads)
+                if task in model.CLASSES:
+                    second = second.softmax(-1)
+                output = (output + second) * 0.5
+            if task in model.CLASSES:
+                output = output.clamp_min(1e-9)
+            elif hasattr(model, 'unscale'):
+                output = model.unscale(task, output)
+        values = output.cpu().tolist()
+        for record, value in zip(chunk, values):
+            result[record['example_id']] = {'scores': value} if task in model.CLASSES else {'value': value[0]}
+    if task == 'secondary_structure' and hasattr(model, 'ss_chain_decoder'):
+        # Decode complete chains only after all overlapping-window probabilities
+        # have been aggregated. No labels or parameter updates enter replay.
+        identifiers = [record['example_id'] for record in rows]
+        probabilities = [result[identifier]['ss3_scores'] for identifier in identifiers]
+        decoded = model.ss_chain_decoder.decode(probabilities)
+        for identifier, scores in zip(identifiers, decoded):
+            result[identifier] = {'ss3_scores': scores.tolist()}
+    model.train(was_training)
+    return result
+
+
+def load_model(package, device):
+    config = json.loads((package / 'config.json').read_text())
+    if config.get('architecture') == 'unified':
+        from unified import UnifiedModel
+        model = UnifiedModel(config)
+    else:
+        model = esm2.Model(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+    model.load_state_dict(torch.load(package / 'model.pt', map_location='cpu', weights_only=True))
+    return model.to(device).eval(), config
+
+
+def main():
+    if len(sys.argv) != 3:
+        raise SystemExit('usage: replay.py INPUT_ROOT OUTPUT_ROOT')
+    torch.set_num_threads(6)
+    source, destination = Path(sys.argv[1]), Path(sys.argv[2]) / 'predictions'
+    destination.mkdir(parents=True, exist_ok=True)
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model, config = load_model(Path(__file__).resolve().parent, device)
+    for task in TASKS:
+        rows = [json.loads(line) for line in (source / f'{task}.jsonl').open()]
+        predictions = predict_records(model, rows, task, device, config)
+        with (destination / f'{task}.jsonl').open('w') as sink:
+            for row in rows:
+                sink.write(json.dumps({'example_id': row['example_id'], 'prediction': predictions[row['example_id']]}, separators=(',', ':')) + '\n')
+
+
+if __name__ == '__main__':
+    main()

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S057/selection.json

@@ -0,0 +1,189 @@
+{
+  "score_kind": "tune_labels_used_for_fold_fluorescence_beta_lactamase_ppi_affinity_and_stability",
+  "tasks_reusing_tune_labels": [
+    "fold",
+    "fluorescence",
+    "beta_lactamase",
+    "ppi_affinity",
+    "stability"
+  ],
+  "production_aggregate_excluded_from_selection": true,
+  "fit_only_development_reference": {
+    "reward": 0.7221453204592783,
+    "tasks": {
+      "beta_lactamase": {
+        "invalid_reason": null,
+        "reward": 0.8851158090618965,
+        "spearman": 0.8851158090618965
+      },
+      "binary_localization": {
+        "accuracy": 0.9462116830537883,
+        "balanced_accuracy": 0.9419155998103367,
+        "invalid_reason": null,
+        "macro_f1": 0.9439947337349208,
+        "reward": 0.9462116830537883
+      },
+      "fluorescence": {
+        "invalid_reason": null,
+        "reward": 0.826705913429907,
+        "spearman": 0.826705913429907
+      },
+      "fold": {
+        "accuracy": 0.24864130434782608,
+        "balanced_accuracy": 0.16124022176653757,
+        "invalid_reason": null,
+        "macro_f1": 0.03846637235687955,
+        "reward": 0.24864130434782608
+      },
+      "human_ppi": {
+        "accuracy": 0.7968253968253968,
+        "balanced_accuracy": 0.8005952380952381,
+        "invalid_reason": null,
+        "macro_f1": 0.7968233491897122,
+        "reward": 0.7968253968253968
+      },
+      "ppi_affinity": {
+        "invalid_reason": null,
+        "reward": 0.5341420012716276,
+        "rmse": 1.9334586965956642,
+        "spearman": 0.7162121646852028
+      },
+      "secondary_structure": {
+        "accuracy": 0.7674307948381397,
+        "invalid_reason": null,
+        "reward": 0.7674307948381397,
+        "valid_residues": 556931
+      },
+      "solubility": {
+        "accuracy": 0.7533851915874388,
+        "balanced_accuracy": 0.7392508255204544,
+        "invalid_reason": null,
+        "macro_f1": 0.742264399722415,
+        "reward": 0.7533851915874388
+      },
+      "stability": {
+        "invalid_reason": null,
+        "reward": 0.7311607642876724,
+        "spearman": 0.7311607642876724
+      },
+      "subcellular_localization": {
+        "accuracy": 0.7908217716115261,
+        "balanced_accuracy": 0.6999121500389823,
+        "invalid_reason": null,
+        "macro_f1": 0.7198401417205603,
+        "reward": 0.7908217716115261
+      },
+      "yeast_ppi": {
+        "accuracy": 0.6631578947368421,
+        "balanced_accuracy": 0.6597985347985349,
+        "invalid_reason": null,
+        "macro_f1": 0.6567299006323397,
+        "reward": 0.6631578947368421
+      }
+    },
+    "package": "/workspace/research/dual-residue-readout1-replay/candidate/package",
+    "report": "/workspace/research/dual-residue-readout1-replay/candidate/report.json",
+    "model_sha256": "bd9bdcc7561bc61d64523b9e99cff98df05ddceebd211a740b07ee8b94abb18e",
+    "inference_assets_sha256": {
+      "model.pt": "bd9bdcc7561bc61d64523b9e99cff98df05ddceebd211a740b07ee8b94abb18e",
+      "config.json": "fa516bd8637412d039d46cc25ceeb318e8da206b892fae9a8fc84540dc68e943",
+      "esm2.py": "d4d512296047ebbd0f9a26dc1390107f72762cb5de011eefc9fecb18118a9be9",
+      "unified.py": "00753e674e1360601f204e445f15714cae02514bfe455d594a4d3f8433018dca",
+      "replay.py": "9c5add2d3fb117470241cf63f621e4797a16962cddadbaad6de2cfb481e7fa85",
+      "infer.sh": "60f55b73f5b39a35a61df84026abed9a127b1cc035d650c9e1ca62f54fc2b468"
+    },
+    "parameters": 139328153,
+    "score_kind": "fit_only_development_tune_selection",
+    "decision": "/workspace/research/dual-residue-readout1-replay/decision.json"
+  },
+  "pending_independent_replay": false,
+  "dual_residue_evidence": {
+    "status": "eligible_for_native_all11_review",
+    "eligible": true,
+    "results": {
+      "primary": {
+        "accuracy": 0.7436379012840011,
+        "blocks": 12,
+        "active_seconds": 0.7173126210400369,
+        "LBFGS_iterations": 76,
+        "closure_evaluations": 129
+      },
+      "auxiliary": {
+        "accuracy": 0.7654377292698736,
+        "blocks": 12,
+        "active_seconds": 0.5298353870166466,
+        "LBFGS_iterations": 98,
+        "closure_evaluations": 119
+      },
+      "full": {
+        "accuracy": 0.7674307948381397,
+        "blocks": 12,
+        "active_seconds": 0.5488360379531514,
+        "LBFGS_iterations": 107,
+        "closure_evaluations": 122,
+        "primary_zeroed_accuracy": 0.7548798684217614,
+        "auxiliary_zeroed_accuracy": 0.6333926464858304
+      }
+    },
+    "comparisons": {
+      "full_minus_primary": {
+        "delta": 0.023792893554138664,
+        "conditional95": [
+          0.02227601983558547,
+          0.025405620421006168
+        ]
+      },
+      "full_minus_auxiliary": {
+        "delta": 0.001993065568266087,
+        "conditional95": [
+          0.0013915113450666237,
+          0.00262078806389141
+        ]
+      },
+      "full_minus_primary_ablated": {
+        "delta": 0.01255092641637833,
+        "conditional95": [
+          0.01141412252412414,
+          0.01367599499083551
+        ]
+      },
+      "full_minus_auxiliary_ablated": {
+        "delta": 0.13403814835230934,
+        "conditional95": [
+          0.13069689870620071,
+          0.13760283893506345
+        ]
+      },
+      "full_minus_native_primary": {
+        "delta": 0.023299116048487157,
+        "conditional95": [
+          0.021785460201619564,
+          0.024879231525420348
+        ]
+      },
+      "full_minus_native_auxiliary": {
+        "delta": 0.002027181105020191,
+        "conditional95": [
+          0.0014295698320689104,
+          0.0026466899667084306
+        ]
+      },
+      "full_minus_native_fusion": {
+        "delta": 0.007792706816463799,
+        "conditional95": [
+          0.0069797076175643485,
+          0.00868359254180614
+        ]
+      }
+    },
+    "fit_unique_residues": 500000,
+    "fit_rows_including_overlap": 505584,
+    "tune_valid_residues": 556931,
+    "tune_proteins": 2170,
+    "published": false,
+    "exported": false,
+    "limitations": "One fixed fit-only recipe; repeated Tune selection and protein-family dependence are not corrected by conditional protein bootstrap. Feature removal is an out-of-distribution diagnostic. Native all11 review still required."
+  },
+  "all11_native_valid": true,
+  "all11_prediction_references_exact": true
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S057/unified.py

@@ -0,0 +1,746 @@
+"""One jointly learned protein encoder, shared pooling, and eleven small heads."""
+import math
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import esm2
+
+
+class NormalizedLinear(nn.Module):
+    def __init__(self, width, outputs=1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs)
+
+    def forward(self, values):
+        return self.linear((values - self.mean) / self.scale)
+
+
+class LowRankPositionHead(nn.Module):
+    """A shared residue projection followed by an ordered position readout."""
+    def __init__(self, dim, bins, rank, outputs=1):
+        super().__init__()
+        assert 0 < rank <= min(dim, bins)
+        self.dim = dim
+        self.project = nn.Linear(dim, rank, bias=False)
+        self.output = nn.Linear(bins * rank, outputs)
+
+    def forward(self, values):
+        residues = values.reshape(values.shape[0], -1, self.dim)
+        return self.output(self.project(residues).flatten(1))
+
+
+class NormalizedCosine(nn.Module):
+    def __init__(self, width, outputs, temperature=20.):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.linear = nn.Linear(width, outputs, bias=False)
+        self.temperature = temperature
+
+    def forward(self, values):
+        features = F.normalize((values-self.mean)/self.scale, dim=-1)
+        return F.linear(features, F.normalize(self.linear.weight, dim=-1))*self.temperature
+
+
+class NormalizedMLP(nn.Module):
+    def __init__(self, width, outputs, hidden=128, dropout=.1):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(width))
+        self.register_buffer('scale', torch.ones(width))
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(), nn.LayerNorm(hidden),
+                                     nn.Dropout(dropout), nn.Linear(hidden, outputs))
+
+    def forward(self, values):
+        return self.network((values-self.mean)/self.scale)
+
+
+class SharedSummaryResidual(nn.Module):
+    """One nonlinear summary map jointly used by several classification heads."""
+    def __init__(self, width, hidden, dropout, classes):
+        super().__init__()
+        self.network = nn.Sequential(nn.Linear(width, hidden), nn.GELU(),
+                                     nn.LayerNorm(hidden), nn.Dropout(dropout),
+                                     nn.Linear(hidden, hidden), nn.GELU(), nn.Dropout(dropout))
+        self.heads = nn.ModuleDict({task: nn.Linear(hidden, outputs)
+                                   for task, outputs in sorted(classes.items())})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, normalized_summary):
+        return self.heads[task](self.network(normalized_summary))
+
+
+class NormalizedResidueLinear(nn.Module):
+    def __init__(self, dim, kernel=9):
+        super().__init__()
+        assert kernel > 0 and kernel % 2 == 1
+        self.kernel = kernel
+        self.readout = NormalizedLinear(dim * kernel, 3)
+
+    @staticmethod
+    def features(hidden, kernel):
+        padded = F.pad(hidden.float().transpose(1, 2), (kernel // 2, kernel // 2))
+        return padded.unfold(-1, kernel, 1).transpose(1, 2).flatten(2)
+
+    def forward(self, hidden):
+        return self.readout(self.features(hidden, self.kernel))
+
+
+class LocalResidueHead(nn.Sequential):
+    """Preserve the original four head parameter names; add a local residual."""
+    def __init__(self, dim):
+        super().__init__(nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+        self.context = nn.Sequential(nn.Conv1d(dim, dim, 9, padding=4, groups=dim),
+                                     nn.GELU(), nn.Conv1d(dim, dim, 1))
+        nn.init.zeros_(self.context[-1].weight)
+        nn.init.zeros_(self.context[-1].bias)
+
+    def forward(self, x):
+        x = x + self.context(x.transpose(1, 2)).transpose(1, 2)
+        for i in range(4):
+            x = self[i](x)
+        return x
+
+
+class CalibratedLocalResidueHead(LocalResidueHead):
+    def __init__(self, dim):
+        super().__init__(dim)
+        self[3] = NormalizedLinear(dim, 3)
+
+
+class DualLocalResidueHead(nn.Module):
+    """Two frozen local feature prefixes followed by one joint residue readout."""
+    def __init__(self, primary_dim, auxiliary_dim):
+        super().__init__()
+        self.primary_dim = primary_dim
+        self.primary = CalibratedLocalResidueHead(primary_dim)
+        self.auxiliary = CalibratedLocalResidueHead(auxiliary_dim)
+        self.primary[3] = nn.Identity()
+        self.auxiliary[3] = nn.Identity()
+        self.readout = NormalizedLinear(primary_dim + auxiliary_dim, 3)
+
+    def features(self, hidden):
+        return torch.cat([self.primary(hidden[..., :self.primary_dim]),
+                          self.auxiliary(hidden[..., self.primary_dim:])], dim=-1)
+
+    def forward(self, hidden):
+        return self.readout(self.features(hidden))
+
+
+class ResidualSequenceConvHead(nn.Module):
+    """Learn local sequence motifs alongside the retained summary classifier."""
+    def __init__(self, dim, outputs, channels=128, dropout=.2, retain_summary=True):
+        super().__init__()
+        self.base = NormalizedLinear(7 * dim, outputs) if retain_summary else None
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, channels)
+        self.convs = nn.ModuleList([nn.Conv1d(channels, channels, k, padding=k//2) for k in (3,9)])
+        self.norms = nn.ModuleList([nn.LayerNorm(channels) for _ in self.convs])
+        self.output = nn.Linear(4 * channels, outputs)
+        nn.init.zeros_(self.output.weight);nn.init.zeros_(self.output.bias)
+        self.dropout = dropout
+
+    def forward(self, features):
+        valid = features['valid'].bool().unsqueeze(-1)
+        x = F.gelu(self.project((features['hidden']-self.mean)/self.scale)) * valid
+        summaries = []
+        for conv,norm in zip(self.convs,self.norms):
+            y = norm(F.gelu(conv(x.transpose(1,2)).transpose(1,2)))
+            center = (y*valid).sum(1)/valid.sum(1).clamp_min(1)
+            maximum = y.masked_fill(~valid,-1e4).amax(1)
+            maximum = torch.where(valid.any(1),maximum,torch.zeros_like(maximum))
+            summaries.extend([center,maximum])
+        pooled = F.dropout(torch.cat(summaries,dim=-1),self.dropout,self.training)
+        logits=self.output(pooled)
+        return self.base(features['summary']) + logits if self.base is not None else logits
+
+
+class TokenLogMeanExpHead(nn.Module):
+    """Class-specific local evidence, pooled without sequence-length bias."""
+    def __init__(self, dim, outputs):
+        super().__init__()
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.linear = nn.Linear(dim, outputs)
+
+    def forward(self, representation):
+        values, valid = representation['hidden'].float(), representation['valid']
+        logits = self.linear((values-self.mean)/self.scale)
+        logits = logits.masked_fill(~valid.unsqueeze(-1), -torch.inf)
+        return torch.logsumexp(logits, 1)-valid.sum(1).clamp_min(1).float().log()[:, None]
+
+    def packed(self, values, lengths):
+        """Equivalent unpadded computation for frozen-feature readout fitting."""
+        logits = self.linear((values.float()-self.mean)/self.scale)
+        # The stabilizing maximum cancels in the derivative; detach avoids
+        # retaining another large token-by-class gradient path.
+        maximum = torch.segment_reduce(logits.detach(), 'max', lengths=lengths)
+        index = torch.repeat_interleave(torch.arange(len(lengths), device=lengths.device), lengths,
+                                        output_size=len(values))
+        exponent = (logits-maximum[index]).exp()
+        total = torch.segment_reduce(exponent, 'sum', lengths=lengths)
+        return maximum+total.log()-lengths.float().log()[:, None]
+
+
+class SharedPairResidueInteraction(nn.Module):
+    """A shared nonlinear comparison of local states from both protein chains."""
+    def __init__(self, dim, settings, classes):
+        super().__init__()
+        width, hidden, channels = (settings[k] for k in ['projection_dim', 'pair_hidden', 'pair_channels'])
+        self.register_buffer('mean', torch.zeros(dim))
+        self.register_buffer('scale', torch.ones(dim))
+        self.project = nn.Linear(dim, width)
+        self.compare = nn.Sequential(nn.Linear(2*width, hidden), nn.GELU(),
+                                     nn.Linear(hidden, channels), nn.GELU())
+        self.dropout = settings['dropout']
+        self.heads = nn.ModuleDict({task: nn.Linear(2*channels, classes.get(task, 1))
+                                   for task in sorted(esm2.Model.PAIR)})
+        for head in self.heads.values():
+            nn.init.zeros_(head.weight)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, task, first, second):
+        first = F.gelu(self.project((first-self.mean)/self.scale))
+        second = F.gelu(self.project((second-self.mean)/self.scale))
+        first = F.dropout(first, self.dropout, self.training)
+        second = F.dropout(second, self.dropout, self.training)
+        pair = torch.cat([(first[:, :, None]-second[:, None, :]).abs(),
+                          first[:, :, None]*second[:, None, :]], dim=-1)
+        local = self.compare(pair)
+        summary = torch.cat([local.mean((1, 2)), local.amax((1, 2))], dim=-1)
+        return self.heads[task](summary)
+
+
+class SSChainDecoder(nn.Module):
+    """Small learned label-compatibility model, applied to frozen residue unaries."""
+    def __init__(self):
+        super().__init__()
+        self.transition = nn.Parameter(torch.empty(3, 3))
+        self.start = nn.Parameter(torch.empty(3))
+        self.end = nn.Parameter(torch.empty(3))
+        for parameter in self.parameters():
+            nn.init.normal_(parameter, std=.01)
+
+    def decode(self, probabilities):
+        from ss_chain import decode_probabilities
+        values = [parameter.detach().double().cpu().numpy()
+                  for parameter in (self.transition, self.start, self.end)]
+        return decode_probabilities(probabilities, *values)
+
+
+class UnifiedModel(esm2.Model):
+    TASK_ORDER = ('fluorescence', 'stability', 'beta_lactamase', 'solubility',
+                  'subcellular_localization', 'binary_localization', 'fold',
+                  'yeast_ppi', 'human_ppi', 'ppi_affinity')
+
+    def __init__(self, config):
+        super().__init__(layers=config['layers'], dim=config['dim'], heads=config['heads'])
+        self.config = config
+        self.task_index = {t: i for i, t in enumerate(self.TASK_ORDER)}
+        dim = config['dim']
+        if config.get('extension_layers', 0):
+            self.encoder.add_extension(config['extension_layers'], config['heads'],
+                                       before_norm=config.get('extension_before_norm', False))
+        if config.get('task_conditioning', False):
+            self.task_condition = nn.Parameter(torch.zeros(11, config['layers'], 4, dim))
+        if config.get('pooling', 'mean') == 'rich':
+            self.pool_query = nn.Parameter(torch.randn(len(self.TASK_ORDER), 2, dim) * 0.02)
+            self.pool_position = nn.Parameter(torch.zeros(len(self.TASK_ORDER), 2, 4))
+            # Shared across tasks, with a zero initial residual for safe lineage transfer.
+            self.pool_fuse = nn.Linear(6 * dim, dim)
+            nn.init.zeros_(self.pool_fuse.weight)
+            nn.init.zeros_(self.pool_fuse.bias)
+        if config.get('pair_interaction', False):
+            self.pair_fuse = nn.Linear(2 * dim, 2 * dim)
+            nn.init.zeros_(self.pair_fuse.weight)
+            nn.init.zeros_(self.pair_fuse.bias)
+        if config.get('ss_context', False):
+            self.heads['secondary_structure'] = LocalResidueHead(dim)
+        for task in config.get('linear_heads', []):
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(nn.Linear(width, self.CLASSES.get(task, 1)))
+        for task, settings in config.get('residue_readouts', {}).items():
+            self.heads[task] = NormalizedLinear(settings['bins'] * dim, self.CLASSES.get(task, 1))
+        for task, rank in config.get('residue_lowrank_heads', {}).items():
+            bins = config['residue_readouts'][task]['bins']
+            self.heads[task] = LowRankPositionHead(dim, bins, rank, self.CLASSES.get(task, 1))
+        for task in config.get('summary_readouts', []):
+            assert task not in self.PAIR and config.get('pooling') == 'rich'
+            self.heads[task] = NormalizedLinear(7 * dim, self.CLASSES.get(task, 1))
+        for task in config.get('sequence_composition_readouts', []):
+            from sequence_composition import WIDTH
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES
+            assert all(task not in config.get(key,[]) for key in
+                       ['cosine_heads','nonlinear_summary_heads','ss_summary_readouts',
+                        'sequence_conv_readouts','terminal_summary_readouts','token_logmeanexp_heads'])
+            self.heads[task] = NormalizedLinear(7 * dim + WIDTH, self.CLASSES[task])
+        for task, temperature in config.get('cosine_heads', {}).items():
+            assert task in config.get('summary_readouts', [])
+            self.heads[task] = NormalizedCosine(7*dim, self.CLASSES[task], temperature)
+        for task, settings in config.get('nonlinear_summary_heads', {}).items():
+            assert task in config.get('summary_readouts', []) and task not in config.get('cosine_heads', {})
+            self.heads[task] = NormalizedMLP(7*dim, self.CLASSES.get(task,1), settings['hidden'], settings['dropout'])
+        for task in config.get('calibrated_heads', []):
+            assert task not in config.get('summary_readouts', []) and task not in config.get('residue_readouts', {})
+            assert task not in config.get('linear_heads', [])
+            self.heads[task][3] = NormalizedLinear(dim, self.CLASSES.get(task,1))
+        for task in config.get('expanded_pair_readouts', []):
+            assert task in self.PAIR
+            width=3 if task in config.get('symmetric_pair_readouts',[]) else 4
+            if task in config.get('pair_summary_readouts', []):
+                assert config.get('pooling') == 'rich'
+                width *= 8
+            self.heads[task] = NormalizedLinear(width*dim, self.CLASSES.get(task,1))
+        if config.get('ss_linear_context'):
+            self.heads['secondary_structure'] = NormalizedResidueLinear(dim, config['ss_linear_context'])
+        if config.get('ss_calibrated'):
+            assert not config.get('ss_linear_context')
+            self.heads['secondary_structure'] = CalibratedLocalResidueHead(dim)
+        for task in config.get('ss_summary_readouts', []):
+            assert task in config.get('summary_readouts', []) and task not in self.PAIR
+            self.heads[task] = NormalizedLinear(7*dim+40, self.CLASSES[task])
+        for task,settings in config.get('sequence_conv_readouts',{}).items():
+            assert task in config.get('summary_readouts',[]) and task in self.CLASSES and task not in self.PAIR
+            self.heads[task] = ResidualSequenceConvHead(dim,self.CLASSES[task],settings['channels'],settings['dropout'],settings.get('retain_summary',True))
+        for task, settings in config.get('terminal_summary_readouts', {}).items():
+            assert task in config.get('summary_readouts', []) and task in self.CLASSES and task not in self.PAIR
+            assert all(task not in config.get(key, {}) for key in
+                       ['cosine_heads', 'nonlinear_summary_heads', 'ss_summary_readouts', 'sequence_conv_readouts'])
+            bins = settings['bins']
+            assert bins > 0 and all(settings[key] > 0 and settings[key] % bins == 0
+                                    for key in ['prefix_residues', 'suffix_residues'])
+            self.heads[task] = NormalizedLinear((7+2*bins)*dim, self.CLASSES[task])
+        if config.get('pair_bilinear_rank', 0):
+            rank = config['pair_bilinear_rank']
+            assert not config.get('pair_summary_readouts')
+            self.pair_bilinear_projection = nn.Linear(dim, rank, bias=False)
+            nn.init.normal_(self.pair_bilinear_projection.weight, std=dim ** -.5)
+            with torch.no_grad():
+                self.pair_bilinear_projection.weight.copy_(F.normalize(self.pair_bilinear_projection.weight, dim=1))
+            self.pair_bilinear_heads = nn.ModuleDict({
+                task: nn.Linear(rank, self.CLASSES.get(task, 1), bias=False)
+                for task in sorted(self.PAIR)})
+            for head in self.pair_bilinear_heads.values():
+                nn.init.zeros_(head.weight)
+            self.register_buffer('pair_bilinear_mean', torch.zeros(dim))
+            self.register_buffer('pair_bilinear_scale', torch.ones(dim))
+        if config.get('pair_residue_interaction'):
+            self.pair_residue_interaction = SharedPairResidueInteraction(
+                dim, config['pair_residue_interaction'], self.CLASSES)
+        for task in config.get('token_logmeanexp_heads', []):
+            assert task in self.CLASSES and task not in self.PAIR
+            assert task not in config.get('sequence_windows', [])
+            self.heads[task] = TokenLogMeanExpHead(dim, self.CLASSES[task])
+        if config.get('ss_chain_decoder', False):
+            self.ss_chain_decoder = SSChainDecoder()
+        if config.get('shared_summary_residual'):
+            settings = config['shared_summary_residual']
+            tasks = settings['tasks']
+            assert all(task in config.get('summary_readouts', []) and
+                       isinstance(self.heads[task], NormalizedLinear) for task in tasks)
+            self.summary_residual = SharedSummaryResidual(7*dim, settings['hidden'], settings['dropout'],
+                                                          {task: self.CLASSES[task] for task in tasks})
+
+        if config.get('dual_summary'):
+            settings = config['dual_summary']
+            tasks = settings['tasks']
+            assert tasks and len(tasks) == len(set(tasks))
+            assert config.get('pooling') == 'rich'
+            assert all(task in config.get('summary_readouts', []) and task not in self.PAIR for task in tasks)
+            assert all(task not in config.get(key, {}) for task in tasks for key in
+                       ['cosine_heads', 'nonlinear_summary_heads', 'ss_summary_readouts',
+                        'sequence_conv_readouts', 'terminal_summary_readouts', 'token_logmeanexp_heads',
+                        'summary_residual_tasks', 'sequence_composition_readouts'])
+            self.auxiliary_summary_encoder = esm2.Encoder(settings['layers'], settings['dim'], settings['heads'])
+            self.auxiliary_summary_index = {task: i for i, task in enumerate(tasks)}
+            self.auxiliary_pool_query = nn.Parameter(torch.randn(len(tasks), 2, settings['dim']) * .02)
+            self.auxiliary_pool_position = nn.Parameter(torch.zeros(len(tasks), 2, 4))
+            for task in tasks:
+                self.heads[task] = NormalizedLinear(7*(dim+settings['dim']), self.CLASSES[task])
+
+        if config.get('shared_fusion'):
+            settings = config['shared_fusion']
+            dual = config['dual_summary']
+            assert not settings.get('conditioned', True)
+            assert all(settings[k] == dual[k] for k in ['layers', 'dim', 'heads'])
+            active = config['shared_fusion_tasks']
+            assert active and not set(active).intersection(dual['tasks'])
+            # One auxiliary module supplies both uses; never register a duplicate alias.
+            width = dim + settings['dim']
+            self.shared_fusion = nn.Sequential(nn.LayerNorm(width), nn.Linear(width, settings['hidden']),
+                                              nn.GELU(), nn.Linear(settings['hidden'], dim))
+            nn.init.normal_(self.shared_fusion[1].weight, std=.02)
+            nn.init.zeros_(self.shared_fusion[1].bias)
+            nn.init.zeros_(self.shared_fusion[3].weight)
+            nn.init.zeros_(self.shared_fusion[3].bias)
+
+        if config.get('dual_residue'):
+            assert config.get('ss_calibrated') and config.get('dual_summary')
+            assert 'secondary_structure' not in config.get('shared_fusion_tasks', [])
+            auxiliary_dim = config['dual_summary']['dim']
+            self.heads['secondary_structure'] = DualLocalResidueHead(dim, auxiliary_dim)
+
+    def pair_representation(self, task, first, second, base):
+        if task in self.config.get('pair_bilinear_tasks', []):
+            return {'base': base, 'chain_a': first, 'chain_b': second}
+        return base
+
+    def apply_head(self, task, representation):
+        if task in self.config.get('summary_residual_tasks', []):
+            head = self.heads[task]
+            normalized = (representation-head.mean)/head.scale
+            return head(representation) + self.summary_residual(task, normalized)
+        if isinstance(representation, dict) and 'residue_a' in representation:
+            base = {k:v for k,v in representation.items() if k not in ['residue_a', 'residue_b']}
+            original = self.apply_head(task, base if 'chain_a' in base else base['base'])
+            return original + self.pair_residue_interaction(task, representation['residue_a'], representation['residue_b'])
+        if isinstance(representation, dict) and 'chain_a' in representation:
+            first = (representation['chain_a'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            second = (representation['chain_b'] - self.pair_bilinear_mean) / self.pair_bilinear_scale
+            interaction = self.pair_bilinear_projection(first) * self.pair_bilinear_projection(second)
+            interaction = interaction / math.sqrt(self.config['pair_bilinear_rank'])
+            return self.heads[task](representation['base']) + self.pair_bilinear_heads[task](interaction)
+        return self.heads[task](representation)
+
+    def encode_residues(self, tokens, task):
+        condition = None
+        if self.config.get('task_conditioning', False):
+            ti = 10 if task == 'secondary_structure' else self.task_index[task]
+            condition = self.task_condition[ti]
+        hidden, padding = self.encoder(tokens, condition=condition, depth=self.config.get('task_encoder_layers',{}).get(task),
+                                       extension_depth=self.config.get('task_extension_depths',{}).get(task))
+        if self.config.get('shared_fusion') and task in self.config['shared_fusion_tasks']:
+            auxiliary, auxiliary_padding = self.auxiliary_summary_encoder(tokens)
+            if not self.config['shared_fusion'].get('auxiliary_input', True):
+                auxiliary = torch.zeros_like(auxiliary)
+            correction = self.shared_fusion(torch.cat([hidden, auxiliary], -1))
+            hidden = (hidden + correction).masked_fill(padding.unsqueeze(-1), 0)
+        if task == 'secondary_structure' and self.config.get('dual_residue'):
+            auxiliary, auxiliary_padding = self.auxiliary_summary_encoder(tokens)
+            hidden = torch.cat([hidden, auxiliary], dim=-1)
+        return hidden, padding
+
+    def pool(self, tokens, task):
+        hidden, pad_mask = self.encode_residues(tokens, task)
+        primary = self.summarize(hidden, tokens, pad_mask, task)
+        if task in self.config.get('dual_summary', {}).get('tasks', []):
+            auxiliary, auxiliary_mask = self.auxiliary_summary_encoder(tokens)
+            secondary = self.auxiliary_summarize(auxiliary, tokens, auxiliary_mask, task)
+            return torch.cat([primary, secondary], dim=-1)
+        return primary
+
+    def summarize(self, hidden, tokens, pad_mask, task):
+        valid = (~pad_mask).unsqueeze(-1)
+        mean = (hidden * valid).sum(1) / valid.sum(1).clamp_min(1)
+        if self.config.get('pooling', 'mean') == 'mean':
+            return mean
+        residues = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+        # Empty/nonstandard-only inputs still produce a finite representation.
+        residues[:, 0] |= ~residues.any(1)
+        keep = residues.unsqueeze(-1)
+        count = keep.sum(1).clamp_min(1)
+        center = (hidden * keep).sum(1) / count
+        position = residues.cumsum(1).to(hidden.dtype) / count.to(hidden.dtype)
+        basis = torch.stack([position, position.square(), torch.sin(position * math.pi),
+                             torch.cos(position * math.pi)], dim=-1)
+        ti = self.task_index[task]
+        scores = torch.einsum('bld,qd->blq', hidden, self.pool_query[ti]) / math.sqrt(hidden.shape[-1])
+        scores = scores + torch.einsum('blp,qp->blq', basis, self.pool_position[ti])
+        scores = scores.masked_fill(~residues.unsqueeze(-1), -1e4)
+        attention = torch.einsum('blq,bld->bqd', scores.softmax(1), hidden)
+        variance = ((hidden - center[:, None]).float().square() * keep).sum(1) / count
+        deviation = (variance + 1e-5).sqrt().to(hidden.dtype)
+        maximum = hidden.masked_fill(~keep, -1e4).amax(1) - center
+        first = residues & (residues.cumsum(1) <= 32)
+        last = residues & ((residues.sum(1, keepdim=True) - residues.cumsum(1)) < 32)
+        prefix = (hidden * first.unsqueeze(-1)).sum(1) / first.sum(1, keepdim=True).clamp_min(1) - center
+        suffix = (hidden * last.unsqueeze(-1)).sum(1) / last.sum(1, keepdim=True).clamp_min(1) - center
+        summary = torch.cat([attention[:, 0] - center, attention[:, 1] - center,
+                             deviation, maximum, prefix, suffix], dim=-1)
+        if task in self.config.get('summary_readouts', []):
+            return torch.cat([mean, summary], dim=-1)
+        if task in self.config.get('pair_summary_readouts', []):
+            return torch.cat([mean + self.pool_fuse(summary), mean, summary], dim=-1)
+        return mean + self.pool_fuse(summary)
+
+    def auxiliary_summarize(self, hidden, tokens, pad_mask, task):
+        valid = (~pad_mask).unsqueeze(-1)
+        mean = (hidden * valid).sum(1) / valid.sum(1).clamp_min(1)
+        if self.config.get('pooling', 'mean') == 'mean':
+            return mean
+        residues = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+        # Empty/nonstandard-only inputs still produce a finite representation.
+        residues[:, 0] |= ~residues.any(1)
+        keep = residues.unsqueeze(-1)
+        count = keep.sum(1).clamp_min(1)
+        center = (hidden * keep).sum(1) / count
+        position = residues.cumsum(1).to(hidden.dtype) / count.to(hidden.dtype)
+        basis = torch.stack([position, position.square(), torch.sin(position * math.pi),
+                             torch.cos(position * math.pi)], dim=-1)
+        ti = self.auxiliary_summary_index[task]
+        scores = torch.einsum('bld,qd->blq', hidden, self.auxiliary_pool_query[ti]) / math.sqrt(hidden.shape[-1])
+        scores = scores + torch.einsum('blp,qp->blq', basis, self.auxiliary_pool_position[ti])
+        scores = scores.masked_fill(~residues.unsqueeze(-1), -1e4)
+        attention = torch.einsum('blq,bld->bqd', scores.softmax(1), hidden)
+        variance = ((hidden - center[:, None]).float().square() * keep).sum(1) / count
+        deviation = (variance + 1e-5).sqrt().to(hidden.dtype)
+        maximum = hidden.masked_fill(~keep, -1e4).amax(1) - center
+        first = residues & (residues.cumsum(1) <= 32)
+        last = residues & ((residues.sum(1, keepdim=True) - residues.cumsum(1)) < 32)
+        prefix = (hidden * first.unsqueeze(-1)).sum(1) / first.sum(1, keepdim=True).clamp_min(1) - center
+        suffix = (hidden * last.unsqueeze(-1)).sum(1) / last.sum(1, keepdim=True).clamp_min(1) - center
+        summary = torch.cat([attention[:, 0] - center, attention[:, 1] - center,
+                             deviation, maximum, prefix, suffix], dim=-1)
+        return torch.cat([mean, summary], dim=-1)
+
+    def pool_sequences(self, sequences, task, device, max_len):
+        if self.training and not self.config.get('window_pooling_training', True):
+            tokens=esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device)
+            return self.pool(tokens,task)
+        if task not in self.config.get('sequence_windows', []) or not any(len(s)>max_len-2 for s in sequences):
+            return self.pool(esm2.pad_batch([esm2.encode(s,max_len) for s in sequences],device),task)
+        results=[None]*len(sequences)
+        short=[i for i,s in enumerate(sequences) if len(s)<=max_len-2]
+        if short:
+            pooled=self.pool(esm2.pad_batch([esm2.encode(sequences[i],max_len) for i in short],device),task)
+            for j,index in enumerate(short):results[index]=pooled[j]
+        width=max_len-2;stride=min(768,width)
+        if self.training and self.config.get('batch_window_training',False):
+            pieces=[];starts_by_index={};encoded={}
+            for index,sequence in enumerate(sequences):
+                if len(sequence)<=width:continue
+                starts=list(range(0,len(sequence)-width+1,stride))
+                if starts[-1]!=len(sequence)-width:starts.append(len(sequence)-width)
+                starts_by_index[index]=starts
+                pieces.extend((index,start) for start in starts)
+            count=max(1,16384//max_len)
+            for begin in range(0,len(pieces),count):
+                part=pieces[begin:begin+count]
+                tokens=esm2.pad_batch([esm2.encode(sequences[i][s:s+width],max_len) for i,s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,key in enumerate(part):encoded[key]=hidden[j]
+            positions=torch.arange(width,device=device)
+            weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+            for index,starts in starts_by_index.items():
+                sequence=sequences[index];length=len(sequence)
+                total=torch.zeros(length,self.config['dim'],device=device);counts=torch.zeros(length,1,device=device)
+                for start in starts:
+                    total.index_add_(0,positions+start,encoded[index,start][1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+                assembled=torch.cat([encoded[index,starts[0]][0:1],total/counts.clamp_min(1),encoded[index,starts[-1]][width+1:width+2]],dim=0)[None]
+                tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+                results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+            return torch.stack(results)
+        for index,sequence in enumerate(sequences):
+            length=len(sequence)
+            if length<=width:continue
+            starts=list(range(0,length-width+1,stride))
+            if starts[-1]!=length-width:starts.append(length-width)
+            total=torch.zeros(length,self.config['dim'],device=device)
+            counts=torch.zeros(length,1,device=device)
+            first=last=None
+            for begin in range(0,len(starts),max(1,16384//max_len)):
+                part=starts[begin:begin+max(1,16384//max_len)]
+                tokens=esm2.pad_batch([esm2.encode(sequence[s:s+width],max_len) for s in part],device)
+                hidden,_=self.encode_residues(tokens,task)
+                for j,start in enumerate(part):
+                    if start==0:first=hidden[j,0:1]
+                    if start==starts[-1]:last=hidden[j,width+1:width+2]
+                    positions=torch.arange(width,device=device)
+                    weight=torch.minimum(torch.minimum(positions+1,width-positions),torch.full_like(positions,128)).float()[:,None]
+                    total.index_add_(0,positions+start,hidden[j,1:width+1].float()*weight)
+                    counts.index_add_(0,positions+start,weight)
+            assembled=torch.cat([first,total/counts.clamp_min(1),last],dim=0)[None]
+            tokens=esm2.pad_batch([esm2.encode(sequence,length+2)],device)
+            results[index]=self.summarize(assembled,tokens,tokens.eq(esm2.PAD),task)[0]
+        return torch.stack(results)
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.config.get('sequence_composition_readouts', []):
+            from sequence_composition import composition_features
+            sequences=[item['sequence'] for item in batch]
+            pooled=self.pool_sequences(sequences,task,device,max_len)
+            return torch.cat([pooled.float(),composition_features(sequences,device)],-1)
+        if task in self.config.get('token_logmeanexp_heads', []):
+            tokens = esm2.pad_batch([esm2.encode(row['sequence'], max_len) for row in batch], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            valid = (tokens >= esm2.FIRST_RESIDUE) & (tokens <= esm2.LAST_RESIDUE)
+            valid[:, 0] |= ~valid.any(1)
+            return {'hidden':hidden, 'valid':valid}
+        if task in self.config.get('terminal_summary_readouts', {}):
+            return self.terminal_summary_features(task, [item['sequence'] for item in batch], device, max_len)
+        if task in self.config.get('ss_summary_readouts', []):
+            sequences=[x['sequence'] for x in batch]
+            summary=self.pool_sequences(sequences,task,device,max_len)
+            structure=self.secondary_structure_summary(sequences,device,max_len)
+            return torch.cat([summary.float(),structure],-1)
+        if task in self.config.get('sequence_conv_readouts',{}):
+            tokens=esm2.pad_batch([esm2.encode(x['sequence'],max_len) for x in batch],device)
+            hidden,pad_mask=self.encode_residues(tokens,task)
+            lengths=torch.tensor([min(len(x['sequence']),max_len-2) for x in batch],device=device)
+            width=max(1,int(lengths.max()))
+            valid=torch.arange(width,device=device)[None,:]<lengths[:,None]
+            return {'hidden':hidden[:,1:1+width], 'valid':valid,
+                    'summary':self.summarize(hidden,tokens,pad_mask,task)}
+        if task in self.config.get('residue_readouts', {}):
+            bins = self.config['residue_readouts'][task]['bins']
+            sequences = [x['sequence'] for x in batch]
+            tokens = esm2.pad_batch([esm2.encode(s, max_len) for s in sequences], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            return self.position_features(hidden, [min(len(s), max_len-2) for s in sequences], bins)
+        if task in self.PAIR:
+            a = self.pool_sequences([x['sequence_a'] for x in batch],task,device,max_len)
+            b = self.pool_sequences([x['sequence_b'] for x in batch],task,device,max_len)
+            if task in self.config.get('expanded_pair_readouts', []):
+                if task in self.config.get('symmetric_pair_readouts',[]):
+                    features=torch.cat([(a.float()+b.float())*.5,a*b,(a-b).abs()],dim=-1)
+                else:
+                    features=torch.cat([a,b,a*b,(a-b).abs()],dim=-1)
+                base = F.dropout(features,p=self.config.get('pair_dropout',0.),training=self.training)
+                return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+            output = torch.cat([a, b], dim=-1)
+            if self.config.get('pair_interaction', False):
+                output = output + self.pair_fuse(torch.cat([a * b, (a - b).abs()], dim=-1))
+            base = F.dropout(output, p=self.config.get('pair_dropout', 0.0), training=self.training)
+            return self.add_pair_residues(task, batch, device, max_len, self.pair_representation(task, a, b, base))
+        return self.pool_sequences([x['sequence'] for x in batch],task,device,max_len)
+
+    def add_pair_residues(self, task, batch, device, max_len, base):
+        if task not in self.config.get('pair_residue_tasks', []):
+            return base
+        result = dict(base) if isinstance(base, dict) else {'base': base}
+        bins = self.config['pair_residue_interaction']['bins']
+        for role, name in [('a', 'sequence_a'), ('b', 'sequence_b')]:
+            result['residue_'+role] = self.pool_residue_bins(
+                [row[name] for row in batch], task, device, max_len, bins)
+        return result
+
+    def pool_residue_bins(self, sequences, task, device, max_len, bins):
+        """Average every residue into fixed relative bins, with full-chain context."""
+        width = max_len-2
+        assert width > 0 and bins > 0
+        output = [None]*len(sequences)
+        short = [i for i, sequence in enumerate(sequences) if len(sequence) <= width]
+        if short:
+            tokens = esm2.pad_batch([esm2.encode(sequences[i], max_len) for i in short], device)
+            hidden, _ = self.encode_residues(tokens, task)
+            for j, index in enumerate(short):
+                length = len(sequences[index])
+                values = hidden[j, 1:1+length].float()
+                output[index] = (F.adaptive_avg_pool1d(values.T[None], bins)[0].T if length
+                                 else torch.zeros(bins, self.config['dim'], device=device))
+        for index, sequence in enumerate(sequences):
+            if len(sequence) <= width:
+                continue
+            starts = list(range(0, len(sequence)-width+1, min(768, width)))
+            if starts[-1] != len(sequence)-width:
+                starts.append(len(sequence)-width)
+            total = torch.zeros(len(sequence), self.config['dim'], device=device)
+            count = torch.zeros(len(sequence), 1, device=device)
+            position = torch.arange(width, device=device)
+            weight = torch.minimum(torch.minimum(position+1, width-position),
+                                   torch.full_like(position, 128)).float()[:, None]
+            for begin in range(0, len(starts), max(1, 16384//max_len)):
+                part = starts[begin:begin+max(1, 16384//max_len)]
+                tokens = esm2.pad_batch([esm2.encode(sequence[s:s+width], max_len) for s in part], device)
+                hidden, _ = self.encode_residues(tokens, task)
+                for j, start in enumerate(part):
+                    total.index_add_(0, position+start, hidden[j, 1:1+width].float()*weight)
+                    count.index_add_(0, position+start, weight)
+            values = total/count.clamp_min(1)
+            output[index] = F.adaptive_avg_pool1d(values.T[None], bins)[0].T
+        return torch.stack(output)
+
+    @staticmethod
+    def terminal_bins(states, width, bins, align_end=False):
+        """Fixed absolute residue bins; exclude padding from partial-bin means."""
+        assert width > 0 and bins > 0 and width % bins == 0
+        states = (states[-width:] if align_end else states[:width]).float()
+        count = states.shape[0]
+        padded = states.new_zeros(width, states.shape[-1])
+        valid = states.new_zeros(width)
+        offset = width-count if align_end else 0
+        padded[offset:offset+count] = states
+        valid[offset:offset+count] = 1
+        total = padded.reshape(bins, width//bins, -1).sum(1)
+        denominator = valid.reshape(bins, width//bins).sum(1).clamp_min(1)[:, None]
+        return (total/denominator).flatten()
+
+    def terminal_summary_features(self, task, sequences, device, max_len):
+        settings = self.config['terminal_summary_readouts'][task]
+        width = max_len-2
+        assert width >= max(settings['prefix_residues'], settings['suffix_residues'])
+        tokens = esm2.pad_batch([esm2.encode(sequence, max_len) for sequence in sequences], device)
+        hidden, padding = self.encode_residues(tokens, task)
+        summary = self.summarize(hidden, tokens, padding, task)
+        long_ids = [index for index, sequence in enumerate(sequences) if len(sequence) > width]
+        tails = {}
+        if long_ids:
+            tail_tokens = esm2.pad_batch([esm2.encode(sequences[index][-width:], max_len)
+                                         for index in long_ids], device)
+            tail_hidden, _ = self.encode_residues(tail_tokens, task)
+            tails = {index: tail_hidden[local, 1:width+1] for local, index in enumerate(long_ids)}
+        terminals = []
+        for index, sequence in enumerate(sequences):
+            prefix = hidden[index, 1:1+min(len(sequence), width)]
+            suffix = tails.get(index, prefix)
+            terminals.append(torch.cat([
+                self.terminal_bins(prefix, settings['prefix_residues'], settings['bins']),
+                self.terminal_bins(suffix, settings['suffix_residues'], settings['bins'], align_end=True)]))
+        return torch.cat([summary.float(), torch.stack(terminals)], dim=-1)
+
+    @staticmethod
+    def position_features(hidden, lengths, bins):
+        features = []
+        for index, length in enumerate(lengths):
+            if length:
+                states = hidden[index:index+1, 1:1+length].float().transpose(1, 2)
+                features.append(F.interpolate(states, size=bins, mode='linear', align_corners=True).flatten())
+            else:
+                features.append(hidden.new_zeros(hidden.shape[-1] * bins).float())
+        return torch.stack(features)
+
+    def secondary_structure_summary(self, sequences, device, max_len):
+        tokens=esm2.pad_batch([esm2.encode(sequence,max_len) for sequence in sequences],device)
+        hidden,_=self.encode_residues(tokens,'secondary_structure')
+        with torch.autocast(device_type=device.type,enabled=False):
+            probabilities=self.heads['secondary_structure'](hidden.float()).softmax(-1)
+        summaries=[]
+        for index,sequence in enumerate(sequences):
+            length=min(len(sequence),max_len-2)
+            if not length:
+                summaries.append(probabilities.new_zeros(40));continue
+            value=probabilities[index,1:1+length]
+            mean=value.mean(0);std=value.std(0,unbiased=False)
+            transition=(value[:-1,:,None]*value[1:,None,:]).mean(0).flatten() if length>1 else value.new_zeros(9)
+            positions=F.adaptive_avg_pool1d(value.T[None],8).flatten()
+            summaries.append(torch.cat([mean,std,transition,positions,value.new_tensor([math.log1p(length)])]))
+        return torch.stack(summaries)
+
+    def normalize(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return (values - stats['mean']) / stats['std'] if stats else values
+
+    def unscale(self, task, values):
+        stats = self.config.get('regression_stats', {}).get(task)
+        return values * stats['std'] + stats['mean'] if stats else values
+
+    def transfer(self, state, normalized_source=False):
+        """Transfer our own lineage only; retain random init for new parameters."""
+        current = self.state_dict()
+        fitting = {k: v for k, v in state.items() if k in current and v.shape == current[k].shape}
+        missing, unexpected = self.load_state_dict(fitting, strict=False)
+        if not normalized_source:
+            with torch.no_grad():
+                for task, stats in self.config.get('regression_stats', {}).items():
+                    # Preserve predictions when moving a trained head to standardized units.
+                    if f'heads.{task}.3.weight' in fitting:
+                        self.heads[task][3].weight.div_(stats['std'])
+                        self.heads[task][3].bias.sub_(stats['mean']).div_(stats['std'])
+        return {'transferred': len(fitting), 'new_tensors': missing, 'unexpected': unexpected}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S058/PUBLISHED.json

@@ -0,0 +1,5 @@
+{
+  "source": "/run-state/workspace/research/production-allfit-ss1/candidate/package",
+  "files": 9,
+  "bytes": 562063804
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S058/README.md

@@ -0,0 +1,41 @@
+# Unified PEER protein model
+
+Exactly **139,328,153 learned parameters** in one state dictionary. The original
+37,845,535-parameter,12-layer,width-512 primary encoder was jointly trained on
+all eleven tasks and supplies every task. Two shared extension blocks serve
+beta-lactamase/stability. One jointly trained12-layer,width-768 auxiliary
+encoder is stored once and supplies SS and subcellular features.
+
+SS concatenates both frozen local convolution/MLP prefixes and uses one
+normalized1280-to-3 linear readout. Subcellular uses both seven-summary
+features. Other heads retain rank-target positional GFP/beta readouts,
+summary fold/solubility/binary heads (binary with shared residual), a stability
+MLP, and pair readouts with retained shared yeast interaction modules.
+
+All parameters originated from random initialization and training here.
+Primary provenance: one hour mounted UniRef50 MLM, joint all11 fit training,
+conditioning/extensions and own-teacher SS distillation. Auxiliary: eight
+hours MLM (10,254,509,402 tokens),8,486 joint all11 fit updates. Only mounted
+fit/Tune/UniRef50 were used; no external weights or embeddings.
+
+SS now fits all2,221,507 valid fit residues (including2,245,710 window views),
+with the same seed20270212,ridge.01,fit mean/std and final12 LBFGS blocks as
+the500k-residue predecessor. Every previous sampled feature/label/window
+weight matches exactly. CUDA optimizer resume checks passed. Cached SS rises
+from.7674307948 to.7678563413; paired protein95 interval for the increase is
+[.00015318,.00070488]. The original minimum-effect threshold.0005 was missed.
+A separately recorded, retrospective publication review uses positive native
+gain and interval, complete all11 replay and shared-parameter dependence.
+It does not claim the original experimental eligibility rule passed.
+Independent native all11 review passed; all ten unaffected production prediction files match exactly, and SS matches the accepted fit-only development output. Native primary feature removal lowers SS accuracy by .01279153; auxiliary removal lowers it by .13247602. The fit-only development mean is .7221840065.
+
+Five existing fit+Tune heads (fold, fluorescence, beta-lactamase, affinity, stability) remain exact. Their Tune scores and aggregate are in-sample and excluded from selection.
+
+Limits: repeated Tune selection and protein-family dependence; the intervals
+are conditional. Feature removal is out of distribution. Fold remains weak,
+PPI validation sets are small, rank outputs lack absolute calibration. SS and
+PPI use full-chain windows; other tasks retain their1022-residue prefix.
+No held-out test score is available.
+
+Run `bash infer.sh INPUT_ROOT OUTPUT_ROOT` offline. No trainer, feature cache,
+sequence lookup, external model or test-time fitting is accessed.

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S058/config.json

@@ -0,0 +1,146 @@
+{
+  "layers": 12,
+  "dim": 512,
+  "heads": 8,
+  "pooling": "rich",
+  "pair_interaction": true,
+  "ss_context": true,
+  "max_len": 1024,
+  "pair_dropout": 0.0,
+  "architecture": "unified",
+  "full_ss": true,
+  "regression_stats": {
+    "fluorescence": {
+      "mean": 3.180586883940159,
+      "std": 0.8339910288860748
+    },
+    "stability": {
+      "mean": 0.1790524860555312,
+      "std": 0.5662245232305059
+    },
+    "beta_lactamase": {
+      "mean": 0.7383112351980983,
+      "std": 0.31642946622284734
+    },
+    "ppi_affinity": {
+      "mean": -11.654589870742203,
+      "std": 3.0832061340498944
+    }
+  },
+  "residue_readouts": {
+    "fluorescence": {
+      "bins": 256
+    },
+    "beta_lactamase": {
+      "bins": 320
+    }
+  },
+  "fp32_heads": [
+    "beta_lactamase",
+    "binary_localization",
+    "fluorescence",
+    "fold",
+    "human_ppi",
+    "ppi_affinity",
+    "secondary_structure",
+    "solubility",
+    "stability",
+    "subcellular_localization",
+    "yeast_ppi"
+  ],
+  "ss_linear_context": 0,
+  "ss_calibrated": true,
+  "linear_heads": [],
+  "summary_readouts": [
+    "solubility",
+    "subcellular_localization",
+    "binary_localization",
+    "fold"
+  ],
+  "cosine_heads": {},
+  "nonlinear_summary_heads": {},
+  "calibrated_heads": [
+    "stability"
+  ],
+  "sequence_windows": [
+    "yeast_ppi",
+    "human_ppi"
+  ],
+  "expanded_pair_readouts": [
+    "yeast_ppi",
+    "human_ppi",
+    "ppi_affinity"
+  ],
+  "symmetric_pair_readouts": [
+    "yeast_ppi",
+    "ppi_affinity"
+  ],
+  "task_encoder_layers": {},
+  "task_conditioning": true,
+  "pair_summary_readouts": [],
+  "extension_layers": 2,
+  "window_pooling_training": true,
+  "batch_window_training": true,
+  "class_weight_power": {
+    "fold": 0.5
+  },
+  "task_extension_depths": {
+    "beta_lactamase": 2,
+    "binary_localization": 0,
+    "fluorescence": 0,
+    "fold": 0,
+    "human_ppi": 0,
+    "ppi_affinity": 0,
+    "secondary_structure": 0,
+    "solubility": 0,
+    "stability": 2,
+    "subcellular_localization": 0,
+    "yeast_ppi": 0
+  },
+  "task_max_len": {
+    "human_ppi": 1536
+  },
+  "pair_bilinear_rank": 32,
+  "pair_bilinear_tasks": [
+    "yeast_ppi"
+  ],
+  "pair_residue_interaction": {
+    "bins": 64,
+    "projection_dim": 32,
+    "pair_hidden": 32,
+    "pair_channels": 8,
+    "dropout": 0.1
+  },
+  "pair_residue_tasks": [
+    "yeast_ppi"
+  ],
+  "rank_target_tasks": [
+    "fluorescence",
+    "beta_lactamase"
+  ],
+  "ss_summary_readouts": [],
+  "terminal_summary_readouts": {},
+  "residue_lowrank_heads": {},
+  "shared_summary_residual": {
+    "tasks": [
+      "binary_localization"
+    ],
+    "hidden": 128,
+    "dropout": 0.2
+  },
+  "summary_residual_tasks": [
+    "binary_localization"
+  ],
+  "dual_summary": {
+    "layers": 12,
+    "dim": 768,
+    "heads": 12,
+    "tasks": [
+      "subcellular_localization"
+    ]
+  },
+  "dual_residue": {
+    "task": "secondary_structure",
+    "features": "two_frozen_local_prefixes"
+  }
+}

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S058/esm2.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""An ESM-2 architecture, trained from scratch, as the reference baseline.
+
+Follows Lin et al. (Science 2023) / facebookresearch/esm in the ways that
+matter for a like-for-like architecture claim:
+
+  * rotary position embeddings, not learned positional embeddings -- this is
+    the defining architectural change from ESM-1b to ESM-2
+  * pre-LayerNorm blocks, GELU feed-forward at 4x expansion
+  * final LayerNorm before the LM head, and the LM head's projection weight
+    tied to the token embedding
+  * the ESM alphabet's special tokens (<cls>/<pad>/<eos>/<mask>) and the same
+    20 standard + rare amino-acid symbols
+
+The published size ladder is reproduced in CONFIGS so the baseline can be named
+by its ESM-2 counterpart rather than by an arbitrary width.
+"""
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ESM-2's alphabet, in its canonical order.
+SPECIALS = ["<cls>", "<pad>", "<eos>", "<unk>"]
+RESIDUES = list("LAGVSERTIDPKQNFYMHWCXBUZO")
+EXTRA = ["<null_1>", "<mask>"]
+ALPHABET = SPECIALS + RESIDUES + EXTRA
+TOKEN = {symbol: index for index, symbol in enumerate(ALPHABET)}
+CLS, PAD, EOS, UNK = TOKEN["<cls>"], TOKEN["<pad>"], TOKEN["<eos>"], TOKEN["<unk>"]
+MASK = TOKEN["<mask>"]
+VOCAB_SIZE = len(ALPHABET)
+FIRST_RESIDUE, LAST_RESIDUE = TOKEN["L"], TOKEN["O"]
+
+# name -> (layers, embed_dim, attention_heads), from the ESM-2 release table.
+CONFIGS = {
+    "esm2_t6_8M":    (6, 320, 20),
+    "esm2_t12_35M":  (12, 480, 20),
+    "esm2_t30_150M": (30, 640, 20),
+    "esm2_t33_650M": (33, 1280, 20),
+}
+
+
+def encode(sequence, max_len=1024):
+    body = [TOKEN.get(c, UNK) for c in sequence[:max_len - 2]]
+    return [CLS] + body + [EOS]
+
+
+def pad_batch(sequences, device):
+    width = max(len(s) for s in sequences)
+    out = torch.full((len(sequences), width), PAD, dtype=torch.long)
+    for row, ids in enumerate(sequences):
+        out[row, :len(ids)] = torch.tensor(ids, dtype=torch.long)
+    return out.to(device, non_blocking=True)
+
+
+class Rotary(nn.Module):
+    """Rotary position embedding, as ESM-2 applies it to q and k."""
+
+    def __init__(self, dim, base=10000):
+        super().__init__()
+        inverse = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inverse", inverse, persistent=False)
+        self._cached_length = 0
+
+    def _tables(self, length, device, dtype):
+        if length != self._cached_length or self._cos.device != device:
+            position = torch.arange(length, device=device, dtype=torch.float)
+            angles = torch.outer(position, self.inverse.to(device))
+            table = torch.cat([angles, angles], dim=-1)
+            self._cos = table.cos()[None, None]
+            self._sin = table.sin()[None, None]
+            self._cached_length = length
+        return self._cos.to(dtype), self._sin.to(dtype)
+
+    @staticmethod
+    def _rotate_half(x):
+        half = x.shape[-1] // 2
+        return torch.cat([-x[..., half:], x[..., :half]], dim=-1)
+
+    def forward(self, q, k):
+        cos, sin = self._tables(q.shape[-2], q.device, q.dtype)
+        return (q * cos + self._rotate_half(q) * sin,
+                k * cos + self._rotate_half(k) * sin)
+
+
+class Attention(nn.Module):
+    def __init__(self, dim, heads):
+        super().__init__()
+        self.heads = heads
+        self.head_dim = dim // heads
+        self.q = nn.Linear(dim, dim)
+        self.k = nn.Linear(dim, dim)
+        self.v = nn.Linear(dim, dim)
+        self.out = nn.Linear(dim, dim)
+        self.rotary = Rotary(self.head_dim)
+
+    def forward(self, x, pad_mask):
+        batch, length, _ = x.shape
+        shape = (batch, length, self.heads, self.head_dim)
+        q = self.q(x).view(shape).transpose(1, 2)
+        k = self.k(x).view(shape).transpose(1, 2)
+        v = self.v(x).view(shape).transpose(1, 2)
+        q, k = self.rotary(q, k)
+        attention_mask = None
+        if pad_mask is not None:
+            attention_mask = (~pad_mask)[:, None, None, :]
+        hidden = F.scaled_dot_product_attention(q, k, v, attn_mask=attention_mask)
+        hidden = hidden.transpose(1, 2).reshape(batch, length, -1)
+        return self.out(hidden)
+
+
+class Block(nn.Module):
+    def __init__(self, dim, heads, ffn):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim)
+        self.attention = Attention(dim, heads)
+        self.norm2 = nn.LayerNorm(dim)
+        self.ffn = nn.Sequential(nn.Linear(dim, ffn), nn.GELU(), nn.Linear(ffn, dim))
+
+    def forward(self, x, pad_mask, condition=None):
+        first = self.norm1(x)
+        if condition is not None:
+            first = first * (1 + condition[0]) + condition[1]
+        x = x + self.attention(first, pad_mask)
+        second = self.norm2(x)
+        if condition is not None:
+            second = second * (1 + condition[2]) + condition[3]
+        return x + self.ffn(second)
+
+
+class Encoder(nn.Module):
+    """The shared backbone. Every task reads from this one parameter set."""
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.dim = dim
+        self.embed = nn.Embedding(VOCAB_SIZE, dim, padding_idx=PAD)
+        self.blocks = nn.ModuleList([Block(dim, heads, dim * 4) for _ in range(layers)])
+        self.norm = nn.LayerNorm(dim)
+        self.lm_bias = nn.Parameter(torch.zeros(VOCAB_SIZE))
+        self.apply(self._init)
+
+    @staticmethod
+    def _init(module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, std=0.02)
+
+    def add_extension(self, layers, heads, before_norm=False):
+        """Append shared residual blocks after the original normalized representation."""
+        assert layers > 0 and not hasattr(self, 'extension')
+        self.extension_before_norm = bool(before_norm)
+        self.extension = nn.ModuleList([Block(self.dim, heads, 4*self.dim) for _ in range(layers)])
+        self.extension.apply(self._init)
+        # Identity at initialization preserves every existing readout exactly.
+        for block in self.extension:
+            nn.init.zeros_(block.attention.out.weight)
+            nn.init.zeros_(block.attention.out.bias)
+            nn.init.zeros_(block.ffn[2].weight)
+            nn.init.zeros_(block.ffn[2].bias)
+
+    def forward(self, tokens, condition=None, depth=None, extension_depth=None):
+        pad_mask = tokens.eq(PAD)
+        hidden = self.embed(tokens)
+        depth=len(self.blocks) if depth is None else int(depth)
+        if not 1<=depth<=len(self.blocks):
+            raise ValueError(f'Encoder depth {depth} is outside 1..{len(self.blocks)}')
+        for index, block in enumerate(self.blocks):
+            if index>=depth:
+                break
+            hidden = block(hidden, pad_mask, condition[index] if condition is not None else None)
+        # Local residue heads must not observe artificial states at padded
+        # positions; otherwise predictions near the C terminus depend on which
+        # other sequences share the batch. Valid transformer states are unchanged.
+        before_norm = getattr(self, 'extension_before_norm', False)
+        if not before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        extension = getattr(self, 'extension', ())
+        extension_depth = len(extension) if extension_depth is None else int(extension_depth)
+        if not 0 <= extension_depth <= len(extension):
+            raise ValueError(f'Extension depth {extension_depth} is outside 0..{len(extension)}')
+        for index, block in enumerate(extension):
+            if index >= extension_depth:
+                break
+            hidden = block(hidden, pad_mask).masked_fill(pad_mask.unsqueeze(-1), 0)
+        if before_norm:
+            hidden = self.norm(hidden).masked_fill(pad_mask.unsqueeze(-1), 0)
+        return hidden, pad_mask
+
+    def lm_logits(self, hidden):
+        # Weight tying, as in ESM-2's RobertaLMHead.
+        return F.linear(hidden, self.embed.weight) + self.lm_bias
+
+    def pool(self, tokens):
+        hidden, pad_mask = self.forward(tokens)
+        keep = (~pad_mask).to(hidden.dtype).unsqueeze(-1)
+        return (hidden * keep).sum(1) / keep.sum(1).clamp(min=1)
+
+
+class Model(nn.Module):
+    """ESM-2 backbone plus the eleven PEER task heads."""
+
+    CLASSES = {"solubility": 2, "subcellular_localization": 10,
+               "binary_localization": 2, "fold": 1195,
+               "yeast_ppi": 2, "human_ppi": 2}
+    REGRESSION = ("fluorescence", "stability", "beta_lactamase", "ppi_affinity")
+    PAIR = {"yeast_ppi", "human_ppi", "ppi_affinity"}
+
+    def __init__(self, layers=12, dim=480, heads=20):
+        super().__init__()
+        self.encoder = Encoder(layers=layers, dim=dim, heads=heads)
+        self.heads = nn.ModuleDict()
+        for task, n in self.CLASSES.items():
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, n))
+        for task in self.REGRESSION:
+            width = dim * 2 if task in self.PAIR else dim
+            self.heads[task] = nn.Sequential(
+                nn.Linear(width, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 1))
+        self.heads["secondary_structure"] = nn.Sequential(
+            nn.Linear(dim, dim), nn.GELU(), nn.LayerNorm(dim), nn.Linear(dim, 3))
+
+    def represent(self, task, batch, device, max_len=1024):
+        if task in self.PAIR:
+            a = self.encoder.pool(pad_batch(
+                [encode(x["sequence_a"], max_len) for x in batch], device))
+            b = self.encoder.pool(pad_batch(
+                [encode(x["sequence_b"], max_len) for x in batch], device))
+            return torch.cat([a, b], dim=-1)
+        return self.encoder.pool(pad_batch(
+            [encode(x["sequence"], max_len) for x in batch], device))
+
+
+def build(name="esm2_t12_35M"):
+    layers, dim, heads = CONFIGS[name]
+    model = Model(layers=layers, dim=dim, heads=heads)
+    return model, {"name": name, "layers": layers, "dim": dim, "heads": heads}
+
+
+if __name__ == "__main__":
+    for name in CONFIGS:
+        model, config = build(name)
+        backbone = sum(p.numel() for p in model.encoder.parameters())
+        total = sum(p.numel() for p in model.parameters())
+        print(f"{name:16s} backbone {backbone/1e6:7.2f}M   with heads {total/1e6:7.2f}M")

tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/submissions/S058/infer.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+export PYTHONDONTWRITEBYTECODE=1
+exec python3 "$(dirname "$0")/replay.py" "$1" "$2"