Add files using upload-large-folder tool

testbed/EleutherAI__lm-evaluation-harness/CODEOWNERS

@@ -0,0 +1 @@
+* @haileyschoelkopf @lintangsutawika @baberabb

testbed/EleutherAI__lm-evaluation-harness/pyproject.toml

@@ -0,0 +1,107 @@
+[build-system]
+requires = ["setuptools>=40.8.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lm_eval"
+version = "0.4.4"
+authors = [
+    {name="EleutherAI", email="contact@eleuther.ai"}
+]
+description = "A framework for evaluating language models"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.8"
+license = { "text" = "MIT" }
+dependencies = [
+    "accelerate>=0.26.0",
+    "evaluate",
+    "datasets>=2.16.0",
+    "evaluate>=0.4.0",
+    "jsonlines",
+    "numexpr",
+    "peft>=0.2.0",
+    "pybind11>=2.6.2",
+    "pytablewriter",
+    "rouge-score>=0.0.4",
+    "sacrebleu>=1.5.0",
+    "scikit-learn>=0.24.1",
+    "sqlitedict",
+    "torch>=1.8",
+    "tqdm-multiprocess",
+    "transformers>=4.1",
+    "zstandard",
+    "dill",
+    "word2number",
+    "more_itertools",
+]
+
+[tool.setuptools.packages.find]
+include = ["lm_eval*"]
+
+# required to include yaml files in pip installation
+[tool.setuptools.package-data]
+lm_eval = ["**/*.yaml", "tasks/**/*"]
+
+[project.scripts]
+lm-eval = "lm_eval.__main__:cli_evaluate"
+lm_eval = "lm_eval.__main__:cli_evaluate"
+
+[project.urls]
+Homepage = "https://github.com/EleutherAI/lm-evaluation-harness"
+Repository = "https://github.com/EleutherAI/lm-evaluation-harness"
+
+[project.optional-dependencies]
+api = ["requests", "aiohttp", "tenacity", "tqdm", "tiktoken"]
+dev = ["pytest", "pytest-cov", "pytest-xdist", "pre-commit", "mypy"]
+deepsparse = ["deepsparse-nightly[llm]>=1.8.0.20240404"]
+gptq = ["auto-gptq[triton]>=0.6.0"]
+hf_transfer = ["hf_transfer"]
+ifeval = ["langdetect", "immutabledict", "nltk>=3.9.1"]
+neuronx = ["optimum[neuronx]"]
+mamba = ["mamba_ssm", "causal-conv1d==1.0.2"]
+math = ["sympy>=1.12", "antlr4-python3-runtime==4.11"]
+multilingual = ["nagisa>=0.2.7", "jieba>=0.42.1", "pycountry"]
+optimum = ["optimum[openvino]"]
+promptsource = ["promptsource>=0.2.3"]
+sentencepiece = ["sentencepiece>=0.1.98"]
+sparseml = ["sparseml-nightly[llm]>=1.8.0.20240404"]
+testing = ["pytest", "pytest-cov", "pytest-xdist"]
+vllm = ["vllm>=0.4.2"]
+zeno = ["pandas", "zeno-client"]
+wandb = ["wandb>=0.16.3", "pandas", "numpy"]
+all = [
+    "lm_eval[anthropic]",
+    "lm_eval[dev]",
+    "lm_eval[deepsparse]",
+    "lm_eval[gptq]",
+    "lm_eval[hf_transfer]",
+    "lm_eval[ifeval]",
+    "lm_eval[mamba]",
+    "lm_eval[math]",
+    "lm_eval[multilingual]",
+    "lm_eval[openai]",
+    "lm_eval[promptsource]",
+    "lm_eval[sentencepiece]",
+    "lm_eval[sparseml]",
+    "lm_eval[testing]",
+    "lm_eval[vllm]",
+    "lm_eval[zeno]",
+    "lm_eval[wandb]",
+]
+
+[tool.ruff.lint]
+extend-select = ["I"]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["lm_eval"]
+
+[tool.ruff.lint.extend-per-file-ignores]
+"__init__.py" = ["F401","F402","F403"]
+"utils.py" = ["F401"]

testbed/EleutherAI__lm-evaluation-harness/tests/test_utils.py

@@ -0,0 +1,398 @@
+import itertools
+
+import numpy as np
+import pytest
+import torch
+
+from lm_eval.api.metrics import (
+    aggregate_subtask_metrics,
+    mean,
+    pooled_sample_stderr,
+    stderr_for_metric,
+)
+from lm_eval.models.utils import Collator
+from lm_eval.utils import (
+    get_rolling_token_windows,
+    make_disjoint_window,
+)
+
+
+# noinspection DuplicatedCode
+def test_get_rolling_token_windows_v1():
+    gold = [
+        ([-100, 0, 1, 2, 3, 4, 5, 6, 7, 8], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        (
+            [9, 10, 11, 12, 13, 14, 15, 16, 17, 18],
+            [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
+        ),
+        (
+            [19, 20, 21, 22, 23, 24, 25, 26, 27, 28],
+            [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
+        ),
+        ([23, 24, 25, 26, 27, 28, 29, 30, 31, 32], [30, 31, 32, 33]),
+    ]
+    x = list(range(34))
+    generator = get_rolling_token_windows(
+        token_list=x,
+        prefix_token=-100,
+        max_seq_len=10,
+        context_len=1,
+    )
+    pred_length = 0
+    output = []
+    for input_tokens, pred_tokens in generator:
+        output.extend([(input_tokens, pred_tokens)])
+        pred_length += len(pred_tokens)
+    assert pred_length == len(x)
+    assert gold == output
+
+
+# noinspection DuplicatedCode
+def test_get_rolling_token_windows_v2():
+    gold = [
+        ([-100, 0, 1, 2, 3, 4, 5, 6, 7, 8], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        ([2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [10, 11, 12]),
+        ([5, 6, 7, 8, 9, 10, 11, 12, 13, 14], [13, 14, 15]),
+        ([8, 9, 10, 11, 12, 13, 14, 15, 16, 17], [16, 17, 18]),
+        ([11, 12, 13, 14, 15, 16, 17, 18, 19, 20], [19, 20, 21]),
+        ([14, 15, 16, 17, 18, 19, 20, 21, 22, 23], [22, 23, 24]),
+        ([17, 18, 19, 20, 21, 22, 23, 24, 25, 26], [25, 26, 27]),
+        ([20, 21, 22, 23, 24, 25, 26, 27, 28, 29], [28, 29, 30]),
+        ([23, 24, 25, 26, 27, 28, 29, 30, 31, 32], [31, 32, 33]),
+    ]
+    x = list(range(34))
+    generator = get_rolling_token_windows(
+        token_list=x,
+        prefix_token=-100,
+        max_seq_len=10,
+        context_len=8,
+    )
+    pred_length = 0
+    output = []
+    for input_tokens, pred_tokens in generator:
+        output.extend([(input_tokens, pred_tokens)])
+        pred_length += len(pred_tokens)
+    assert pred_length == len(x)
+    assert gold == output
+
+
+# noinspection DuplicatedCode
+def test_get_rolling_token_windows_v3():
+    gold = [
+        ([-100, 0, 1, 2, 3, 4, 5, 6, 7, 8], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [10]),
+        ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [11]),
+        ([2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [12]),
+        ([3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [13]),
+        ([4, 5, 6, 7, 8, 9, 10, 11, 12, 13], [14]),
+        ([5, 6, 7, 8, 9, 10, 11, 12, 13, 14], [15]),
+        ([6, 7, 8, 9, 10, 11, 12, 13, 14, 15], [16]),
+        ([7, 8, 9, 10, 11, 12, 13, 14, 15, 16], [17]),
+        ([8, 9, 10, 11, 12, 13, 14, 15, 16, 17], [18]),
+        ([9, 10, 11, 12, 13, 14, 15, 16, 17, 18], [19]),
+        ([10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [20]),
+        ([11, 12, 13, 14, 15, 16, 17, 18, 19, 20], [21]),
+        ([12, 13, 14, 15, 16, 17, 18, 19, 20, 21], [22]),
+        ([13, 14, 15, 16, 17, 18, 19, 20, 21, 22], [23]),
+        ([14, 15, 16, 17, 18, 19, 20, 21, 22, 23], [24]),
+        ([15, 16, 17, 18, 19, 20, 21, 22, 23, 24], [25]),
+        ([16, 17, 18, 19, 20, 21, 22, 23, 24, 25], [26]),
+        ([17, 18, 19, 20, 21, 22, 23, 24, 25, 26], [27]),
+        ([18, 19, 20, 21, 22, 23, 24, 25, 26, 27], [28]),
+        ([19, 20, 21, 22, 23, 24, 25, 26, 27, 28], [29]),
+        ([20, 21, 22, 23, 24, 25, 26, 27, 28, 29], [30]),
+        ([21, 22, 23, 24, 25, 26, 27, 28, 29, 30], [31]),
+        ([22, 23, 24, 25, 26, 27, 28, 29, 30, 31], [32]),
+        ([23, 24, 25, 26, 27, 28, 29, 30, 31, 32], [33]),
+    ]
+    x = list(range(34))
+    generator = get_rolling_token_windows(
+        token_list=x,
+        prefix_token=-100,
+        max_seq_len=10,
+        context_len=10,
+    )
+    pred_length = 0
+    output = []
+    for input_tokens, pred_tokens in generator:
+        output.extend([(input_tokens, pred_tokens)])
+        pred_length += len(pred_tokens)
+    assert pred_length == len(x)
+    assert gold == output
+
+
+# noinspection DuplicatedCode
+def test_get_rolling_token_windows_v4():
+    gold = [
+        ([-100, 0, 1, 2, 3, 4, 5, 6, 7, 8], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [10]),
+        ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [11]),
+        ([2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [12]),
+        ([3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [13]),
+        ([4, 5, 6, 7, 8, 9, 10, 11, 12, 13], [14]),
+        ([5, 6, 7, 8, 9, 10, 11, 12, 13, 14], [15]),
+        ([6, 7, 8, 9, 10, 11, 12, 13, 14, 15], [16]),
+        ([7, 8, 9, 10, 11, 12, 13, 14, 15, 16], [17]),
+        ([8, 9, 10, 11, 12, 13, 14, 15, 16, 17], [18]),
+        ([9, 10, 11, 12, 13, 14, 15, 16, 17, 18], [19]),
+        ([10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [20]),
+        ([11, 12, 13, 14, 15, 16, 17, 18, 19, 20], [21]),
+        ([12, 13, 14, 15, 16, 17, 18, 19, 20, 21], [22]),
+        ([13, 14, 15, 16, 17, 18, 19, 20, 21, 22], [23]),
+        ([14, 15, 16, 17, 18, 19, 20, 21, 22, 23], [24]),
+        ([15, 16, 17, 18, 19, 20, 21, 22, 23, 24], [25]),
+        ([16, 17, 18, 19, 20, 21, 22, 23, 24, 25], [26]),
+        ([17, 18, 19, 20, 21, 22, 23, 24, 25, 26], [27]),
+        ([18, 19, 20, 21, 22, 23, 24, 25, 26, 27], [28]),
+        ([19, 20, 21, 22, 23, 24, 25, 26, 27, 28], [29]),
+    ]
+    x = list(range(30))
+    generator = get_rolling_token_windows(
+        token_list=x,
+        prefix_token=-100,
+        max_seq_len=10,
+        context_len=10,
+    )
+    pred_length = 0
+    output = []
+    for input_tokens, pred_tokens in generator:
+        output.extend([(input_tokens, pred_tokens)])
+        pred_length += len(pred_tokens)
+    assert pred_length == len(x)
+    assert gold == output
+
+
+# noinspection DuplicatedCode
+def test_get_rolling_token_windows_v5():
+    gold = [
+        ([-100, 0, 1, 2, 3, 4, 5, 6, 7, 8], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        (
+            [9, 10, 11, 12, 13, 14, 15, 16, 17, 18],
+            [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
+        ),
+        (
+            [19, 20, 21, 22, 23, 24, 25, 26, 27, 28],
+            [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
+        ),
+    ]
+    x = list(range(30))
+    generator = get_rolling_token_windows(
+        token_list=x,
+        prefix_token=-100,
+        max_seq_len=10,
+        context_len=1,
+    )
+    pred_length = 0
+    output = []
+    for input_tokens, pred_tokens in generator:
+        output.extend([(input_tokens, pred_tokens)])
+        pred_length += len(pred_tokens)
+    assert pred_length == len(x)
+    assert gold == output
+
+
+# noinspection DuplicatedCode
+def test_get_rolling_token_windows_v6():
+    gold = [
+        ([-100, 0], [0, 1]),
+        ([1, 2], [2, 3]),
+        ([3, 4], [4, 5]),
+        ([5, 6], [6, 7]),
+        ([6, 7], [8]),
+    ]
+    x = list(range(9))
+    generator = get_rolling_token_windows(
+        token_list=x,
+        prefix_token=-100,
+        max_seq_len=2,
+        context_len=1,
+    )
+    pred_length = 0
+    output = []
+    for input_tokens, pred_tokens in generator:
+        output.extend([(input_tokens, pred_tokens)])
+        pred_length += len(pred_tokens)
+    assert pred_length == len(x)
+    assert gold == output
+
+
+def test_get_rolling_token_windows_empty():
+    generator = get_rolling_token_windows(
+        token_list=[],
+        prefix_token=-100,
+        max_seq_len=2,
+        context_len=1,
+    )
+    n = 0
+    for _ in generator:
+        n += 1
+    assert n == 0
+
+
+def test_make_disjoint_window():
+    assert make_disjoint_window(([1, 2, 3, 4, 5], [2, 3, 4, 5, 6])) == (
+        [1],
+        [2, 3, 4, 5, 6],
+    )
+    assert make_disjoint_window(([1, 2, 3, 4, 5], [4, 5, 6])) == ([1, 2, 3], [4, 5, 6])
+    assert make_disjoint_window(([1, 2, 3, 4, 5], [6])) == ([1, 2, 3, 4, 5], [6])
+
+
+class TestCollator:
+    def make_generate_sample(self, end=10):
+        strings = ["x" * i for i in range(1, end + 1)]
+        gen_kwargs1, gen_kwargs2 = (
+            {"temperature": 0},
+            {"temperature": 0, "until": ["nn", "\n\n"]},
+        )
+        args = [
+            (string, gen_kwargs1 if i < len(strings) // 2 else gen_kwargs2)
+            for i, string in enumerate(strings)
+        ]
+
+        return args
+
+    def make_loglikelihood_sample(self, end=11):
+        samples = [
+            (("x", "x"), list(range(1, total_length + 1)))
+            for total_length in range(1, end + 1)
+        ]
+        return samples
+
+    def make_loglikelihood_sample_group(self, end=11):
+        a = [(("x", "x"), [1, 2, 3, 4, 5, 6, 7, 8], [x]) for x in range(9)]
+        b = [
+            (("x", "x"), [1, 2, 3, 4, 5, 6, 7, 8], [x, y, z])
+            for x, y, z in zip(range(9), range(9, 18), range(18, 27))
+        ]
+        return a + b
+
+    @pytest.mark.parametrize("batch_size, end", [(17, 30), (8, 61), (12, 48), (0, 9)])
+    def test_generations(self, batch_size, end):
+        _collate_gen = lambda x: (-len(x[0]), x[0])  # noqa: E731
+
+        generation_samples = self.make_generate_sample(int(end))
+        gens = Collator(generation_samples, _collate_gen, group_by="gen_kwargs")
+        chunks_gen = gens.get_batched(n=int(batch_size), batch_fn=None)
+        output = []
+        group_one = end // 2
+        group_two = end - end // 2
+        is_batch = batch_size != 0
+        for chunks in chunks_gen:
+            # check batching
+            assert (
+                len(chunks) <= batch_size
+                if is_batch
+                else len(chunks) in [group_one, group_two]
+            )
+            # check if reorder-er is working correctly
+            chunk_lengths = [len(chunk[0]) for chunk in chunks]
+            assert chunk_lengths == sorted(chunk_lengths, reverse=True)
+            # check if grouping correctly
+            chunk_to_compare = chunks[0][1]
+            assert all(x[1] == chunk_to_compare for x in chunks)
+            for x in chunks:
+                output.extend([x])
+        reordered_output = gens.get_original(output)
+        # check get original
+        assert reordered_output == generation_samples
+
+    @pytest.mark.parametrize("batch_size, end", [(17, 30), (8, 61), (12, 48), (0, 3)])
+    def test_loglikelihood(self, batch_size, end):
+        _collate_log = lambda x: (-len(x[1]), tuple(x[1]))  # noqa: E731
+        loglikelihood_samples = self.make_loglikelihood_sample(int(end))
+        loglikelihoods = Collator(
+            loglikelihood_samples,
+            _collate_log,
+        )
+        chunks_gen = loglikelihoods.get_batched(n=int(batch_size), batch_fn=None)
+        output = []
+        is_batch = batch_size != 0
+        for chunks in chunks_gen:
+            # check batching
+            assert len(chunks) <= batch_size if is_batch else len(chunks) == end
+            # check reorder
+            chunk_lengths = [len(chunk[1]) for chunk in chunks]
+            assert chunk_lengths == sorted(chunk_lengths, reverse=True)
+            for x in chunks:
+                output.extend([x[1]])
+        # check indices
+        reordered_output = loglikelihoods.get_original(output)
+        assert reordered_output == [x[1] for x in loglikelihood_samples]
+
+    @pytest.mark.parametrize("batch_size", [17, 8, 12, 0])
+    def test_context_grouping(self, batch_size):
+        def _collate(x):
+            toks = x[1] + x[2]
+            return -len(toks), tuple(toks)
+
+        _collate_log = _collate  # noqa: E731
+        loglikelihood_samples = self.make_loglikelihood_sample_group()
+        loglikelihoods = Collator(
+            loglikelihood_samples,
+            _collate_log,
+            group_fn=lambda a: a[-2] + a[-1][:-1],
+            group_by="contexts",
+        )
+        chunks_gen = loglikelihoods.get_batched(n=int(batch_size), batch_fn=None)
+        output = []
+        outputs_ = []
+        is_batch = batch_size != 0
+        for chunks in chunks_gen:
+            # check batching
+            if is_batch:
+                assert len(chunks) <= batch_size
+            # check reorder
+            chunk_lengths = [len(chunk[1]) for chunk in chunks]
+            assert chunk_lengths == sorted(chunk_lengths, reverse=True)
+            for x in chunks:
+                for request_str, cont_toks, logits in loglikelihoods.get_cache(
+                    req_str="".join(x[0]),
+                    cxt_toks=x[1],
+                    cont_toks=x[2],
+                    logits=torch.tensor([1, 2, 3, 4, 5, 6, 7, 8])
+                    .unsqueeze(0)
+                    .unsqueeze(0),
+                ):
+                    output.extend([x[1]])
+                    outputs_.extend([cont_toks])
+        assert len(output) == len(outputs_)
+        # check indices
+        reordered_output = loglikelihoods.get_original(output)
+        assert reordered_output == [x[1] for x in loglikelihood_samples]
+
+
+def test_aggregate_mean():
+    # test weight_by_size is respected
+    assert (
+        aggregate_subtask_metrics([0.3, 0.2, 0.4], [20, 40, 100], weight_by_size=False)
+        == 0.3
+    )
+    assert (
+        aggregate_subtask_metrics([0.3, 0.2, 0.4], [20, 40, 100], weight_by_size=True)
+        == 0.3375
+    )
+
+
+@pytest.mark.parametrize(
+    "samples",
+    [
+        [40 * [1.0] + 60 * [0.0], 30 * [1.0] + 30 * [0.0], 20 * [1.0] + 60 * [0.0]],
+        [35 * [1.0] + 65 * [0.0], 20 * [1.0] + 20 * [0.0]],
+    ],
+)
+def test_aggregate_stderrs(samples):
+    # check that aggregating subtasks' bootstrap stderrs with our formula
+    # (using weight_by_size) is ~equiv.
+    # to just getting bootstrap stderr of the whole set of samples
+    mean_stderr = stderr_for_metric(metric=mean, bootstrap_iters=100000)
+
+    stderrs = [mean_stderr(subtask) for subtask in samples]
+
+    sizes = [len(subtask) for subtask in samples]
+
+    assert np.allclose(
+        pooled_sample_stderr(stderrs, sizes),
+        mean_stderr(list(itertools.chain.from_iterable(samples))),
+        atol=1.0e-3,
+    )

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_only_npi_scope-v0-loglikelihood

@@ -0,0 +1 @@
+fc0be817478c212327050fa297ef61ad214f4847dbff61d4e0fe7914c06a1691

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_passive_2-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_passive_2": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_passive_2": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_principle_A_case_1-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_principle_A_case_1": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_principle_A_case_1": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_principle_A_domain_1-v0-loglikelihood

@@ -0,0 +1 @@
+290e7eddacea4ec16989af697f2ee3373fdd9aef4b452bf887184c6e2f6e7d9d

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_principle_A_domain_1-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_principle_A_domain_1": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_principle_A_domain_1": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_principle_A_domain_2-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_principle_A_domain_2": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_principle_A_domain_2": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_principle_A_domain_3-v0-loglikelihood

@@ -0,0 +1 @@
+38454befedcf1f3f6ef27d3bef9ccfdfb3e94a7ab32d86a63493a920d2d50093

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_principle_A_domain_3-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_principle_A_domain_3": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_principle_A_domain_3": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_principle_A_reconstruction-v0-loglikelihood

@@ -0,0 +1 @@
+894efedfd8750d5b8de6157f9b2ed2b51b5290d3a78ea9b041fc62d34e96efbc

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_principle_A_reconstruction-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_principle_A_reconstruction": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_principle_A_reconstruction": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_regular_plural_subject_verb_agreement_1-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_regular_plural_subject_verb_agreement_1": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_regular_plural_subject_verb_agreement_1": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_regular_plural_subject_verb_agreement_2-v0-loglikelihood

@@ -0,0 +1 @@
+f69d9891f59872538962221fccc425b07df7cfbd83cdc546ce83e6b0e9a93f7c

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_regular_plural_subject_verb_agreement_2-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_regular_plural_subject_verb_agreement_2": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_regular_plural_subject_verb_agreement_2": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_sentential_negation_npi_licensor_present-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_sentential_negation_npi_licensor_present": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_sentential_negation_npi_licensor_present": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_sentential_negation_npi_scope-v0-res.json

@@ -0,0 +1 @@
+{"results": {"blimp_sentential_negation_npi_scope": {"acc": 0.485, "acc_stderr": 0.0158121796418149}}, "versions": {"blimp_sentential_negation_npi_scope": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_sentential_subject_island-v0-loglikelihood

@@ -0,0 +1 @@
+80f5f98fad26240de2767fe58c4b18d864df41cbfa76f06c84c3fce9f14f4833

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_superlative_quantifiers_1-v0-loglikelihood

@@ -0,0 +1 @@
+8a01f6a5ea87a01c0c9b0c7b3bc4de4711bf0ff050976976651182b9ed34a0d4

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_superlative_quantifiers_2-v0-loglikelihood

@@ -0,0 +1 @@
+59c20ff0f632cf42afc74ecc682cf92e5e740417b01e6cf9a610a3bc544d2ea5

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_tough_vs_raising_2-v0-loglikelihood

@@ -0,0 +1 @@
+d255a10a34f14d77d9526604a17b0f6747d32f62fc2e3a09e9ab10054535fd45

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/blimp_wh_vs_that_no_gap-v0-loglikelihood

@@ -0,0 +1 @@
+d1d3e439b2020ef5ed232bfebbcc9634adc5117e9eb61e38fdbbe2c8ea128d54

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/drop-v1-greedy_until

@@ -0,0 +1 @@
+a670f911ab2999d72db15f534b22703d19e7837edbda4f9f199ad587f7aae6b2

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/ethics_deontology-v0-res.json

@@ -0,0 +1 @@
+{"results": {"ethics_deontology": {"acc": 0.503615127919911, "acc_stderr": 0.008338908432085105, "em": 0.07119021134593993}}, "versions": {"ethics_deontology": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/ethics_justice-v0-loglikelihood

@@ -0,0 +1 @@
+d7dfc44fea507b5c5c3a8218f79ed8197da8599ebb396d85feb91c25512126b6

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/ethics_justice-v0-res.json

@@ -0,0 +1 @@
+{"results": {"ethics_justice": {"acc": 0.49556213017751477, "acc_stderr": 0.009616784279885177, "em": 0.057692307692307696}}, "versions": {"ethics_justice": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/ethics_utilitarianism-v0-res.json

@@ -0,0 +1 @@
+{"results": {"ethics_utilitarianism": {"acc": 0.49771214642262895, "acc_stderr": 0.007211546310787838}}, "versions": {"ethics_utilitarianism": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/ethics_utilitarianism_original-v0-loglikelihood

@@ -0,0 +1 @@
+5b42ba1faf5ece6a6ec9a3976ce79c1fac8df5b98272aab85457188c2142693c

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/ethics_virtue-v0-loglikelihood

@@ -0,0 +1 @@
+8021db8de46850090ddae6e6ec2d382029c3027b7c69884607503f916d09b709

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/gsm8k-v0-res.json

@@ -0,0 +1 @@
+{"results": {"gsm8k": {"acc": 0.0, "acc_stderr": 0.0}}, "versions": {"gsm8k": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/headqa-v0-loglikelihood

@@ -0,0 +1 @@
+767ca34d9714edd9fb030ddbcc35a64e5180d1e247b0cb557fbb22fdf971ad1f

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/headqa-v0-res.json

@@ -0,0 +1 @@
+{"results": {"headqa": {"acc": 0.23559445660102116, "acc_norm": 0.25018234865062, "acc_norm_stderr": 0.008272783230806014, "acc_stderr": 0.008105688874297972}}, "versions": {"headqa": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/headqa_en-v0-loglikelihood

@@ -0,0 +1 @@
+09da45119b12a0144e3081f8fb790c2a22af7b9c3aac42f54423d348a711fbf5

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/headqa_en-v0-res.json

@@ -0,0 +1 @@
+{"results": {"headqa_en": {"acc": 0.23559445660102116, "acc_norm": 0.2447118891320204, "acc_norm_stderr": 0.008211629406841468, "acc_stderr": 0.008105688874297972}}, "versions": {"headqa_en": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/headqa_es-v0-loglikelihood

@@ -0,0 +1 @@
+767ca34d9714edd9fb030ddbcc35a64e5180d1e247b0cb557fbb22fdf971ad1f

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/headqa_es-v0-res.json

@@ -0,0 +1 @@
+{"results": {"headqa_es": {"acc": 0.23559445660102116, "acc_norm": 0.25018234865062, "acc_norm_stderr": 0.008272783230806014, "acc_stderr": 0.008105688874297972}}, "versions": {"headqa_es": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hellaswag-v0-loglikelihood

@@ -0,0 +1 @@
+abb808c97d6529eda6c11067837a132c62d25cba0394d720f80cca6df9f7196e

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hellaswag-v0-res.json

@@ -0,0 +1 @@
+{"results": {"hellaswag": {"acc": 0.24965146385182235, "acc_norm": 0.24756024696275641, "acc_norm_stderr": 0.004307128573285236, "acc_stderr": 0.004319267432460666}}, "versions": {"hellaswag": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-abstract_algebra-v0-loglikelihood

@@ -0,0 +1 @@
+e35d1eeb356ac1084d4e9773f028cb3c81ba1c6e5574d598ac4a78aa467cd797

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-abstract_algebra-v0-res.json

@@ -0,0 +1 @@
+{"results": {"hendrycksTest-abstract_algebra": {"acc": 0.32, "acc_norm": 0.34, "acc_norm_stderr": 0.04760952285695235, "acc_stderr": 0.04688261722621504}}, "versions": {"hendrycksTest-abstract_algebra": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-anatomy-v0-loglikelihood

@@ -0,0 +1 @@
+bf05e04ed8cf61cf3aad294ed3f5a16137775ffdd20f1b129022ddffc1251768

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-anatomy-v0-res.json

@@ -0,0 +1 @@
+{"results": {"hendrycksTest-anatomy": {"acc": 0.2222222222222222, "acc_norm": 0.23703703703703705, "acc_norm_stderr": 0.03673731683969506, "acc_stderr": 0.0359144408419697}}, "versions": {"hendrycksTest-anatomy": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-astronomy-v0-loglikelihood

@@ -0,0 +1 @@
+bed1e47127cc2893c6aef63b9a0909cca31aa351a703da2a166b01cae03c3311

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-astronomy-v0-res.json

@@ -0,0 +1 @@
+{"results": {"hendrycksTest-astronomy": {"acc": 0.2565789473684211, "acc_norm": 0.29605263157894735, "acc_norm_stderr": 0.03715062154998904, "acc_stderr": 0.0355418036802569}}, "versions": {"hendrycksTest-astronomy": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-business_ethics-v0-loglikelihood

@@ -0,0 +1 @@
+b3b27e9dbad587377d3c8cab1072782de883e245da93a563bd8b3099017b1fc0

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-business_ethics-v0-res.json

@@ -0,0 +1 @@
+{"results": {"hendrycksTest-business_ethics": {"acc": 0.29, "acc_norm": 0.27, "acc_norm_stderr": 0.044619604333847394, "acc_stderr": 0.045604802157206845}}, "versions": {"hendrycksTest-business_ethics": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-clinical_knowledge-v0-loglikelihood

@@ -0,0 +1 @@
+fbcb7ce507e0675d811e71e10a67c8d05a6605e29036f46776e04a6588cefbda

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-clinical_knowledge-v0-res.json

@@ -0,0 +1 @@
+{"results": {"hendrycksTest-clinical_knowledge": {"acc": 0.23773584905660378, "acc_norm": 0.27169811320754716, "acc_norm_stderr": 0.027377706624670713, "acc_stderr": 0.02619980880756191}}, "versions": {"hendrycksTest-clinical_knowledge": 0}}

testbed/EleutherAI__lm-evaluation-harness/tests/testdata/hendrycksTest-college_biology-v0-loglikelihood

@@ -0,0 +1 @@
+c29e4e67ff91af29b9434884874414d1b1b32ccc32903c6b1639469b19907419