SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2302.13971 · arXiv.org · 2023

LLaMA: Open and Efficient Foundation Language Models

Naman Goyal, Armand Joulin, Gautier Izacard, Edouard Grave, Eric Hambro, Hugo Touvron, Baptiste Rozière, Thibaut Lavril, Faisal Azhar, Guillaume Lample, Timothée Lacroix, X. Martinet, and 2 more

arXiv · PDF · Open in the Atlas

Code that ran

37 of 58 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (9 of them constructed an object rather than computing a result; 3 honoured the contract we drafted, 0 violated it and 21 have no contract verdict; 13 failures of our instrument; 21 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2302.13971.json · badge: /api/ran/2302.13971.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
young-geng/easylm community
not in the paper's declared repositories
9 ran · 6 no recorded run
akanyaani/miniLLAMA community
not in the paper's declared repositories
6 ran · 3 no recorded run
grantslatton/llama.cpp community (classifier label)
classifier basis not recorded on the link
5 ran · 0 no recorded run
Lightning-AI/lit-llama community
not in the paper's declared repositories
4 ran · 4 no recorded run
beomi/koalpaca community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
ntunlplab/traditional-chinese-alpaca community (classifier label)
classifier basis not recorded on the link
2 ran · 2 no recorded run
copy not recorded community
not in the paper's declared repositories
2 ran · 1 no recorded run
aethercortex/llama-x community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
teelinsan/camoscio community (classifier label)
classifier basis not recorded on the link
1 ran · 1 no recorded run
abhaskumarsinha/Corpus2GPT community
not in the paper's declared repositories
1 ran · 0 no recorded run
stanfordbdhg/llama.cpp community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
longhao-chen/aicas2024 community (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
ofa-sys/expertllama community
not in the paper's declared repositories
0 ran · 1 no recorded run
ecnu-icalk/educhat community
Papers with Code archive
0 ran · 1 no recorded run
fsoft-ai4code/codecapybara community
Papers with Code archive
0 ran · 1 no recorded run
FunctionStatusWhere it lives
Carry Ran
ran on a synthesized input · constructed an object; no result was computed
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("a066e3b4457453fd")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Carry: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
from typing import NamedTuple

class Carry(NamedTuple):
    numerator: jax.Array
    denominator: jax.Array
    max_so_far: jax.Array

ARGS = {
    "numerator": jnp.array([1.0, 2.0, 3.0, 4.0]),
    "denominator": jnp.array([2.0, 3.0, 4.0, 5.0]),
    "max_so_far": jnp.array([5.0, 6.0, 7.0, 8.0]),
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Carry — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Carry output the recorded ndim 2 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
FeedForward Ran
ran on a synthesized input
akanyaani/miniLLAMA/model.py
code served (permissive licence) · get_code("6efcd693d3b4dc58")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

config = {
    'hidden_size': 6,
}

INIT_ARGS = {
    'config': config,
}

batch_size = 2
seq_len = 5

x = torch.randn(batch_size, seq_len, config['hidden_size'])

ARGS = {
    'x': x,
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
FlaxLLaMABlockCollection Ran
ran on a synthesized input · constructed an object; no result was computed
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("2b160cc445933c46")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, FlaxLLaMABlockCollection: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import numpy as np
from flax import linen as nn
from transformers.configuration_utils import PretrainedConfig

# Create a minimal config that satisfies the LLaMA attention requirements
class MinimalLLaMAConfig(PretrainedConfig):
    def __init__(self):
        super().__init__()
        self.hidden_size = 64
        self.num_attention_heads = 4
        self.num_key_value_heads = 2
        self.max_position_embeddings = 128
        self.initializer_range = 0.02
        self.residue_dropout = 0.1
        self.attention_dropout = 0.1
        self.scan_attention = False

config = MinimalLLaMAConfig()

# Create minimal input tensors
batch_size = 2
seq_length = 3
hidden_size = 64

hidden_states = jnp.ones((batch_size, seq_length, hidden_size), dtype=jnp.float32)
attention_mask = jnp.ones((batch_size, 1, seq_length, seq_length), dtype=jnp.float32)
position_ids = jnp.arange(seq_length).reshape(1, seq_length)
position_ids = jnp.broadcast_to(position_ids, (batch_size, seq_length))

ARGS = {
    'config': config,
    'dtype': jnp.float32,
    'param_dtype': jnp.float32,
    'precision': None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
einops, flax, jax, numpy, transformers — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type FlaxLLaMABlockCollection — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a FlaxLLaMABlockCollection output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
FlaxLLaMAMLP Ran
ran on a synthesized input · constructed an object; no result was computed
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("a4fb09d490cd772f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, FlaxLLaMAMLP: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import flax.linen as nn
from transformers.configuration_utils import PretrainedConfig
import numpy as np

class MockLLaMAConfig(PretrainedConfig):
    """Minimal mock config for LLaMA"""
    model_type = "llama"
    
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.hidden_size = 4
        self.intermediate_size = 8
        self.initializer_range = 0.02
        self.residue_dropout = 0.1

config = MockLLaMAConfig()

ARGS = {
    "config": config,
    "dtype": jnp.float32,
    "param_dtype": jnp.float32,
    "precision": None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax, numpy, transformers — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type FlaxLLaMAMLP — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a FlaxLLaMAMLP output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
GPT Ran
ran on a synthesized input · constructed an object; no result was computed
abhaskumarsinha/Corpus2GPT/models/GPT.py
code served (permissive licence) · get_code("ebfbcce998fad801")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, GPT: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import keras
import numpy as np

# Create minimal stand-in classes for decoder and embeddings

class MinimalDecoder(keras.layers.Layer):
    """Minimal decoder layer that accepts the required parameters."""
    def __init__(self, dropout_rate, num_heads, head_dims, fc_dim_factor, input_len=64):
        super().__init__()
        self.dropout_rate = dropout_rate
        self.num_heads = num_heads
        self.head_dims = head_dims
        self.fc_dim_factor = fc_dim_factor
        self.input_len = input_len
        # Build a simple dense layer to process input
        self.dense = keras.layers.Dense(1280)
    
    def call(self, x):
        return self.dense(x)


class MinimalEmbedding(keras.layers.Layer):
    """Minimal embedding layer that accepts input_len, vocab_size, and embed_dim."""
    def __init__(self, input_len, vocab_size, embed_dim=1280):
        super().__init__()
        self.input_len = input_len
        self.vocab_size = vocab_size
        self.embed_dim = embed_dim
        self.embedding = keras.layers.Embedding(vocab_size, embed_dim)
    
    def call(self, x):
        return self.embedding(x)


# Set up arguments for GPT initialization
ARGS = {
    'decoder': MinimalDecoder,
    'embeddings': MinimalEmbedding,
    'pos_embeddings': None,
    'embedding_size': 1280,
    'vocab_size': 100,
    'input_len': 64,
    'num_decoders': 2,
    'dropout_rate': 0.1,
    'num_heads': 8,
    'head_dims': 40,
    'fc_dim_factor': 5,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
keras, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type GPT — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a GPT output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
LLaMAConfig Ran
ran on a synthesized input · constructed an object; no result was computed
Lightning-AI/lit-llama/lit_llama/model.py
code served (permissive licence) · get_code("0d0deeba6c2a15d7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, LLaMAConfig: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from dataclasses import dataclass
from typing import List, Optional, Tuple, Union
from typing_extensions import Self

torch.manual_seed(0)

def find_multiple(n: int, k: int) -> int:
    if n % k == 0:
        return n
    return n + k - n % k

llama_configs = {'7B': dict(n_layer=32, n_head=32, n_embd=4096), '13B': dict(n_layer=40, n_head=40, n_embd=5120), '30B': dict(n_layer=60, n_head=52, n_embd=6656), '65B': dict(n_layer=80, n_head=64, n_embd=8192)}

@dataclass
class LLaMAConfig:
    block_size: int = 2048
    vocab_size: int = 32000
    padded_vocab_size: Optional[int] = None
    n_layer: int = 32
    n_head: int = 32
    n_embd: int = 4096

    def __post_init__(self):
        if self.padded_vocab_size is None:
            self.padded_vocab_size = find_multiple(self.vocab_size, 64)

    @classmethod
    def from_name(cls, name: str) -> Self:
        return cls(**llama_configs[name])

# Test instantiation to verify the dataclass works
config1 = LLaMAConfig()
config2 = LLaMAConfig(block_size=1024, vocab_size=16000, n_layer=16, n_head=16, n_embd=2048)
config3 = LLaMAConfig.from_name('7B')

ARGS = {
    'block_size': 2048,
    'vocab_size': 32000,
    'padded_vocab_size': None,
    'n_layer': 32,
    'n_head': 32,
    'n_embd': 4096,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch, typing_extensions — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type LLaMAConfig — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a LLaMAConfig output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MLP Ran
ran on a synthesized input · constructed an object; no result was computed
Lightning-AI/lit-llama/lit_llama/model.py
code served (permissive licence) · get_code("76a887e44ebc75d5")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MLP: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from dataclasses import dataclass
from typing import Optional

torch.manual_seed(0)

@dataclass
class LLaMAConfig:
    block_size: int = 2048
    vocab_size: int = 32000
    padded_vocab_size: Optional[int] = None
    n_layer: int = 32
    n_head: int = 32
    n_embd: int = 4096

    def __post_init__(self):
        if self.padded_vocab_size is None:
            self.padded_vocab_size = self.find_multiple(self.vocab_size, 64)

    @staticmethod
    def find_multiple(n: int, k: int) -> int:
        if n % k == 0:
            return n
        return n + k - n % k

def find_multiple(n: int, k: int) -> int:
    if n % k == 0:
        return n
    return n + k - n % k

config = LLaMAConfig(
    block_size=2048,
    vocab_size=32000,
    n_layer=32,
    n_head=32,
    n_embd=4096
)

ARGS = {
    "config": config
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, typing_extensions — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MLP — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MLP output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
RMSNorm Ran
ran on a synthesized input
akanyaani/miniLLAMA/model.py
code served (permissive licence) · get_code("0ea811a4ad9027b8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float, shape (2, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

class RMSNorm(nn.Module):

    def __init__(self, hidden_size, eps=1e-06):
        """
        LlamaRMSNorm is equivalent to T5LayerNorm
        https://arxiv.org/pdf/1910.07467.pdf
        """
        super().__init__()
        self.weight = nn.Parameter(torch.ones(hidden_size))
        self.variance_epsilon = eps

    def forward(self, hidden_states):
        input_dtype = hidden_states.dtype
        hidden_states = hidden_states.to(torch.float32)
        variance = hidden_states.pow(2).mean(-1, keepdim=True)
        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
        return self.weight * hidden_states.to(input_dtype)


INIT_ARGS = {
    'hidden_size': 4,
    'eps': 1e-06,
}

ARGS = {
    'hidden_states': torch.randn(2, 3, 4),
}

if __name__ == '__main__':
    model = RMSNorm(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Input shape: {ARGS['hidden_states'].shape}")
    print(f"Output shape: {output.shape}")
    print(f"Output dtype: {output.dtype}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
RMSNorm Ran
ran on a synthesized input · constructed an object; no result was computed
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("aaa8a447973c0f68")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, RMSNorm: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import flax.linen as nn

# The RMSNorm class is a Flax module that normalizes input using RMS normalization
# It takes:
# - dim: the dimension of the input features
# - eps: small constant for numerical stability
# - dtype: data type for computation
# - param_dtype: data type for parameters

# To test this, we need to create valid arguments for the RMSNorm module
# The module expects:
# - dim: int - the feature dimension
# - eps: float - epsilon for stability (optional, defaults to 1e-06)
# - dtype: jnp.dtype - computation dtype (optional, defaults to jnp.float32)
# - param_dtype: jnp.dtype - parameter dtype (optional, defaults to jnp.float32)

ARGS = {
    'dim': 4,
    'eps': 1e-06,
    'dtype': jnp.float32,
    'param_dtype': jnp.float32,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
flax, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type RMSNorm — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a RMSNorm output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
RMSNorm Ran
ran on a synthesized input · constructed an object; no result was computed
Lightning-AI/lit-llama/lit_llama/model.py
code served (permissive licence) · get_code("133fab2290f71687")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, RMSNorm: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# The RMSNorm.__init__ takes: size (int), dim (int, default=-1), eps (float, default=1e-05)
# The forward method uses:
# - self.scale: Parameter with shape (size,)
# - self.eps: float for numerical stability
# - self.dim: int for which dimension to normalize over
# - x: input tensor

# Create a small input tensor for testing
# Using distinct sizes to probe dimensions: batch=2, feature=4, sequence=3
x = torch.randn(2, 3, 4)  # batch_size=2, seq_len=3, hidden_dim=4

ARGS = {
    "size": 4,           # Must match the last dimension of input for scale parameter
    "dim": -1,           # Normalize over last dimension
    "eps": 1e-05,        # Small epsilon for numerical stability
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type RMSNorm — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a RMSNorm output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
RotaryEmbedding Ran
ran on a synthesized input · constructed an object; no result was computed
akanyaani/miniLLAMA/model.py
code served (permissive licence) · get_code("fd513b4604a55972")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, RotaryEmbedding: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# RotaryEmbedding parameters:
# - dim: int (embedding dimension)
# - max_position_embeddings: int (max sequence length)
# - base: int (base for frequency calculation)
# - device: device or None

# Looking at the forward method:
# - x: tensor with dtype that gets used
# - position_ids: tensor of shape (seq_len, n_positions) that gets converted to float
# - seq_len: optional int (not actually used in the function body)

# We need to construct inputs for forward() as well
dim = 4
max_position_embeddings = 128
base = 10000
device = None

# For forward pass, we need:
# - x: a tensor with a dtype (used to cast output)
# - position_ids: a 2D tensor of integers

batch_size = 2
seq_len = 3
n_positions = 5

x = torch.randn(batch_size, dim, dtype=torch.float32)
position_ids = torch.arange(n_positions, dtype=torch.int64).unsqueeze(0).expand(batch_size, -1)

ARGS = {
    'dim': dim,
    'max_position_embeddings': max_position_embeddings,
    'base': base,
    'device': device,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type RotaryEmbedding — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a RotaryEmbedding output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
_chunk_attention_bias Ran
ran; our contract draft was wrong, not the code
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("d81e74d07a61f182")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 4, dtype family float, shape (1, 1, 2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import numpy as np

ARGS = {
    "query_chunk_size": 2,
    "key_chunk_size": 3,
    "bias": jnp.ones((1, 1, 8, 12), dtype=jnp.float32),
    "deterministic": False,
    "attn_dropout": jnp.ones((1, 1, 8, 12), dtype=jnp.float32) * -0.5,
    "attn_pdrop": 0.1,
    "causal": True,
    "dtype": jnp.float32,
    "query_chunk_idx": 0,
    "key_chunk_idx": 0,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 4, dtype family float, shape (1, 1, 2, 3) — shape (1, 1, 2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
apply_rotary_pos_emb Ran
ran; our contract draft was wrong, not the code
akanyaani/miniLLAMA/model.py
code served (permissive licence) · get_code("705bfc1394637339")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 4, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create small tensors with distinct dimensions
batch_size = 2
seq_len = 3
hidden_dim = 4

# q: query tensor (batch_size, seq_len, hidden_dim)
q = torch.randn(batch_size, seq_len, hidden_dim)

# k: key tensor (batch_size, seq_len, hidden_dim)
k = torch.randn(batch_size, seq_len, hidden_dim)

# cos: cosine positional embedding (seq_len, hidden_dim)
cos = torch.randn(seq_len, hidden_dim)

# sin: sine positional embedding (seq_len, hidden_dim)
sin = torch.randn(seq_len, hidden_dim)

# position_ids: position indices (batch_size, seq_len)
position_ids = torch.arange(seq_len).unsqueeze(0).expand(batch_size, -1)

# unsqueeze_dim: dimension to unsqueeze at
unsqueeze_dim = 1

ARGS = {
    "q": q,
    "k": k,
    "cos": cos,
    "sin": sin,
    "position_ids": position_ids,
    "unsqueeze_dim": unsqueeze_dim
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 4, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
bf16_to_fp32 Ran
ran on a synthesized input
grantslatton/llama.cpp/convert.py
code served (permissive licence) · get_code("3af74b5c95d41acd")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a small bfloat16 array represented as uint16
# bfloat16 is a 16-bit float format, we'll create some sample uint16 values
# that represent valid bfloat16 encoded data
bf16_array = np.array([0x3f80, 0x4000, 0x4040, 0x4080], dtype=np.uint16)

ARGS = {
    "bf16_arr": bf16_array
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
blockwise_attn Ran
ran; our contract draft was wrong, not the code
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("4932ae36f745aea2")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned ArrayImpl, ndim 4, dtype family float, shape (2, 4096, 3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
import jax.random as jr

# Set seed for reproducibility
key = jr.PRNGKey(0)

# Define minimal tensor dimensions
batch_size = 2
q_len = 4096  # Must be divisible by query_chunk_size
kv_len = 4096  # Must be divisible by key_chunk_size
num_heads = 3
dim_per_head = 4
query_chunk_size = 2048
key_chunk_size = 2048

# Create query, key, value tensors
query = jnp.ones((batch_size, q_len, num_heads, dim_per_head), dtype=jnp.float32)
key = jnp.ones((batch_size, kv_len, num_heads, dim_per_head), dtype=jnp.float32)
value = jnp.ones((batch_size, kv_len, num_heads, dim_per_head), dtype=jnp.float32)

# Create optional bias tensor (broadcastable to (batch, num_heads, q_len, kv_len))
bias = jnp.zeros((1, 1, q_len, kv_len), dtype=jnp.float32)

# Create dropout RNG
dropout_rng = jr.PRNGKey(1)

ARGS = {
    "query": query,
    "key": key,
    "value": value,
    "bias": bias,
    "deterministic": True,
    "dropout_rng": dropout_rng,
    "attn_pdrop": 0.0,
    "causal": True,
    "query_chunk_size": query_chunk_size,
    "key_chunk_size": key_chunk_size,
    "dtype": jnp.float32,
    "policy": jax.checkpoint_policies.nothing_saveable(),
    "precision": None,
    "float32_logits": True,
    "prevent_cse": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
einops, jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 4, dtype family float, shape (2, 4096, 3, 4) — shape (2, 4096, 3, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
build_rope_cache Ran
ran, honoured the contract we drafted
Lightning-AI/lit-llama/lit_llama/model.py
code served (permissive licence) · get_code("8a187cb05b43141d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (8, 2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

ARGS = {
    "seq_len": 8,
    "n_elem": 4,
    "dtype": torch.float32,
    "device": torch.device("cpu"),
    "base": 10000,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (8, 2, 2) — shape (8, 2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
create_masks Ran
ran; our contract draft was wrong, not the code
akanyaani/miniLLAMA/model.py
code served (permissive licence) · get_code("31c156187744eaa5")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, dtype family float, shape (2, 1, 4, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a small input tensor with shape (batch_size=2, seq_len=4)
# Values are integers, with some zeros to test padding mask
inp = torch.tensor([
    [1, 2, 3, 0],
    [5, 0, 0, 0]
], dtype=torch.int64)

# device can be None or 'cpu'
device = None

ARGS = {
    'inp': inp,
    'device': device
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 1, 4, 4) — shape (2, 1, 4, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
encode_prompt Ran
ran; our contract draft was wrong, not the code
beomi/koalpaca/generate_instruction.py
code served (permissive licence) · get_code("9b2dd0265fc6e6b6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re
import tempfile
import os

# Create a temporary prompt.txt file
temp_dir = tempfile.mkdtemp()
prompt_file = os.path.join(temp_dir, 'prompt.txt')
with open(prompt_file, 'w') as f:
    f.write('You are a helpful assistant.\n')

# Change to temp directory so the function can find prompt.txt
original_dir = os.getcwd()
os.chdir(temp_dir)

# Define the prompt_instructions parameter
prompt_instructions = [
    {
        'instruction': 'Classify  the   sentiment',
        'input': 'This movie is great!',
        'output': 'Positive'
    },
    {
        'instruction': 'Translate to French',
        'input': 'Hello world',
        'output': 'Bonjour le monde'
    },
    {
        'instruction': 'Summarize the text',
        'input': '',
        'output': 'This is a summary'
    }
]

ARGS = {
    'prompt_instructions': prompt_instructions
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
find_multiple Ran
ran, honoured the contract we drafted
this paper's copy was not recorded; identical code first harvested from time-series-foundation-models/lag-llama
pointer only · get_code("aba86ffbed27ba65")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

find_word_in_string Ran
ran; our contract draft was wrong, not the code
beomi/koalpaca/generate_instruction.py
code served (permissive licence) · get_code("8ca6a5f9f77053c2")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Match. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re

# The function find_word_in_string takes two parameters:
# w: a word (string) to search for
# s: a string to search in
# It uses re.compile with word boundary matching and case-insensitive flag

ARGS = {
    "w": "hello",
    "s": "Hello world, this is a test string with HELLO in it"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Match — a Match output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Match output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_prompt Ran
ran on a synthesized input
aethercortex/llama-x/src/generate.py
code served (permissive licence) · get_code("96db588eb784d7e4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function generate_prompt takes two parameters:
# - instruction: a string describing a task
# - input: an optional string providing further context

ARGS = {
    'instruction': 'Summarize the following text',
    'input': 'The quick brown fox jumps over the lazy dog'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_prompt Ran
ran on a synthesized input
ntunlplab/traditional-chinese-alpaca/code/finetune.py
code served (permissive licence) · get_code("911a8a5064b9a121")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function takes a data_point parameter which is a dict with keys:
# 'instruction', 'input', 'output'
data_point = {
    'instruction': 'Translate the following English text to Traditional Chinese.',
    'input': 'Hello, how are you?',
    'output': '你好,你好嗎?'
}

ARGS = {
    'data_point': data_point
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_prompt Ran
ran on a synthesized input
ntunlplab/traditional-chinese-alpaca/code/inference.py
code served (permissive licence) · get_code("d7d073a5b1729e58")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

instruction = "請將以下文本翻譯成英文"
input_text = "你好,世界"

ARGS = {
    "instruction": instruction,
    "input": input_text
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_prompt Ran
ran on a synthesized input
teelinsan/camoscio/eval/src/utils.py
code served (permissive licence) · get_code("efa79bea90c5fd5a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

ARGS = {
    "instruction": "Traduci il seguente testo in italiano",
    "input": "Hello, how are you?"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_gradient_checkpoint_policy Ran
ran; our contract draft was wrong, not the code
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("a9b09c32ed58621c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax

ARGS = {
    'name': 'everything_saveable'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_llama Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from shawnricecake/agile-quant
pointer only; the stored copy get_code serves, from shawnricecake/agile-quant, is pointer only (licence: NONE) · get_code("2c201f017173954b")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

get_names_from_parition_spec Ran
ran; our contract draft was wrong, not the code
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("dad72196bdb2301a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# - Takes partition_specs as input
# - If it's a dict, gets the values
# - Iterates through items
# - Each item can be None, a string, or a nested structure (recursive case)
# - Returns a list of axis names (strings)

# Test case 1: Simple list with strings and None
partition_specs_1 = ["batch", None, "hidden", "batch"]

# Test case 2: Dict with string values
partition_specs_2 = {
    "weight": "batch",
    "bias": None,
    "embedding": "hidden"
}

# Test case 3: Nested structure with lists/tuples
partition_specs_3 = [
    "batch",
    None,
    ["hidden", "vocab"],
    ("sequence", None, "batch")
]

# Test case 4: Complex nested dict
partition_specs_4 = {
    "layer1": ["batch", "hidden"],
    "layer2": None,
    "layer3": {
        "weight": "vocab",
        "bias": ["batch", "hidden"]
    }
}

ARGS = {
    "partition_specs": partition_specs_3
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_op_by_name Ran
ran; our contract draft was wrong, not the code
stanfordbdhg/llama.cpp/awq-py/awq/apply_awq.py
code served (permissive licence) · get_code("d06d467f98e77d68")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned SimpleSubModule. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a simple nested module structure
class SimpleSubModule(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

class MainModule(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(4, 3)
        self.layer2 = SimpleSubModule()
        self.layer3 = nn.ReLU()
    
    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        return x

# Instantiate the main module
main_module = MainModule()

# The op_name should be a valid submodule name that exists in the module's named_modules()
# Valid options include: '', 'layer1', 'layer2', 'layer2.linear', 'layer3'
op_name = 'layer2'

ARGS = {
    'module': main_module,
    'op_name': op_name
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SimpleSubModule — a SimpleSubModule output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleSubModule output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
handle_metadata Ran
ran on a synthesized input
longhao-chen/aicas2024/convert-llama-ggml-to-gguf.py
code served (permissive licence) · get_code("6f0f4989a4b70aeb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from pathlib import Path
from unittest.mock import Mock, MagicMock
import tempfile
import json

# Create a temporary directory structure for metadata
temp_dir = tempfile.TemporaryDirectory()
metadata_dir = Path(temp_dir.name) / "metadata"
metadata_dir.mkdir(exist_ok=True)

vocab_dir = Path(temp_dir.name) / "vocab"
vocab_dir.mkdir(exist_ok=True)

# Create a mock convert module with necessary classes
class LazyTensor:
    def __init__(self):
        self.shape = None

class Params:
    def __init__(self):
        self.n_vocab = 512
        self.n_ff = 2048
    
    @staticmethod
    def loadHFTransformerJson(fakemodel, hf_config_path):
        params = Params()
        return params
    
    @staticmethod
    def loadOriginalParamsJson(fakemodel, orig_config_path):
        params = Params()
        return params

class VocabFactory:
    def __init__(self, vocab_path):
        self.vocab_path = vocab_path
    
    def load_vocab(self, vocab_types, metadata_dir):
        vocab = {i: f"token_{i}" for i in range(512)}
        special_vocab = {"<pad>": 0, "<unk>": 1, "<bos>": 2, "<eos>": 3}
        return vocab, special_vocab

def check_vocab_size(params, vocab):
    pass

# Mock convert module
convert = Mock()
convert.LazyTensor = LazyTensor
convert.Params = Params
convert.VocabFactory = VocabFactory
convert.check_vocab_size = check_vocab_size

# Inject mock convert into sys.modules
import sys
sys.modules['convert'] = convert

# Create config.json in metadata directory
config_json_path = metadata_dir / 'config.json'
config_json_path.write_text(json.dumps({
    "vocab_size": 512,
    "hidden_size": 768,
    "num_hidden_layers": 12,
    "intermediate_size": 2048
}))

# Create cfg object
cfg = Mock()
cfg.model_metadata_dir = metadata_dir
cfg.vocab_dir = vocab_dir
cfg.vocabtype = "default"

# Create hp object
hp = Mock()
hp.n_vocab = 512
hp.n_ff = 2048

ARGS = {
    "cfg": cfg,
    "hp": hp
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
convert, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
jload Ran
ran; our contract draft was wrong, not the code
aethercortex/llama-x/src/utils.py
code served (permissive licence) · get_code("d07d04439cd1d44f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import io
import json
import tempfile
import os

# Create a temporary JSON file with test data
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "test.json")

test_data = {
    "key1": "value1",
    "key2": [1, 2, 3],
    "key3": {"nested": "dict"}
}

with open(temp_file, 'w') as f:
    json.dump(test_data, f)

# Define ARGS with the file path
ARGS = {
    "f": temp_file,
    "mode": "r"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
many Ran
ran on a synthesized input
grantslatton/llama.cpp/grammar.py
code served (permissive licence) · get_code("e1e39d01d0f3f81a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# The `many` function takes a `parser` parameter
# The parser is a callable that:
# 1. Takes a string `s` as input
# 2. Returns a tuple of (remaining_string, parsed_value)
# 3. Raises ValueError when it can't parse anymore

# We need to create a parser function that can parse multiple values from a string
def simple_parser(s):
    """
    A simple parser that extracts space-separated integers from a string.
    Returns (remaining_string, parsed_value) or raises ValueError.
    """
    s = s.lstrip()  # remove leading whitespace
    if not s:
        raise ValueError("No more input to parse")
    
    # Find the first space or end of string
    space_idx = s.find(' ')
    if space_idx == -1:
        # No space found, take the whole string
        token = s
        remaining = ""
    else:
        token = s[:space_idx]
        remaining = s[space_idx:]
    
    try:
        value = int(token)
        return (remaining, value)
    except ValueError:
        raise ValueError(f"Could not parse '{token}' as integer")

ARGS = {
    "parser": simple_parser
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
none_of Ran
ran on a synthesized input
grantslatton/llama.cpp/grammar.py
code served (permissive licence) · get_code("24f233cbf074bc95")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

def none_of(chars):
    def inner(s):
        if s[0] in chars:
            raise ValueError('unexpected ' + s[0])
        return (s[1:], s[0])
    return inner

# chars parameter: a string or collection of characters to check against
chars = "abc"

ARGS = {
    "chars": chars
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
one_of Ran
ran on a synthesized input
grantslatton/llama.cpp/grammar.py
code served (permissive licence) · get_code("42cd9e49542e405f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned function. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

# one_of is a parser combinator that accepts a string and a set of valid characters
# It returns a function that parses one character from the input string

# The function takes 'chars' as a parameter - a string of valid characters
# The inner function takes 's' (a string) and returns a tuple of (remaining_string, parsed_char)

# Let's create valid arguments for the 'one_of' function
ARGS = {
    'chars': 'abc'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
post_process_gpt3_response Ran
ran, honoured the contract we drafted
beomi/koalpaca/generate_instruction.py
code served (permissive licence) · get_code("a5e4ad4e11cf2143")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re
import string

# Construct valid arguments for post_process_gpt3_response
ARGS = {
    'num_prompt_instructions': 2,
    'response': {
        'text': '\n### 3. Instruction: Write a summary of the text\nInput: The quick brown fox jumps over the lazy dog\nOutput: A fast fox jumps over a slow dog\n### 4. Instruction: Translate to Spanish\nInput: Hello world\nOutput: Hola mundo',
        'finish_reason': 'stop'
    }
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
repeat_kv Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
akanyaani/miniLLAMA/model.py
code served (permissive licence) · get_code("31333a36df31a820")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, dtype family float, shape (2, 6, 4, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function repeat_kv takes:
# - hidden_states: a tensor with shape (batch, num_key_value_heads, slen, head_dim)
# - n_rep: an integer representing the repetition factor

# Create a small tensor with appropriate shape
batch = 2
num_key_value_heads = 3
slen = 4
head_dim = 5
n_rep = 2

hidden_states = torch.randn(batch, num_key_value_heads, slen, head_dim)

ARGS = {
    "hidden_states": hidden_states,
    "n_rep": n_rep,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 6, 4, 5) — shape (2, 6, 4, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
translate_tensor_name Ran
ran on a synthesized input
grantslatton/llama.cpp/convert-lora-to-ggml.py
code served (permissive licence) · get_code("17761b6cb6d0876d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import re
import sys

HF_SUBLAYER_TO_GGML = {'self_attn.q_proj': 'attention.wq', 'self_attn.k_proj': 'attention.wk', 'self_attn.v_proj': 'attention.wv', 'self_attn.o_proj': 'attention.wo', 'mlp.gate_proj': 'feed_forward.w1', 'mlp.down_proj': 'feed_forward.w2', 'mlp.up_proj': 'feed_forward.w3', 'input_layernorm': 'attention_norm', 'post_attention_layernorm': 'ffn_norm'}

def translate_tensor_name(t: str) -> str:
    match = re.match('.*layers\\.(\\d+)\\.(\\w+\\.\\w+)\\.lora_(A|B)\\.weight', t)
    if match:
        nn = match.group(1)
        sub_layer = match.group(2)
        lora_type = match.group(3)
        sub_layer_renamed = HF_SUBLAYER_TO_GGML.get(sub_layer)
        if sub_layer_renamed is None:
            print(f'Error: unrecognized sub-layer {sub_layer} in tensor {t}')
            sys.exit(1)
        output_string = f'layers.{nn}.{HF_SUBLAYER_TO_GGML[sub_layer]}.weight.lora{lora_type}'
        return output_string
    else:
        print(f'Error: unrecognized tensor {t}')
        sys.exit(1)

ARGS = {
    't': 'model.layers.5.self_attn.q_proj.lora_A.weight'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
with_sharding_constraint Ran
ran; our contract draft was wrong, not the code
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("6c8893718b619284")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp
from jax.interpreters import pxla

# Set up a minimal JAX mesh context for testing
# We need to ensure the function can access mesh information
import jax.experimental.pjit as pjit

# Create small test data
x = jnp.array([[1.0, 2.0, 3.0, 4.0],
                [5.0, 6.0, 7.0, 8.0]])

# Test with simple string partition spec
partition_specs_1 = "batch"

# Test with nested/structured partition specs (dict case)
partition_specs_2 = {
    "layer1": "batch",
    "layer2": ["batch", "model"],
    "layer3": None
}

# Test with None partition spec
partition_specs_3 = None

# Test with list of partition specs
partition_specs_4 = ["batch", None, "model"]

ARGS = {
    "x": x,
    "partition_specs": partition_specs_1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Attention Not yet run
unverified (harvested, no recorded run)
akanyaani/miniLLAMA/model.py
code served (permissive licence) · get_code("00a9dc7ef03e2fcc")
How it ran

no invocation recorded.

Block Not yet run
unverified (harvested, no recorded run)
Lightning-AI/lit-llama/lit_llama/model.py
code served (permissive licence) · get_code("d24315a7d247960d")
How it ran

no invocation recorded.

CausalSelfAttention Not yet run
unverified (harvested, no recorded run)
Lightning-AI/lit-llama/lit_llama/model.py
code served (permissive licence) · get_code("5a58d3796ebd39f1")
How it ran

no invocation recorded.

DecoderBlock Not yet run
unverified (harvested, no recorded run)
akanyaani/miniLLAMA/model.py
code served (permissive licence) · get_code("dba8af448d5b7b39")
How it ran

no invocation recorded.

FlaxLLaMAAttention Not yet run
unverified (harvested, no recorded run)
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("733d82a9306baa8b")
How it ran

no invocation recorded.

FlaxLLaMABlock Not yet run
unverified (harvested, no recorded run)
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("7e8dcebe492702bb")
How it ran

no invocation recorded.

FlaxLLaMAModule Not yet run
unverified (harvested, no recorded run)
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("9238f425f871bc11")
How it ran

no invocation recorded.

LLAMA Not yet run
unverified (harvested, no recorded run)
akanyaani/miniLLAMA/model.py
code served (permissive licence) · get_code("10092db6d72af6ab")
How it ran

no invocation recorded.

LLaMA Not yet run
unverified (harvested, no recorded run)
Lightning-AI/lit-llama/lit_llama/model.py
code served (permissive licence) · get_code("cad096e5b0761afb")
How it ran

no invocation recorded.

apply_rope Not yet run
unverified (harvested, no recorded run)
Lightning-AI/lit-llama/lit_llama/model.py
code served (permissive licence) · get_code("7137105772c52074")
How it ran

no invocation recorded.

apply_rotary_emb Not yet run
unverified (harvested, no recorded run)
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("f280056a639ae634")
How it ran

no invocation recorded.

blockwise_ffn Not yet run
unverified (harvested, no recorded run)
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("4833ab3506125762")
How it ran

no invocation recorded.

gen Not yet run
unverified (harvested, no recorded run)
ofa-sys/expertllama/model/gen_demo.py
code served (permissive licence) · get_code("ef609b4fb59efa8a")
How it ran

no invocation recorded.

generate_and_tokenize_prompt Not yet run
unverified (harvested, no recorded run)
ntunlplab/traditional-chinese-alpaca/code/finetune.py
code served (permissive licence) · get_code("ec1a43f948c4bfb1")
How it ran

no invocation recorded.

get_conv_template Not yet run
unverified (harvested, no recorded run)
aethercortex/llama-x/src/conversation.py
code served (permissive licence) · get_code("614f3f063d0ec7f0")
How it ran

no invocation recorded.

initialize_model_and_tokenizer Not yet run
unverified (harvested, no recorded run)
ecnu-icalk/educhat/demo/educhat_api.py
pointer only (licence: NONE) · get_code("50924ee98cd1539e")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, ecnu-icalk/educhat when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

llama_sequential Not yet run
unverified (harvested, no recorded run)
this paper's copy was not recorded; identical code first harvested from aozhongzhang/magr
pointer only · get_code("8a49f06400cfa533")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

load_model Not yet run
unverified (harvested, no recorded run)
fsoft-ai4code/codecapybara/deploy/run_hf.py
code served (permissive licence) · get_code("bb9d66258a238b9c")
How it ran

no invocation recorded.

names_in_current_mesh Not yet run
unverified (harvested, no recorded run)
young-geng/easylm/EasyLM/models/llama/llama_model.py
code served (permissive licence) · get_code("a8530c4a22be1de7")
How it ran

no invocation recorded.

openai_call Not yet run
unverified (harvested, no recorded run)
teelinsan/camoscio/eval/qa_em_gpt_eval.py
code served (permissive licence) · get_code("690c9b43da9c18a8")
How it ran

no invocation recorded.

tokenize Not yet run
unverified (harvested, no recorded run)
ntunlplab/traditional-chinese-alpaca/code/finetune.py
code served (permissive licence) · get_code("f54de390493549bb")
How it ran

no invocation recorded.

Also present in other papers' code

Of 58 samples lifted from this paper's linked repositories, 58 carry a function identity and 0 do not. Of the 58 distinct functions with an identity, 26 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 0 the same month, 26 later) and 32 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
get_conv_template 69 other papers
3 dated earlier, 65 later, 1 undated
1911.03705 (2019-11)
CommonGen: A Constrained Text Generation Challenge for Generative Commonsense Reasoning
2112.05682 (2021-12)
Self-attention Does Not Need $O(n^2)$ Memory
2204.07705 (2022-04)
SUPER-NATURALINSTRUCTIONS: Generalization via Declarative Instructions on 1600+ NLP Tasks
and 66 more not named here
jload 46 other papers
46 later
2305.12870 (2023-05)
Lion: Adversarial Distillation of Proprietary Large Language Models
2305.13068 (2023-05)
Making Language Models Better Tool Learners with Execution Feedback
2305.14825 (2023-05)
Large Language Models are In-Context Semantic Reasoners rather than Symbolic Reasoners
and 43 more not named here
find_word_in_string 11 other papers
1 dated earlier, 9 later, 1 same year, order not determinable
2212.10560 (2022-12)
SELF-INSTRUCT: Aligning Language Models with Self-Generated Instructions
2023.findings-emnlp.836 (2023 (year only))
Ensemble-Instruct: Generating Instruction-Tuning Data with a Heterogeneous Mixture of LMs
2305.14825 (2023-05)
Large Language Models are In-Context Semantic Reasoners rather than Symbolic Reasoners
and 8 more not named here
find_multiple
brick of this paper's assembly: helper
9 other papers
9 later
2310.06434 (2023-10)
Whispering LLaMA: A Cross-Modal Generative Error Correction Framework for Speech Recognition
2310.08278 (2023-10)
Lag-Llama: Towards Foundation Models for Probabilistic Time Series Forecasting
2310.08581 (2023-10)
Universal Visual Decomposer: Long-Horizon Manipulation Made Easy
and 6 more not named here
encode_prompt 7 other papers
7 later
2305.14825 (2023-05)
Large Language Models are In-Context Semantic Reasoners rather than Symbolic Reasoners
2308.04948 (2023-08)
Extrapolating Large Language Models to Non-English by Aligning Languages
2312.11875 (2023-12)
Sparse is Enough in Fine-tuning Pre-trained Large Language Models
and 4 more not named here
post_process_gpt3_response 7 other papers
7 later
2305.14825 (2023-05)
Large Language Models are In-Context Semantic Reasoners rather than Symbolic Reasoners
2308.04948 (2023-08)
Extrapolating Large Language Models to Non-English by Aligning Languages
2312.11875 (2023-12)
Sparse is Enough in Fine-tuning Pre-trained Large Language Models
and 4 more not named here
get_llama
brick of this paper's assembly: entry
4 other papers
4 later
2307.08072 (2023-07)
Do Emergent Abilities Exist in Quantized Large Language Models: An Empirical Study
2310.01382 (2023-10)
Compressing LLMs: The Truth is Rarely Pure and Never Simple
2312.05693 (2023-12)
Agile-Quant: Activation-Guided Quantization for Faster Inference of LLMs on the Edge
and 1 more not named here
apply_rope
brick of this paper's assembly: helper
3 other papers
3 later
2310.06434 (2023-10)
Whispering LLaMA: A Cross-Modal Generative Error Correction Framework for Speech Recognition
2310.08581 (2023-10)
Universal Visual Decomposer: Long-Horizon Manipulation Made Easy
2402.05457 (2024-02)
It's Never Too Late: Fusing Acoustic Information into Large Language Models for Automatic Speech Recognition
build_rope_cache
brick of this paper's assembly: helper
3 other papers
3 later
2310.06434 (2023-10)
Whispering LLaMA: A Cross-Modal Generative Error Correction Framework for Speech Recognition
2310.08581 (2023-10)
Universal Visual Decomposer: Long-Horizon Manipulation Made Easy
2402.05457 (2024-02)
It's Never Too Late: Fusing Acoustic Information into Large Language Models for Automatic Speech Recognition
blockwise_attn
brick of this paper's assembly: helper
2 other papers
2 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models
2406.09279 (2024-06)
Unpacking DPO and PPO: Disentangling Best Practices for Learning from Preference Feedback
blockwise_ffn
brick of this paper's assembly: helper
2 other papers
2 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models
2406.09279 (2024-06)
Unpacking DPO and PPO: Disentangling Best Practices for Learning from Preference Feedback
get_names_from_parition_spec
brick of this paper's assembly: helper
2 other papers
2 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models
2406.09279 (2024-06)
Unpacking DPO and PPO: Disentangling Best Practices for Learning from Preference Feedback
get_op_by_name 2 other papers
2 later
2402.18158 (2024-02)
Evaluating Quantized Large Language Models
2410.23918 (2024-10)
BitStack: Any-Size Compression of Large Language Models in Variable Memory Environments
Carry
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models
FlaxLLaMAAttention
brick of this paper's assembly: model
1 other paper
1 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models
FlaxLLaMABlock
brick of this paper's assembly: model
1 other paper
1 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models
FlaxLLaMABlockCollection
brick of this paper's assembly: model
1 other paper
1 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models
FlaxLLaMAMLP
brick of this paper's assembly: model
1 other paper
1 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models
FlaxLLaMAModule
brick of this paper's assembly: entry
1 other paper
1 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models
RMSNorm
brick of this paper's assembly: model
1 other paper
1 later · 1 only as an assembly brick
2307.09288 (2023-07)
Llama 2: Open Foundation and Fine-Tuned Chat Models

Shown: the 20 functions present in the most other papers. 6 more shared functions are not listed here.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

More are linked than shown here.

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

We introduce LLaMA, a collection of foundation language models ranging from 7B to 65B parameters. We train our models on trillions of tokens, and show that it is possible to train state-of-the-art models using publicly available datasets exclusively, without resorting to proprietary and inaccessible datasets. In particular, LLaMA-13B outperforms GPT-3 (175B) on most benchmarks, and LLaMA-65B is competitive with the best models, Chinchilla-70B and PaLM-540B. We release all our models to the research community 1 .

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2302.13971")
get_code_for_paper("2302.13971")
have("2302.13971")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2302.13971.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2302.13971.svg)](https://syntology.ai/paper/2302.13971)

Connect an agent — have() is free.