Site icon TechHype.io

Inverse Scaling Prize – Win up to $100,000 for finding a task where larger language models do worse

TL;DR: Win up to $100,000 for finding an important task where larger language models do worse.

Submissions due August 27, 2022 (Round 1) and October 27, 2022 (Round 2).

Motivation

As language models get larger, they seem to only get better. Larger language models score better on benchmarks and unlock new capabilities like arithmetic [1], few-shot learning [1], and multi-step reasoning [2]. However, language models are not without flaws, exhibiting many biases [3] and producing plausible misinformation [4]. The purpose of this contest is to find evidence for a stronger failure mode: tasks where language models get worse as they become better at language modeling (next word prediction).

The standard paradigm in natural language processing today is to pretrain large language models to autocomplete text corpora. The resulting models are then either frozen and used directly for other tasks (zero-shot or using few-shot learning), or additionally trained on other tasks (fine-tuning). We focus on the case of zero-shot/few-shot evaluation on downstream tasks without task-specific gradient optimization: it’s typically easier to use in practice and to study.

Scaling laws [5][6] show that language models get predictably better (in terms of test loss and downstream performance [7]) as the number of parameters, amount of compute used, and dataset size increase. The improvement follows a power law in each of parameters, compute, and dataset size. We hypothesize that there are tasks with trends in the opposite direction: task performance gets monotonically, predictably worse as the overall test loss of the language model improves. We call this phenomenon inverse scaling, in contrast with the standard scaling laws. There are some tasks that appear to show inverse scaling under some conditions [4][8][10], but such tasks appear to be rare.

This contest aims to find inverse scaling tasks, especially those of importance to the safe and responsible use of language models. We hope that task submissions will teach us more about what types of tasks exhibit inverse scaling; inverse scaling tasks will also highlight potential issues with the current paradigm of language model pretraining and scaling. Inverse scaling tasks are important because they represent a mismatch between the behavior we want language models to exhibit and the behavior we get in practice from the training objectives and data we use. As language models continue to get bigger and used in more real-world applications, it is important that they are not increasingly getting worse or harming users in yet-undetected ways.

After two rounds of the contest, we will write a survey of the submitted tasks and other examples found in the literature. Authors of winning tasks will be awarded prize money and invited to be co-authors on the resulting paper. Below, we detail our call for submissions. Feel free to join our Slack to message us with questions, find collaborators, and participate in contest-related discussions with other participants (code, ideas, findings, and related work sharing).

Inverse Scaling Prize information

We will award up to $250,000 in total prize money for task submissions, distributed as follows:

  1. Up to 1 Grand Prize of $100,000.
  2. Up to 5 Second Prizes of $20,000 each.
  3. Up to 10 Third Prizes of $5,000 each.

All prize decisions will be made by the organizers and anonymous reviewers, using the Prize Rubric below. Prize winners may nominate a non-profit to receive the prize money on their behalf. Some prizes may remain unawarded if there are not enough tasks that meet the eligibility for a prize tier, as detailed in the Prize Rubric.

Benchmark and Co-authorship: Authors of prize-winning submissions will be invited as co-authors on the paper written after the contest concludes. We will also offer co-authorship to authors of submissions that met our acceptability criteria but did not receive prizes, in the event that we receive more acceptable submissions than we can award with prizes. We will include all accepted submissions in our final benchmark, which we plan to release to the research community after the contest.

Timeline: The contest begins on June 27, 2022. We will host a first round of evaluations on submissions received on or before August 27, 2022 (Anywhere on Earth) and a second, final round of evaluations on submissions received on or before October 27, 2022 (Anywhere on Earth). After the first round, we will award eligible tasks with third prizes (up to 5) and second prizes (up to 2). To help improve first-round submissions, we will also return reviewer feedback and scaling law plots/results from our private, evaluation models. At the end of the second round, we will reward eligible tasks at all prize tiers, with the possibility of upgrading first-round submissions to higher prize tiers based on both rounds of submissions.

Prize Rubric

Here, we detail our submission evaluation rubric. The rubric will guide an anonymous panel of reviewers in judging submissions for prizes. A submission must meet all criteria in the “Grand Prize” column to win the grand prize. Likewise, a submission must meet all criteria in the “Accepted Task” column to be accepted into our benchmark and for co-authorship on our paper. For second prizes, submissions must meet all “Accepted Task” criteria and some “Grand Prize” criteria. Third prizes must meet the “Accepted Task” criteria. We may receive more eligible submissions than we have prizes for a given tier. In this case, we will first break ties based on how many “Grand Prize” criteria are met and then by having reviewers make subjective rankings within tiers (e.g., more granular measures of how much various criteria are met or the relative difficulty or importance of each criterion met). We will consider inverse scaling trends on publicly-available models like GPT-3, as well as held-out, private models for which we will run evaluation.

Criterion Description Prize Tier
No Prize Accepted Task Grand Prize
Inverse Scaling Strength How straight and steep is the inverse scaling trend on public models? Shows flat, very bumpy, or standard scaling. Shows approximately monotonic inverse scaling. Shows a clear, strictly monotonic inverse scaling trend.
Inverse Scaling Generality Do different models all show inverse scaling? No inverse scaling on private models. Shows inverse scaling on some public and some private models. Shows inverse scaling across all public and private models tested.
Task Importance Is the task important to the safe and responsible use of LMs, or for shedding light on where LMs fail? How strong are the arguments? Weak. No users or third parties would be harmed, and the task does not shed light on where LMs fail. Fairly convincing. Some LM users or third parties would be harmed by the discovered behavior, or the task sheds light on where LMs fail (e.g., sensitivity to prompts). Very convincing. Significant implications for how LM research or deployment will need to be developed to be reliably safe and effective.
Novelty and Surprisingness Is inverse scaling on the task novel (not shown in prior work) and surprising? Not novel or surprising. Novel and somewhat surprising. Novel and surprising, teaching us something new about LMs.
Task Coverage Are the examples fully representative of the described task? Examples only cover a special subcategory or phrasing of the described task. There’s no evidence of inverse scaling on other subcategories or phrasings. Examples cover different subcategories and phrasings for the described task. Examples cover almost all important task subcategories and phrasings, suggesting robust inverse scaling on the described task.
Reproducibility Does inverse scaling appear to occur if we reproduce the task based on its description? No, we see flat, very bumpy, or standard scaling. The particular examples submitted may have been over-optimized for inverse scaling, to the extent that the examples are unrepresentative of the described task. Yes, but to a lesser extent. Yes, to a similar or stronger extent.

Answering the below, optional questions in our submission form (in the free-form response) will make your task stand out more:

We reserve the right to update the prize tier standards or criteria, e.g., between rounds if we observe submissions gaming them in some way.

Evaluation Eligibility: To be eligible for official review, a task submission must:

  1. Include a plot of loss vs. model size across adababbagecurie, and davinci GPT-3 models, using the provided code for GPT-3 evaluation. The plot must not show a standard scaling law.
  2. Meet the formatting requirements described in the Submission Guidelines.
    • This requirement should already be satisfied if you are able to successfully run the evaluation code.
  3. Include a coherent description of the task.

Models

This contest uses pretrained autoregressive language models such as GPT-3. We offer Google colab notebooks for evaluating inverse scaling with the GPT-3OPT, and GPT-2 model series when developing a task. However, to avoid overfitting to publicly available models, we use private models to run the evaluations for awarding prizes. Currently, we are using the series of pretrained language models (without additional finetuning) from Anthropic [Bai et al. 2022]. We are in discussions with other organizations to use their models, which may be added later on to strengthen the evaluation.

Reviewers

Prize decisions will be made by an anonymous panel of reviewers. Reviewers will be selected by the contest organizers and may include some organizers. Reviewers will have ML and NLP experience relevant to inverse scaling. The panel may contain some competition organizers. Reviewers will not be allowed to make submissions to the contest.

Submission guidelines

  1. Each task submission should be a language modeling test set (in the style of BIG-Bench) of inputs with corresponding answers, which will be evaluated according to one of four evaluation metrics (detailed later).
  2. This prize is to incentivize original work, so submissions should find a new phenomenon for which inverse scaling has not been previously documented.
    1. If a task has already shown inverse scaling in prior work (even if the original authors did not identify it as such) then it is ineligible for the contest.
    2. If an existing task has not been subjected to any kind of scaling analysis, then it is likely eligible for the contest.
    3. If you would like to check whether an existing task is eligible, message us on our Slack or email us at inverse.scaling@gmail.com with [PRIOR WORK] in the subject line and a link to where the task has previously been published.
  3. Data must be formatted as .csv.
    • The .csv will be read using the pandas package.
    • Specific formats are given below in the Evaluation metrics section.
  4. Examples will be given as a prompt to an autoregressive language model.
    • I.e., either zero-shot or few-shot prompts (prompts containing a few examples). Few-shot examples must demonstrate the correct behavior on the task.
  5. Tasks must contain at least 300 examples
    • We recommend 500+ diverse examples so that inverse scaling trends are clearer.
  6. In the submission form, you will be asked to add:
    1. Evaluation metric used
      • The metric should be one of:
        1. Classification loss in a multiple-choice format (classification).
        2. Loss on a sequence at the end of the prompt (sequence_prob).
        3. Difference in logodds between two possible responses (logodds).
        4. Absolute difference in logodds between two possible responses (absolute_logodds).
    2. Authors
    3. Description of intended task
      • What is the task aiming to test?
    4. Why is the task important?
      • How is the task important to safe and responsible use of LMs?
      • Does inverse scaling on the task suggest any fundamental insights about model behavior and model failures?
    5. Why do you expect to see inverse scaling?
      • What led you to suspect that your task will inverse scale?
    6. Data generation procedure
      • How did you construct the dataset? What resources did you use?
      • E.g., based on a template given pre-set vocabulary, programmatically generated based on some math phenomenon, etc.
    7. Expertise required for human annotators to verify the task labels
      • E.g., knowledge of linguistics, fluent in specific languages.
    8. A plot of GPT-3 performance on the task, produced using this colab.
  7. We will verify or validate task labels for correctness using contractors.
    • See this colab to test an interface similar to what we will use for task validation.
    • If you submit a very large dataset, we may uniformly subsample up to 10,000 examples from it for evaluation.

Evaluation metrics

Here, we include more detail on the types of evaluation metrics that an eligible task submission can use. For examples of datasets correctly formatted for each metric, see this sheet. Please message us on our Slack or email us at inverse.scaling@gmail.com with [METRIC] in the subject line if you think it is impossible to frame your task as any of these evaluation metrics and that some other metric would demonstrate inverse scaling.

Classification loss (classification)

  1. Use this metric for a standard classification task, e.g., when testing how well a model can choose the correct response from a list of possible responses.
  2. The columns of the .csv are:
    1. prompt, a string.
    2. classes, an ordered list (using valid Python syntax) of the possible answer tokens.
      • NOTE: because of the way language model tokenizers typically process text, the class tokens should almost always start with a space and a capital letter, e.g. ” Yes” and ” No” rather than “yes” and “no”.
      • Each class may be multiple tokens long, in which case we will use the logprob of the full token sequence as the logit for computing the classification loss. We strongly prefer for you to design each class to be the same number of tokens long, so that the sequence length of class labels does not affect the results (longer sequences tend to have smaller probabilities). Furthermore, we strongly encourage you to design class labels that are just a single token long. To do so, you can turn a task with a several possible sequence completions into an explicit, multiple choice task, where the classses are e.g. ” A”, ” B”, ” C”, and ” D”. This task format can guide the language model more clearly to put a high probability on valid completions.
    3. answer_index, an integer specifying which of the class tokens is the correct answer (using zero-indexing).

Completion sequence loss (sequence_prob)

  1. Use this metric when you are testing how well the model predicts the correct conclusion or completion to a prompt.
    • This type of loss is used by LAMBADA, which uses as the target a single word. LAMBADA uses sequence probabilities because each example has only one correct completion, which is always a single word but may be multiple tokens long after tokenization.
    • Where possible, prefer using the classification loss (described above) instead of this metric, as sequence probabilities are often hard to interpret; there may be multiple correct completions for a given prompt that compete for probability mass (see Holtzmann et al. 2021 for discussion). For this reason, tasks that use classification loss will be more likely to pass our contractor task validation process.
  2. The columns of the .csv are:
    1. prompt, a string up until the target word.
    2. completion, the target sequence (can be more than one token).

Signed difference in log-odds between examples (logodds)

  1. This loss metric measures how much the model changes its probabilities between the two prompts.
    • In particular, the model can get better overall while still showing inverse scaling on this metric if the difference in log-odds between the two prompts grows.
    • Use this metric when testing how much changing the prompt influences the relative probabilities of the two class tokens in some undesirable way (e.g., to show bias against women). We will evaluate the average, signed (not absolute) difference between two prompts.
      • The first prompt, called prompt, should be neutral or favor the correct/desirable answer (e.g., a question about men, if expecting a male-favored bias).
      • The second prompt, called other_prompt, should be neutral or favor an incorrect/undesirable answer (e.g., a question about women, if expecting a male-favored bias).
  2. The columns of the .csv are:
    1. prompt, a string.
      • prompt should be neutral or be expected to favor the correct answer.
    2. other_prompt, a string.
      • other_prompt should be neutral or be expected to favor the incorrect answer.
    3. classes, an ordered list (using valid Python syntax) of the two possible answer tokens.
      • NOTE: because of the way tokenizers process text, the class tokens should almost always start with a space and a capital letter, e.g. ” Yes” and ” No” rather than “yes” and “no”.
    4. answer_index, an integer specifying the index of the “correct” answer in the classes list (using zero-indexing).

Absolute difference in log-odds between examples (absolute_logodds)

  1. This loss metric is identical to the signed difference (logodds) except that the absolute value of each log-odds difference is taken before averaging across examples.
    • This is useful when you expect there to be some difference between the prompts but are not sure of the direction.
    • An example is slightly varying the prompts in ways that should be irrelevant to the prediction: see True Few-shot Learning with Language Models.
    • Please use the logodds metric instead if you expect the difference between prompts to go in a particular direction (e.g., a consistent, male-favored bias).
  2. The columns of the .csv are:
    1. prompt, a string.
      • prompt should be one version of the prompt.
    2. other_prompt, a string.
      • other_prompt should be another version of the prompt, which should produce some difference in log-odds.
    3. classes, an ordered list (using valid Python syntax) of the two possible answer tokens.
      • NOTE: because of the way tokenizers process text, the class tokens should almost always start with a space and a capital letter, e.g. ” Yes” and ” No” rather than “yes” and “no”.
    4. answer_index, an integer specifying the index of the “correct” answer in the classes list (using zero-indexing).
      • Note that this index does not matter for the absolute difference metric, but is needed for compatibility.

Submission instructions

  1. Create a .csv file with your dataset examples following the guidelines
    1. If you have created your dataset as a Google Sheet, click:
      • File > Download > Comma Separated Values (.csv)
    2. See this sheet for examples.
  2. Upload it to the GPT-3 colab and run it.
    • If you don’t have access to the OpenAI API, follow the instructions in the colab.
    • Based on our calculations, we expect the free credits provided by OpenAI to be enough to evaluate most tasks at least once across all model sizes.
      • During development, we recommend the OPT colab. In general, we recommend finding tasks that show inverse scaling with both GPT-3 and OPT, as such tasks are more likely to show inverse scaling during our evaluation procedure on held-out private models.
        • We also have a GPT-2 colab, but in our experience, the OPT colab demonstrates clearer scaling trends that generalize better to different and larger models.
      • Please message us on our Slack or email us if you are unable to participate due to a lack of funding for credits.
  3. Download the scaling plot produced.
  4. Fill in the submission form.

FAQ

  1. How does submitting to this contest interact with our own publication of the dataset/results?
    • We impose no restrictions on publication of submissions – in fact, we encourage it!
    • In addition, we will have performed a manual verification of the task labels and a scaling laws analysis on your data which may reduce the work required to publish.
  2. Can people without machine learning expertise participate?
    • Yes! Our resources (such as the GPT-3 colab for testing your task) are designed to be useable with no coding – just provide the data.
    • Here are some example Google sheets for each of the evaluation metrics: Inverse Scaling Dataset Examples.
    • Simply click File > Download > Comma Separated Values (.csv) to get a .csv file that can be submitted.
  3. Is there a restriction on what language the submission can be in? Is any arbitrary unicode script supported?
    • All languages are accepted so long as you can help us find contractors who are able to perform the task for label verification.
  4. Relatedly, if I have a task that I’ve translated into 10 languages, is that one multilingual task or 10 monolingual tasks?
    • Translations of a task count as the same task – please only submit each example in one language.
  5. How many tasks can I submit?
    • Contestants can win an award for each distinct submission; there’s no limit to the number of awards one can receive. That said, a single submission that covers a broad phenomenon is more likely to win a higher tier prize due to our “task importance” criterion, so contestants may wish to group tasks together when possible.
    • If we receive too many submissions from one contestant, we may ask the contestant to choose a subset of their submissions for evaluation, especially if the submissions seem low-quality.
  6. I’ve checked all labels in the submitted data, can I just report that instead of having your team verify it?
    • For consistency, all tasks will have to pass our review, even if they have undergone other validation.
  7. Why do we require task submissions to have at least 300 examples?
    • 300 examples was the minimum number of examples for which we found clean, standard scaling trends on LAMBADA. LAMBADA is a next word prediction (language-modeling-like) task where we expect to observe clear, standard scaling laws, so we expect 300 examples to be a rough minimum number of examples to observe (inverse) scaling laws.
  8. Should prompts include instructions?
    • For tasks where you expect that a typical NLP practitioner would try instruction prompting, we’d encourage you to formulate your task in this as well; we will consider your task submission more important and realistic if it shows inverse scaling even with clear instructions in the example prompts. Please make sure to format the instructions in a way that you should reasonably expect a pretrained LM (i.e., GPT-3 or OPT, rather than InstructGPT) should be able to understand.
  9. Should prompts include few-shot example sequences?
    • We encourage you to look for tasks that show inverse scaling even with in-context few-shot learning (as in the GPT-3 paper). For many tasks where a model does poorly, NLP practitioners would try few-shot learning. We will consider your task submission more important and realistic if it shows inverse scaling even with correctly-labeled few-shot examples of the task in the example prompts.
  10. How will the prize money be distributed between co-authors of a task submission?
    • We will leave it up to the co-authors of submissions to decide how to distribute the prize money between co-authors.
  11. How do I ask a question about the contest?
    • Please open a GitHub issue for general or public questions that others may have. Please email us at inverse.scaling@gmail.com or message us on the Inverse Scaling Slack for private questions related to your specific submission, task, or situation.
  12. What license should I use for my dataset?
    • Please use the CC-BY license, unless you have composed the dataset from already existing data sources. In the latter case, please use a license that is compatible with the license of preexisting data you used.
  13. Can I use data from existing datasets or sources in my submission?
    • We place no restrictions on where data can come from. For example, we would be interested to know if inverse scaling shows up on a well-known task where it hadn’t been observed yet, or on a specific, interesting subset of that task.
    • Licenses: Where possible, when using existing data, please use data licensed with CC-BY or less restrictive licenses, so we may release your dataset publicly. Less restrictive licenses make it easier for the dataset to be disseminated and used in a variety of settings (e.g., in industry research labs or to improve the safety of commercial products). We may not be able to release tasks that use a more restrictive license or incorporate them into a benchmark after our contest. That said, we still allow submissions with more restrictive licenses, because finding inverse scaling on some version of a task is a significant contribution. In this case, we may ask you to create a small, releasable version of the data based on your original task or to release code to reproduce a similar task to your submission.
  14. Can I submit examples of misuse as a task? What about other tasks that explicitly prompt the model to produce harmful behavior?
    • We don’t consider most cases of misuse or explicitly prompting for harmful behavior as surprising examples of inverse scaling. We expect that explicitly prompting/asking an LM to generate e.g. hate speech or propaganda will work more effectively with larger models, so we do not consider such behavior surprising. That said, we are still interested novel misuse examples, but they will need to be surprising in order to be accepted.
  15. Can I submit examples of bias, toxicity, or misinformation as a task?
    • In many of the above cases, inverse scaling has been shown to some extent in prior work. For example, [Solaiman & Dennison 2021] showed that larger GPT-3 models generate more toxic text, [BIG-Bench] showed that larger models show more bias related to gender, race, ethnicity, and nationality, and [TruthfulQA] suggests that larger models generate more plausible misinformation. As a result, we will apply more scrutiny for novelty on submissions on or other topics covered by prior work. That said, we are still interested in submissions related to these topics, if submissions effectively argue they have found a different phenomenon (e.g., a novel kind of bias) or that prior work did not sufficiently show inverse scaling for some behavior.

Tips

Inverse Scaling Prize on GitHub: https://github.com/inverse-scaling/prize
Platform: Machine Learinig
⭐️: 231
Exit mobile version