Add files using upload-large-folder tool

testbed/huggingface__datasets/.dvcignore

@@ -0,0 +1,3 @@
+# Add patterns of files dvc should ignore, which could improve
+# the performance. Learn more at
+# https://dvc.org/doc/user-guide/dvcignore

testbed/huggingface__datasets/.pre-commit-config.yaml

@@ -0,0 +1,9 @@
+repos:
+  - repo: https://github.com/charliermarsh/ruff-pre-commit # https://github.com/charliermarsh/ruff#usage
+    rev: 'v0.1.5'
+    hooks:
+      # Run the linter.
+      - id: ruff
+        args: [ --fix ]
+      # Run the formatter.
+      - id: ruff-format

testbed/huggingface__datasets/.zenodo.json

@@ -0,0 +1,130 @@
+{
+    "license": "Apache-2.0",
+    "creators": [
+        {
+            "affiliation": "Hugging Face",
+            "name": "Quentin Lhoest"
+        },
+        {
+            "orcid": "0000-0003-1727-1045",
+            "affiliation": "Hugging Face",
+            "name": "Albert Villanova del Moral"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Patrick von Platen"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Thomas Wolf"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Mario Šaško"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Yacine Jernite"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Abhishek Thakur"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Lewis Tunstall"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Suraj Patil"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Mariama Drame"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Julien Chaumond"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Julien Plu"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Joe Davison"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Simon Brandeis"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Victor Sanh"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Teven Le Scao"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Kevin Canwen Xu"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Nicolas Patry"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Steven Liu"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Angelina McMillan-Major"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Philipp Schmid"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Sylvain Gugger"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Nathan Raw"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Sylvain Lesage"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Anton Lozhkov"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Matthew Carrigan"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Th\u00e9o Matussi\u00e8re"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Leandro von Werra"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Lysandre Debut"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Stas Bekman"
+        },
+        {
+            "affiliation": "Hugging Face",
+            "name": "Cl\u00e9ment Delangue"
+        }
+    ]
+}

testbed/huggingface__datasets/ADD_NEW_DATASET.md

@@ -0,0 +1,8 @@
+# How to add one new datasets
+
+Add datasets directly to the 🤗 Hugging Face Hub!
+
+You can share your dataset on https://huggingface.co/datasets directly using your account, see the documentation:
+
+* [Create a dataset and upload files on the website](https://huggingface.co/docs/datasets/upload_dataset)
+* [Advanced guide using the CLI](https://huggingface.co/docs/datasets/share)

testbed/huggingface__datasets/AUTHORS

@@ -0,0 +1,8 @@
+# This is the list of HuggingFace Datasets authors for copyright purposes.
+#
+# This does not necessarily list everyone who has contributed code, since in
+# some cases, their employer may be the copyright holder.  To see the full list
+# of contributors, see the revision history in source control.
+
+Google Inc.
+HuggingFace Inc.

testbed/huggingface__datasets/CITATION.cff

@@ -0,0 +1,150 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+title: "huggingface/datasets"
+authors:
+- family-names: Lhoest
+  given-names: Quentin
+- family-names: Villanova del Moral
+  given-names: Albert
+  orcid: "https://orcid.org/0000-0003-1727-1045"
+- family-names: von Platen
+  given-names: Patrick
+- family-names: Wolf
+  given-names: Thomas
+- family-names: Šaško
+  given-names: Mario
+- family-names: Jernite
+  given-names: Yacine
+- family-names: Thakur
+  given-names: Abhishek
+- family-names: Tunstall
+  given-names: Lewis
+- family-names: Patil
+  given-names: Suraj
+- family-names: Drame
+  given-names: Mariama
+- family-names: Chaumond
+  given-names: Julien
+- family-names: Plu
+  given-names: Julien
+- family-names: Davison
+  given-names: Joe
+- family-names: Brandeis
+  given-names: Simon
+- family-names: Sanh
+  given-names: Victor
+- family-names: Le Scao
+  given-names: Teven
+- family-names: Canwen Xu
+  given-names: Kevin
+- family-names: Patry
+  given-names: Nicolas
+- family-names: Liu
+  given-names: Steven
+- family-names: McMillan-Major
+  given-names: Angelina
+- family-names: Schmid
+  given-names: Philipp
+- family-names: Gugger
+  given-names: Sylvain
+- family-names: Raw
+  given-names: Nathan
+- family-names: Lesage
+  given-names: Sylvain
+- family-names: Lozhkov
+  given-names: Anton
+- family-names: Carrigan
+  given-names: Matthew
+- family-names: Matussière
+  given-names: Théo
+- family-names: von Werra
+  given-names: Leandro
+- family-names: Debut
+  given-names: Lysandre
+- family-names: Bekman
+  given-names: Stas
+- family-names: Delangue
+  given-names: Clément
+doi: 10.5281/zenodo.4817768
+repository-code: "https://github.com/huggingface/datasets"
+license: Apache-2.0
+preferred-citation:
+  type: conference-paper
+  title: "Datasets: A Community Library for Natural Language Processing"
+  authors:
+  - family-names: Lhoest
+    given-names: Quentin
+  - family-names: Villanova del Moral
+    given-names: Albert
+    orcid: "https://orcid.org/0000-0003-1727-1045"
+  - family-names: von Platen
+    given-names: Patrick
+  - family-names: Wolf
+    given-names: Thomas
+  - family-names: Šaško
+    given-names: Mario
+  - family-names: Jernite
+    given-names: Yacine
+  - family-names: Thakur
+    given-names: Abhishek
+  - family-names: Tunstall
+    given-names: Lewis
+  - family-names: Patil
+    given-names: Suraj
+  - family-names: Drame
+    given-names: Mariama
+  - family-names: Chaumond
+    given-names: Julien
+  - family-names: Plu
+    given-names: Julien
+  - family-names: Davison
+    given-names: Joe
+  - family-names: Brandeis
+    given-names: Simon
+  - family-names: Sanh
+    given-names: Victor
+  - family-names: Le Scao
+    given-names: Teven
+  - family-names: Canwen Xu
+    given-names: Kevin
+  - family-names: Patry
+    given-names: Nicolas
+  - family-names: Liu
+    given-names: Steven
+  - family-names: McMillan-Major
+    given-names: Angelina
+  - family-names: Schmid
+    given-names: Philipp
+  - family-names: Gugger
+    given-names: Sylvain
+  - family-names: Raw
+    given-names: Nathan
+  - family-names: Lesage
+    given-names: Sylvain
+  - family-names: Lozhkov
+    given-names: Anton
+  - family-names: Carrigan
+    given-names: Matthew
+  - family-names: Matussière
+    given-names: Théo
+  - family-names: von Werra
+    given-names: Leandro
+  - family-names: Debut
+    given-names: Lysandre
+  - family-names: Bekman
+    given-names: Stas
+  - family-names: Delangue
+    given-names: Clément
+  collection-title: "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing: System Demonstrations"
+  collection-type: proceedings
+  month: 11
+  year: 2021
+  publisher:
+    name: "Association for Computational Linguistics"
+  url: "https://aclanthology.org/2021.emnlp-demo.21"
+  start: 175
+  end: 184
+  identifiers:
+    - type: other
+      value: "arXiv:2109.02846"
+      description: "The arXiv preprint of the paper"

testbed/huggingface__datasets/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+feedback@huggingface.co.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+[https://www.contributor-covenant.org/version/2/0/code_of_conduct.html][v2.0].
+
+Community Impact Guidelines were inspired by 
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available 
+at [https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.0]: https://www.contributor-covenant.org/version/2/0/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

testbed/huggingface__datasets/CONTRIBUTING.md

@@ -0,0 +1,122 @@
+# How to contribute to Datasets?
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](CODE_OF_CONDUCT.md)
+
+Datasets is an open source project, so all contributions and suggestions are welcome.
+
+You can contribute in many different ways: giving ideas, answering questions, reporting bugs, proposing enhancements,
+improving the documentation, fixing bugs,...
+
+Many thanks in advance to every contributor.
+
+In order to facilitate healthy, constructive behavior in an open and inclusive community, we all respect and abide by
+our [code of conduct](CODE_OF_CONDUCT.md).
+
+## How to work on an open Issue?
+You have the list of open Issues at: https://github.com/huggingface/datasets/issues
+
+Some of them may have the label `help wanted`: that means that any contributor is welcomed!
+
+If you would like to work on any of the open Issues:
+
+1. Make sure it is not already assigned to someone else. You have the assignee (if any) on the top of the right column of the Issue page.
+
+2. You can self-assign it by commenting on the Issue page with the keyword: `#self-assign`.
+
+3. Work on your self-assigned issue and eventually create a Pull Request.
+
+## How to create a Pull Request?
+If you want to add a dataset see specific instructions in the section [*How to add a dataset*](#how-to-add-a-dataset).
+
+1. Fork the [repository](https://github.com/huggingface/datasets) by clicking on the 'Fork' button on the repository's page. This creates a copy of the code under your GitHub user account.
+
+2. Clone your fork to your local disk, and add the base repository as a remote:
+
+    ```bash
+    git clone git@github.com:<your Github handle>/datasets.git
+    cd datasets
+    git remote add upstream https://github.com/huggingface/datasets.git
+    ```
+
+3. Create a new branch to hold your development changes:
+
+    ```bash
+    git checkout -b a-descriptive-name-for-my-changes
+    ```
+
+    **do not** work on the `main` branch.
+
+4. Set up a development environment by running the following command in a virtual environment:
+
+    ```bash
+    pip install -e ".[dev]"
+    ```
+
+   (If datasets was already installed in the virtual environment, remove
+   it with `pip uninstall datasets` before reinstalling it in editable
+   mode with the `-e` flag.)
+
+5. Develop the features on your branch.
+
+6. Format your code. Run `black` and `ruff` so that your newly added files look nice with the following command:
+
+    ```bash
+    make style
+    ```
+   
+7. _(Optional)_ You can also use [`pre-commit`](https://pre-commit.com/) to format your code automatically each time run `git commit`, instead of running `make style` manually. 
+To do this, install `pre-commit` via `pip install pre-commit` and then run `pre-commit install` in the project's root directory to set up the hooks.
+Note that if any files were formatted by `pre-commit` hooks during committing, you have to run `git commit` again .
+
+
+8. Once you're happy with your contribution, add your changed files and make a commit to record your changes locally:
+
+    ```bash
+    git add -u
+    git commit
+    ```
+
+    It is a good idea to sync your copy of the code with the original
+    repository regularly. This way you can quickly account for changes:
+
+    ```bash
+    git fetch upstream
+    git rebase upstream/main
+    ```
+
+9. Once you are satisfied, push the changes to your fork repo using:
+
+   ```bash
+   git push -u origin a-descriptive-name-for-my-changes
+   ```
+
+   Go the webpage of your fork on GitHub. Click on "Pull request" to send your to the project maintainers for review.
+
+## How to add a dataset
+
+You can share your dataset on https://huggingface.co/datasets directly using your account, see the documentation:
+
+* [Create a dataset and upload files on the website](https://huggingface.co/docs/datasets/upload_dataset)
+* [Advanced guide using the CLI](https://huggingface.co/docs/datasets/share)
+
+## How to contribute to the dataset cards
+
+Improving the documentation of datasets is an ever-increasing effort, and we invite users to contribute by sharing their insights with the community in the `README.md` dataset cards provided for each dataset.
+
+If you see that a dataset card is missing information that you are in a position to provide (as an author of the dataset or as an experienced user), the best thing you can do is to open a Pull Request on the Hugging Face Hub. To do, go to the "Files and versions" tab of the dataset page and edit the `README.md` file. We provide:
+
+* a [template](https://github.com/huggingface/datasets/blob/main/templates/README.md)
+* a [guide](https://github.com/huggingface/datasets/blob/main/templates/README_guide.md) describing what information should go into each of the paragraphs
+* and if you need inspiration, we recommend looking through a [completed example](https://huggingface.co/datasets/eli5/blob/main/README.md)
+
+If you are a **dataset author**... you know what to do, it is your dataset after all ;) ! We would especially appreciate if you could help us fill in information about the process of creating the dataset, and take a moment to reflect on its social impact and possible limitations if you haven't already done so in the dataset paper or in another data statement.
+
+If you are a **user of a dataset**, the main source of information should be the dataset paper if it is available: we recommend pulling information from there into the relevant paragraphs of the template. We also eagerly welcome discussions on the [Considerations for Using the Data](https://github.com/huggingface/datasets/blob/main/templates/README_guide.md#considerations-for-using-the-data) based on existing scholarship or personal experience that would benefit the whole community.
+
+Finally, if you want more information on the how and why of dataset cards, we strongly recommend reading the foundational works [Datasheets for Datasets](https://arxiv.org/abs/1803.09010) and [Data Statements for NLP](https://www.aclweb.org/anthology/Q18-1041/).
+
+Thank you for your contribution!
+
+## Code of conduct
+
+This project adheres to the HuggingFace [code of conduct](CODE_OF_CONDUCT.md).
+By participating, you are expected to abide by this code.

testbed/huggingface__datasets/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

testbed/huggingface__datasets/Makefile

@@ -0,0 +1,20 @@
+.PHONY: quality style test
+
+check_dirs := tests src benchmarks metrics utils
+
+# Check that source code meets quality standards
+
+quality:
+	ruff check $(check_dirs) setup.py  # linter
+	ruff format --check $(check_dirs) setup.py # formatter
+
+# Format source code automatically
+
+style:
+	ruff check --fix $(check_dirs) setup.py # linter
+	ruff format $(check_dirs) setup.py # formatter
+
+# Run tests for the library
+
+test:
+	python -m pytest -n auto --dist=loadfile -s -v ./tests/

testbed/huggingface__datasets/README.md

@@ -0,0 +1,212 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/datasets-logo-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/datasets-logo-light.svg">
+    <img alt="Hugging Face Datasets Library" src="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/datasets-logo-light.svg" width="352" height="59" style="max-width: 100%;">
+  </picture>
+  <br/>
+  <br/>
+</p>
+
+<p align="center">
+    <a href="https://github.com/huggingface/datasets/actions/workflows/ci.yml?query=branch%3Amain">
+        <img alt="Build" src="https://github.com/huggingface/datasets/actions/workflows/ci.yml/badge.svg?branch=main">
+    </a>
+    <a href="https://github.com/huggingface/datasets/blob/main/LICENSE">
+        <img alt="GitHub" src="https://img.shields.io/github/license/huggingface/datasets.svg?color=blue">
+    </a>
+    <a href="https://huggingface.co/docs/datasets/index.html">
+        <img alt="Documentation" src="https://img.shields.io/website/http/huggingface.co/docs/datasets/index.html.svg?down_color=red&down_message=offline&up_message=online">
+    </a>
+    <a href="https://github.com/huggingface/datasets/releases">
+        <img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/datasets.svg">
+    </a>
+    <a href="https://huggingface.co/datasets/">
+        <img alt="Number of datasets" src="https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen">
+    </a>
+    <a href="CODE_OF_CONDUCT.md">
+        <img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg">
+    </a>
+    <a href="https://zenodo.org/badge/latestdoi/250213286"><img src="https://zenodo.org/badge/250213286.svg" alt="DOI"></a>
+</p>
+
+🤗 Datasets is a lightweight library providing **two** main features:
+
+- **one-line dataloaders for many public datasets**: one-liners to download and pre-process any of the ![number of datasets](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen) major public datasets (image datasets, audio datasets, text datasets in 467 languages and dialects, etc.) provided on the [HuggingFace Datasets Hub](https://huggingface.co/datasets). With a simple command like `squad_dataset = load_dataset("squad")`, get any of these datasets ready to use in a dataloader for training/evaluating a ML model (Numpy/Pandas/PyTorch/TensorFlow/JAX),
+- **efficient data pre-processing**: simple, fast and reproducible data pre-processing for the public datasets as well as your own local datasets in CSV, JSON, text, PNG, JPEG, WAV, MP3, Parquet, etc. With simple commands like `processed_dataset = dataset.map(process_example)`, efficiently prepare the dataset for inspection and ML model evaluation and training.
+
+[🎓 **Documentation**](https://huggingface.co/docs/datasets/) [🔎 **Find a dataset in the Hub**](https://huggingface.co/datasets) [🌟 **Share a dataset on the Hub**](https://huggingface.co/docs/datasets/share)
+
+<h3 align="center">
+    <a href="https://hf.co/course"><img src="https://raw.githubusercontent.com/huggingface/datasets/main/docs/source/imgs/course_banner.png"></a>
+</h3>
+
+🤗 Datasets is designed to let the community easily add and share new datasets.
+
+🤗 Datasets has many additional interesting features:
+
+- Thrive on large datasets: 🤗 Datasets naturally frees the user from RAM memory limitation, all datasets are memory-mapped using an efficient zero-serialization cost backend (Apache Arrow).
+- Smart caching: never wait for your data to process several times.
+- Lightweight and fast with a transparent and pythonic API (multi-processing/caching/memory-mapping).
+- Built-in interoperability with NumPy, pandas, PyTorch, TensorFlow 2 and JAX.
+- Native support for audio and image data.
+- Enable streaming mode to save disk space and start iterating over the dataset immediately.
+
+🤗 Datasets originated from a fork of the awesome [TensorFlow Datasets](https://github.com/tensorflow/datasets) and the HuggingFace team want to deeply thank the TensorFlow Datasets team for building this amazing library. More details on the differences between 🤗 Datasets and `tfds` can be found in the section [Main differences between 🤗 Datasets and `tfds`](#main-differences-between--datasets-and-tfds).
+
+# Installation
+
+## With pip
+
+🤗 Datasets can be installed from PyPi and has to be installed in a virtual environment (venv or conda for instance)
+
+```bash
+pip install datasets
+```
+
+## With conda
+
+🤗 Datasets can be installed using conda as follows:
+
+```bash
+conda install -c huggingface -c conda-forge datasets
+```
+
+Follow the installation pages of TensorFlow and PyTorch to see how to install them with conda.
+
+For more details on installation, check the installation page in the documentation: https://huggingface.co/docs/datasets/installation
+
+## Installation to use with PyTorch/TensorFlow/pandas
+
+If you plan to use 🤗 Datasets with PyTorch (1.0+), TensorFlow (2.2+) or pandas, you should also install PyTorch, TensorFlow or pandas.
+
+For more details on using the library with NumPy, pandas, PyTorch or TensorFlow, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart
+
+# Usage
+
+🤗 Datasets is made to be very simple to use - the API is centered around a single function, `datasets.load_dataset(dataset_name, **kwargs)`, that instantiates a dataset.
+
+This library can be used for text/image/audio/etc. datasets. Here is an example to load a text dataset:
+
+Here is a quick example:
+
+```python
+from datasets import load_dataset
+
+# Print all the available datasets
+from huggingface_hub import list_datasets
+print([dataset.id for dataset in list_datasets()])
+
+# Load a dataset and print the first example in the training set
+squad_dataset = load_dataset('squad')
+print(squad_dataset['train'][0])
+
+# Process the dataset - add a column with the length of the context texts
+dataset_with_length = squad_dataset.map(lambda x: {"length": len(x["context"])})
+
+# Process the dataset - tokenize the context texts (using a tokenizer from the 🤗 Transformers library)
+from transformers import AutoTokenizer
+tokenizer = AutoTokenizer.from_pretrained('bert-base-cased')
+
+tokenized_dataset = squad_dataset.map(lambda x: tokenizer(x['context']), batched=True)
+```
+
+If your dataset is bigger than your disk or if you don't want to wait to download the data, you can use streaming:
+
+```python
+# If you want to use the dataset immediately and efficiently stream the data as you iterate over the dataset
+image_dataset = load_dataset('cifar100', streaming=True)
+for example in image_dataset["train"]:
+    break
+```
+
+For more details on using the library, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart and the specific pages on:
+
+- Loading a dataset: https://huggingface.co/docs/datasets/loading
+- What's in a Dataset: https://huggingface.co/docs/datasets/access
+- Processing data with 🤗 Datasets: https://huggingface.co/docs/datasets/process
+    - Processing audio data: https://huggingface.co/docs/datasets/audio_process
+    - Processing image data: https://huggingface.co/docs/datasets/image_process
+    - Processing text data: https://huggingface.co/docs/datasets/nlp_process
+- Streaming a dataset: https://huggingface.co/docs/datasets/stream
+- Writing your own dataset loading script: https://huggingface.co/docs/datasets/dataset_script
+- etc.
+
+# Add a new dataset to the Hub
+
+We have a very detailed step-by-step guide to add a new dataset to the ![number of datasets](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen) datasets already provided on the [HuggingFace Datasets Hub](https://huggingface.co/datasets).
+
+You can find:
+- [how to upload a dataset to the Hub using your web browser or Python](https://huggingface.co/docs/datasets/upload_dataset) and also
+- [how to upload it using Git](https://huggingface.co/docs/datasets/share).
+
+# Main differences between 🤗 Datasets and `tfds`
+
+If you are familiar with the great TensorFlow Datasets, here are the main differences between 🤗 Datasets and `tfds`:
+
+- the scripts in 🤗 Datasets are not provided within the library but are queried, downloaded/cached and dynamically loaded upon request
+- the backend serialization of 🤗 Datasets is based on [Apache Arrow](https://arrow.apache.org/) instead of TF Records and leverage python dataclasses for info and features with some diverging features (we mostly don't do encoding and store the raw data as much as possible in the backend serialization cache).
+- the user-facing dataset object of 🤗 Datasets is not a `tf.data.Dataset` but a built-in framework-agnostic dataset class with methods inspired by what we like in `tf.data` (like a `map()` method). It basically wraps a memory-mapped Arrow table cache.
+
+# Disclaimers
+
+🤗 Datasets may run Python code defined by the dataset authors to parse certain data formats or structures. For security reasons, we ask users to:
+- check the dataset scripts they're going to run beforehand and
+- pin the `revision` of the repositories they use.
+
+If you're a dataset owner and wish to update any part of it (description, citation, license, etc.), or do not want your dataset to be included in the Hugging Face Hub, please get in touch by opening a discussion or a pull request in the Community tab of the dataset page. Thanks for your contribution to the ML community!
+
+## BibTeX
+
+If you want to cite our 🤗 Datasets library, you can use our [paper](https://arxiv.org/abs/2109.02846):
+
+```bibtex
+@inproceedings{lhoest-etal-2021-datasets,
+    title = "Datasets: A Community Library for Natural Language Processing",
+    author = "Lhoest, Quentin  and
+      Villanova del Moral, Albert  and
+      Jernite, Yacine  and
+      Thakur, Abhishek  and
+      von Platen, Patrick  and
+      Patil, Suraj  and
+      Chaumond, Julien  and
+      Drame, Mariama  and
+      Plu, Julien  and
+      Tunstall, Lewis  and
+      Davison, Joe  and
+      {\v{S}}a{\v{s}}ko, Mario  and
+      Chhablani, Gunjan  and
+      Malik, Bhavitvya  and
+      Brandeis, Simon  and
+      Le Scao, Teven  and
+      Sanh, Victor  and
+      Xu, Canwen  and
+      Patry, Nicolas  and
+      McMillan-Major, Angelina  and
+      Schmid, Philipp  and
+      Gugger, Sylvain  and
+      Delangue, Cl{\'e}ment  and
+      Matussi{\`e}re, Th{\'e}o  and
+      Debut, Lysandre  and
+      Bekman, Stas  and
+      Cistac, Pierric  and
+      Goehringer, Thibault  and
+      Mustar, Victor  and
+      Lagunas, Fran{\c{c}}ois  and
+      Rush, Alexander  and
+      Wolf, Thomas",
+    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing: System Demonstrations",
+    month = nov,
+    year = "2021",
+    address = "Online and Punta Cana, Dominican Republic",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2021.emnlp-demo.21",
+    pages = "175--184",
+    abstract = "The scale, variety, and quantity of publicly-available NLP datasets has grown rapidly as researchers propose new tasks, larger models, and novel benchmarks. Datasets is a community library for contemporary NLP designed to support this ecosystem. Datasets aims to standardize end-user interfaces, versioning, and documentation, while providing a lightweight front-end that behaves similarly for small datasets as for internet-scale corpora. The design of the library incorporates a distributed, community-driven approach to adding datasets and documenting usage. After a year of development, the library now includes more than 650 unique datasets, has more than 250 contributors, and has helped support a variety of novel cross-dataset research projects and shared tasks. The library is available at https://github.com/huggingface/datasets.",
+    eprint={2109.02846},
+    archivePrefix={arXiv},
+    primaryClass={cs.CL},
+}
+```
+
+If you need to cite a specific version of our 🤗 Datasets library for reproducibility, you can use the corresponding version Zenodo DOI from this [list](https://zenodo.org/search?q=conceptrecid:%224817768%22&sort=-version&all_versions=True).

testbed/huggingface__datasets/SECURITY.md

@@ -0,0 +1,33 @@
+# Security Policy
+
+## Supported Versions
+<!--
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 5.1.x   | :white_check_mark: |
+| 5.0.x   | :x:                |
+| 4.0.x   | :white_check_mark: |
+| < 4.0   | :x:                |
+-->
+
+Each major version is currently being supported with security updates.
+
+| Version | Supported          |
+|---------|--------------------|
+| 1.x.x   | :white_check_mark: |
+| 2.x.x   | :white_check_mark: |
+
+
+## Reporting a Vulnerability
+<!--
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.
+-->
+
+To report a security vulnerability, please contact: security@huggingface.co

testbed/huggingface__datasets/additional-tests-requirements.txt

@@ -0,0 +1,4 @@
+unbabel-comet>=1.0.0
+git+https://github.com/google-research/bleurt.git
+git+https://github.com/ns-moosavi/coval.git
+git+https://github.com/hendrycks/math.git

testbed/huggingface__datasets/benchmarks/benchmark_array_xd.py

@@ -0,0 +1,142 @@
+import json
+import os
+import tempfile
+
+import datasets
+from datasets.arrow_writer import ArrowWriter
+from datasets.features import Array2D
+from utils import generate_examples, get_duration
+
+
+SHAPE_TEST_1 = (30, 487)
+SHAPE_TEST_2 = (36, 1024)
+SPEED_TEST_SHAPE = (100, 100)
+SPEED_TEST_N_EXAMPLES = 100
+
+DEFAULT_FEATURES = datasets.Features(
+    {"text": Array2D(SHAPE_TEST_1, dtype="float32"), "image": Array2D(SHAPE_TEST_2, dtype="float32")}
+)
+
+RESULTS_BASEPATH, RESULTS_FILENAME = os.path.split(__file__)
+RESULTS_FILE_PATH = os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json"))
+
+
+@get_duration
+def write(my_features, dummy_data, tmp_dir):
+    with ArrowWriter(features=my_features, path=os.path.join(tmp_dir, "beta.arrow")) as writer:
+        for key, record in dummy_data:
+            example = my_features.encode_example(record)
+            writer.write(example)
+        num_examples, num_bytes = writer.finalize()
+
+
+@get_duration
+def read_unformated(feats, tmp_dir):
+    dataset = datasets.Dataset.from_file(
+        filename=os.path.join(tmp_dir, "beta.arrow"), info=datasets.DatasetInfo(features=feats)
+    )
+    for _ in dataset:
+        pass
+
+
+@get_duration
+def read_formatted_as_numpy(feats, tmp_dir):
+    dataset = datasets.Dataset.from_file(
+        filename=os.path.join(tmp_dir, "beta.arrow"), info=datasets.DatasetInfo(features=feats)
+    )
+    dataset.set_format("numpy")
+    for _ in dataset:
+        pass
+
+
+@get_duration
+def read_batch_unformated(feats, tmp_dir):
+    batch_size = 10
+    dataset = datasets.Dataset.from_file(
+        filename=os.path.join(tmp_dir, "beta.arrow"), info=datasets.DatasetInfo(features=feats)
+    )
+    for i in range(0, len(dataset), batch_size):
+        _ = dataset[i : i + batch_size]
+
+
+@get_duration
+def read_batch_formatted_as_numpy(feats, tmp_dir):
+    batch_size = 10
+    dataset = datasets.Dataset.from_file(
+        filename=os.path.join(tmp_dir, "beta.arrow"), info=datasets.DatasetInfo(features=feats)
+    )
+    dataset.set_format("numpy")
+    for i in range(0, len(dataset), batch_size):
+        _ = dataset[i : i + batch_size]
+
+
+@get_duration
+def read_col_unformated(feats, tmp_dir):
+    dataset = datasets.Dataset.from_file(
+        filename=os.path.join(tmp_dir, "beta.arrow"), info=datasets.DatasetInfo(features=feats)
+    )
+    for col in feats:
+        _ = dataset[col]
+
+
+@get_duration
+def read_col_formatted_as_numpy(feats, tmp_dir):
+    dataset = datasets.Dataset.from_file(
+        filename=os.path.join(tmp_dir, "beta.arrow"), info=datasets.DatasetInfo(features=feats)
+    )
+    dataset.set_format("numpy")
+    for col in feats:
+        _ = dataset[col]
+
+
+def benchmark_array_xd():
+    times = {}
+    read_functions = (
+        read_unformated,
+        read_formatted_as_numpy,
+        read_batch_unformated,
+        read_batch_formatted_as_numpy,
+        read_col_unformated,
+        read_col_formatted_as_numpy,
+    )
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        feats = datasets.Features({"image": Array2D(SPEED_TEST_SHAPE, dtype="float32")})
+        data = generate_examples(features=feats, num_examples=SPEED_TEST_N_EXAMPLES)
+        times["write_array2d"] = write(feats, data, tmp_dir)
+        for read_func in read_functions:
+            times[read_func.__name__ + " after write_array2d"] = read_func(feats, tmp_dir)
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        # don't use fixed length for fair comparison
+        # feats = datasets.Features(
+        #     {"image": datasets.Sequence(datasets.Sequence(datasets.Value("float32"), SPEED_TEST_SHAPE[1]), SPEED_TEST_SHAPE[0])}
+        # )
+        feats = datasets.Features({"image": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))})
+        data = generate_examples(
+            features=feats, num_examples=SPEED_TEST_N_EXAMPLES, seq_shapes={"image": SPEED_TEST_SHAPE}
+        )
+        times["write_nested_sequence"] = write(feats, data, tmp_dir)
+        for read_func in read_functions:
+            times[read_func.__name__ + " after write_nested_sequence"] = read_func(feats, tmp_dir)
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        # don't use fixed length for fair comparison
+        # feats = datasets.Features(
+        #     {"image": datasets.Sequence(datasets.Value("float32"), SPEED_TEST_SHAPE[0] * SPEED_TEST_SHAPE[1])}
+        # )
+        feats = datasets.Features({"image": datasets.Sequence(datasets.Value("float32"))})
+        data = generate_examples(
+            features=feats,
+            num_examples=SPEED_TEST_N_EXAMPLES,
+            seq_shapes={"image": [SPEED_TEST_SHAPE[0] * SPEED_TEST_SHAPE[1]]},
+        )
+        times["write_flattened_sequence"] = write(feats, data, tmp_dir)
+        for read_func in read_functions:
+            times[read_func.__name__ + " after write_flattened_sequence"] = read_func(feats, tmp_dir)
+
+    with open(RESULTS_FILE_PATH, "wb") as f:
+        f.write(json.dumps(times).encode("utf-8"))
+
+
+if __name__ == "__main__":  # useful to run the profiler
+    benchmark_array_xd()

testbed/huggingface__datasets/benchmarks/benchmark_iterating.py

@@ -0,0 +1,98 @@
+import json
+import os
+import tempfile
+
+import datasets
+from utils import generate_example_dataset, get_duration
+
+
+SPEED_TEST_N_EXAMPLES = 50_000
+SMALL_TEST = 5_000
+
+RESULTS_BASEPATH, RESULTS_FILENAME = os.path.split(__file__)
+RESULTS_FILE_PATH = os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json"))
+
+
+@get_duration
+def read(dataset: datasets.Dataset, length):
+    for i in range(length):
+        _ = dataset[i]
+
+
+@get_duration
+def read_batch(dataset: datasets.Dataset, length, batch_size):
+    for i in range(0, len(dataset), batch_size):
+        _ = dataset[i : i + batch_size]
+
+
+@get_duration
+def read_formatted(dataset: datasets.Dataset, length, type):
+    with dataset.formatted_as(type=type):
+        for i in range(length):
+            _ = dataset[i]
+
+
+@get_duration
+def read_formatted_batch(dataset: datasets.Dataset, length, batch_size, type):
+    with dataset.formatted_as(type=type):
+        for i in range(0, length, batch_size):
+            _ = dataset[i : i + batch_size]
+
+
+def benchmark_iterating():
+    times = {"num examples": SPEED_TEST_N_EXAMPLES}
+    functions = [
+        (read, {"length": SMALL_TEST}),
+        (read, {"length": SPEED_TEST_N_EXAMPLES}),
+        (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 10}),
+        (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 100}),
+        (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 1_000}),
+        (read_formatted, {"type": "numpy", "length": SMALL_TEST}),
+        (read_formatted, {"type": "pandas", "length": SMALL_TEST}),
+        (read_formatted, {"type": "torch", "length": SMALL_TEST}),
+        (read_formatted, {"type": "tensorflow", "length": SMALL_TEST}),
+        (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 10}),
+        (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 1_000}),
+    ]
+
+    functions_shuffled = [
+        (read, {"length": SMALL_TEST}),
+        (read, {"length": SPEED_TEST_N_EXAMPLES}),
+        (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 10}),
+        (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 100}),
+        (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 1_000}),
+        (read_formatted, {"type": "numpy", "length": SMALL_TEST}),
+        (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 10}),
+        (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 1_000}),
+    ]
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        print("generating dataset")
+        features = datasets.Features(
+            {"list": datasets.Sequence(datasets.Value("float32")), "numbers": datasets.Value("float32")}
+        )
+        dataset = generate_example_dataset(
+            os.path.join(tmp_dir, "dataset.arrow"),
+            features,
+            num_examples=SPEED_TEST_N_EXAMPLES,
+            seq_shapes={"list": (100,)},
+        )
+        print("first set of iterations")
+        for func, kwargs in functions:
+            print(func.__name__, str(kwargs))
+            times[func.__name__ + " " + " ".join(str(v) for v in kwargs.values())] = func(dataset, **kwargs)
+
+        print("shuffling dataset")
+        dataset = dataset.shuffle()
+        print("Second set of iterations (after shuffling")
+        for func, kwargs in functions_shuffled:
+            print("shuffled ", func.__name__, str(kwargs))
+            times["shuffled " + func.__name__ + " " + " ".join(str(v) for v in kwargs.values())] = func(
+                dataset, **kwargs
+            )
+
+    with open(RESULTS_FILE_PATH, "wb") as f:
+        f.write(json.dumps(times).encode("utf-8"))
+
+
+if __name__ == "__main__":  # useful to run the profiler
+    benchmark_iterating()

testbed/huggingface__datasets/benchmarks/benchmark_map_filter.py

@@ -0,0 +1,71 @@
+import json
+import os
+import tempfile
+
+import transformers
+
+import datasets
+from utils import generate_example_dataset, get_duration
+
+
+SPEED_TEST_N_EXAMPLES = 500_000
+
+RESULTS_BASEPATH, RESULTS_FILENAME = os.path.split(__file__)
+RESULTS_FILE_PATH = os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json"))
+
+
+@get_duration
+def map(dataset: datasets.Dataset, **kwargs):
+    _ = dataset.map(**kwargs)
+
+
+@get_duration
+def filter(dataset: datasets.Dataset, **kwargs):
+    _ = dataset.filter(**kwargs)
+
+
+def benchmark_map_filter():
+    times = {"num examples": SPEED_TEST_N_EXAMPLES}
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        features = datasets.Features({"text": datasets.Value("string"), "numbers": datasets.Value("float32")})
+        dataset = generate_example_dataset(
+            os.path.join(tmp_dir, "dataset.arrow"), features, num_examples=SPEED_TEST_N_EXAMPLES
+        )
+
+        tokenizer = transformers.AutoTokenizer.from_pretrained("bert-base-cased", use_fast=True)
+
+        def tokenize(examples):
+            return tokenizer(examples["text"])
+
+        times["map identity"] = map(dataset)
+
+        times["map identity batched"] = map(dataset, batched=True)
+
+        times["map no-op batched"] = map(dataset, function=lambda x: None, batched=True)
+
+        with dataset.formatted_as(type="numpy"):
+            times["map no-op batched numpy"] = map(dataset, function=lambda x: None, batched=True)
+
+        with dataset.formatted_as(type="pandas"):
+            times["map no-op batched pandas"] = map(dataset, function=lambda x: None, batched=True)
+
+        with dataset.formatted_as(type="torch", columns="numbers"):
+            times["map no-op batched pytorch"] = map(dataset, function=lambda x: None, batched=True)
+
+        with dataset.formatted_as(type="tensorflow", columns="numbers"):
+            times["map no-op batched tensorflow"] = map(dataset, function=lambda x: None, batched=True)
+
+        times["map fast-tokenizer batched"] = map(dataset, function=tokenize, batched=True)
+
+        times["filter"] = filter(dataset)
+
+        # Activate later when tokenizer support batched inputs
+        # with dataset.formatted_as(type='numpy'):
+        #     times[func.__name__ + " fast-tokenizer batched numpy"] = func(dataset, function=tokenize, batched=True)
+
+    with open(RESULTS_FILE_PATH, "wb") as f:
+        f.write(json.dumps(times).encode("utf-8"))
+
+
+if __name__ == "__main__":  # useful to run the profiler
+    benchmark_map_filter()

testbed/huggingface__datasets/benchmarks/format.py

@@ -0,0 +1,49 @@
+import json
+import sys
+
+
+def format_json_to_md(input_json_file, output_md_file):
+    with open(input_json_file, encoding="utf-8") as f:
+        results = json.load(f)
+
+    output_md = ["<details>", "<summary>Show updated benchmarks!</summary>", " "]
+
+    for benchmark_name in sorted(results):
+        benchmark_res = results[benchmark_name]
+
+        benchmark_file_name = benchmark_name.split("/")[-1]
+        output_md.append(f"### Benchmark: {benchmark_file_name}")
+
+        title = "| metric |"
+        lines = "|--------|"
+        value = "| new / old (diff) |"
+        for metric_name in sorted(benchmark_res):
+            metric_vals = benchmark_res[metric_name]
+            new_val = metric_vals["new"]
+            old_val = metric_vals.get("old", None)
+            dif_val = metric_vals.get("diff", None)
+
+            val_str = f" {new_val:f}" if isinstance(new_val, (int, float)) else "None"
+
+            if old_val is not None:
+                val_str += f" / {old_val:f}" if isinstance(old_val, (int, float)) else "None"
+            if dif_val is not None:
+                val_str += f" ({dif_val:f})" if isinstance(dif_val, (int, float)) else "None"
+
+            title += " " + metric_name + " |"
+            lines += "---|"
+            value += val_str + " |"
+
+        output_md += [title, lines, value, " "]
+
+    output_md.append("</details>")
+
+    with open(output_md_file, "w", encoding="utf-8") as f:
+        f.writelines("\n".join(output_md))
+
+
+if __name__ == "__main__":
+    input_json_file = sys.argv[1]
+    output_md_file = sys.argv[2]
+
+    format_json_to_md(input_json_file, output_md_file)

testbed/huggingface__datasets/benchmarks/results/benchmark_array_xd.json

@@ -0,0 +1 @@
+{"write_array2d": 0.14168284999323077, "read_unformated after write_array2d": 0.04353281999647152, "read_formatted_as_numpy after write_array2d": 0.1285462469968479, "read_batch_unformated after write_array2d": 0.023109222995117307, "read_batch_formatted_as_numpy after write_array2d": 0.011352884990628809, "read_col_unformated after write_array2d": 0.037052362007671036, "read_col_formatted_as_numpy after write_array2d": 0.007985618998645805, "write_nested_sequence": 1.4927163410029607, "read_unformated after write_nested_sequence": 0.28319963401008863, "read_formatted_as_numpy after write_nested_sequence": 0.419271487990045, "read_batch_unformated after write_nested_sequence": 0.3234798710036557, "read_batch_formatted_as_numpy after write_nested_sequence": 0.03850809299910907, "read_col_unformated after write_nested_sequence": 0.29384092400141526, "read_col_formatted_as_numpy after write_nested_sequence": 0.004250421989127062, "write_flattened_sequence": 1.4521546780015342, "read_unformated after write_flattened_sequence": 0.25513897799828555, "read_formatted_as_numpy after write_flattened_sequence": 0.07564631900459062, "read_batch_unformated after write_flattened_sequence": 0.2758980469952803, "read_batch_formatted_as_numpy after write_flattened_sequence": 0.011008214991306886, "read_col_unformated after write_flattened_sequence": 0.25848906899045687, "read_col_formatted_as_numpy after write_flattened_sequence": 0.004328447001171298}

testbed/huggingface__datasets/benchmarks/results/benchmark_getitem_100B.json

@@ -0,0 +1 @@
+{"num examples": 100000000000, "get_first_row": 0.00019991099999927542, "get_last_row": 5.4411000000698095e-05, "get_batch_of_1024_rows": 0.0004897069999998394, "get_batch_of_1024_random_rows": 0.01800621099999944}

testbed/huggingface__datasets/benchmarks/results/benchmark_iterating.json

@@ -0,0 +1 @@
+{"num examples": 50000, "read 5000": 0.2152090710005723, "read 50000": 2.077654693988734, "read_batch 50000 10": 1.5041199039987987, "read_batch 50000 100": 1.5411947140091797, "read_batch 50000 1000": 1.4684901159926085, "read_formatted numpy 5000": 4.584776938994764, "read_formatted pandas 5000": 3.7457121399929747, "read_formatted torch 5000": 4.565676491998602, "read_formatted tensorflow 5000": 5.269861594992108, "read_formatted_batch numpy 5000 10": 0.4242750950070331, "read_formatted_batch numpy 5000 1000": 0.007607111998368055, "shuffled read 5000": 0.22604441999283154, "shuffled read 50000": 2.268928524994408, "shuffled read_batch 50000 10": 55.44462437101174, "shuffled read_batch 50000 100": 6.876476717996411, "shuffled read_batch 50000 1000": 2.1420724369963864, "shuffled read_formatted numpy 5000": 4.8052272600034485, "shuffled read_formatted_batch numpy 5000 10": 6.500664097999106, "shuffled read_formatted_batch numpy 5000 1000": 0.0754691059992183}

testbed/huggingface__datasets/benchmarks/results/benchmark_map_filter.json

@@ -0,0 +1 @@
+{"num examples": 500000, "map identity": 10.19139202599763, "map identity batched": 0.6804238399927272, "map no-op batched": 0.5342009569867514, "map no-op batched numpy": 0.5792830920108827, "map no-op batched pandas": 0.4343639040016569, "map no-op batched pytorch": 0.5403374370071106, "map no-op batched tensorflow": 1.3869360350072384, "map fast-tokenizer batched": 8.074308118986664, "filter": 1.841787679004483}

testbed/huggingface__datasets/benchmarks/utils.py

@@ -0,0 +1,64 @@
+import timeit
+
+import numpy as np
+
+import datasets
+from datasets.arrow_writer import ArrowWriter
+from datasets.features.features import _ArrayXD
+
+
+def get_duration(func):
+    def wrapper(*args, **kwargs):
+        starttime = timeit.default_timer()
+        _ = func(*args, **kwargs)
+        delta = timeit.default_timer() - starttime
+        return delta
+
+    wrapper.__name__ = func.__name__
+
+    return wrapper
+
+
+def generate_examples(features: dict, num_examples=100, seq_shapes=None):
+    dummy_data = []
+    seq_shapes = seq_shapes or {}
+    for i in range(num_examples):
+        example = {}
+        for col_id, (k, v) in enumerate(features.items()):
+            if isinstance(v, _ArrayXD):
+                data = np.random.rand(*v.shape).astype(v.dtype)
+            elif isinstance(v, datasets.Value):
+                if v.dtype == "string":
+                    data = "The small grey turtle was surprisingly fast when challenged."
+                else:
+                    data = np.random.randint(10, size=1).astype(v.dtype).item()
+            elif isinstance(v, datasets.Sequence):
+                while isinstance(v, datasets.Sequence):
+                    v = v.feature
+                shape = seq_shapes[k]
+                data = np.random.rand(*shape).astype(v.dtype)
+            example[k] = data
+
+        dummy_data.append((i, example))
+
+    return dummy_data
+
+
+def generate_example_dataset(dataset_path, features, num_examples=100, seq_shapes=None):
+    dummy_data = generate_examples(features, num_examples=num_examples, seq_shapes=seq_shapes)
+
+    with ArrowWriter(features=features, path=dataset_path) as writer:
+        for key, record in dummy_data:
+            example = features.encode_example(record)
+            writer.write(example)
+
+        num_final_examples, num_bytes = writer.finalize()
+
+    if not num_final_examples == num_examples:
+        raise ValueError(
+            f"Error writing the dataset, wrote {num_final_examples} examples but should have written {num_examples}."
+        )
+
+    dataset = datasets.Dataset.from_file(filename=dataset_path, info=datasets.DatasetInfo(features=features))
+
+    return dataset

testbed/huggingface__datasets/dvc.yaml

@@ -0,0 +1,40 @@
+stages:
+  benchmark_array_xd:
+    cmd: python ./benchmarks/benchmark_array_xd.py
+    deps:
+    - ./benchmarks/benchmark_array_xd.py
+    metrics:
+    - ./benchmarks/results/benchmark_array_xd.json:
+        cache: false
+
+  benchmark_indices_mapping:
+    cmd: python ./benchmarks/benchmark_indices_mapping.py
+    deps:
+    - ./benchmarks/benchmark_indices_mapping.py
+    metrics:
+    - ./benchmarks/results/benchmark_indices_mapping.json:
+        cache: false
+
+  benchmark_map_filter:
+    cmd: python ./benchmarks/benchmark_map_filter.py
+    deps:
+    - ./benchmarks/benchmark_map_filter.py
+    metrics:
+    - ./benchmarks/results/benchmark_map_filter.json:
+        cache: false
+
+  benchmark_iterating:
+    cmd: python ./benchmarks/benchmark_iterating.py
+    deps:
+    - ./benchmarks/benchmark_iterating.py
+    metrics:
+    - ./benchmarks/results/benchmark_iterating.json:
+        cache: false
+
+  benchmark_getitem_100B:
+    cmd: python ./benchmarks/benchmark_getitem_100B.py
+    deps:
+    - ./benchmarks/benchmark_getitem_100B.py
+    metrics:
+    - ./benchmarks/results/benchmark_getitem_100B.json:
+        cache: false

testbed/huggingface__datasets/metrics/accuracy/README.md

@@ -0,0 +1,97 @@
+# Metric Card for Accuracy
+
+
+## Metric Description
+
+Accuracy is the proportion of correct predictions among the total number of cases processed. It can be computed with:
+Accuracy = (TP + TN) / (TP + TN + FP + FN)
+ Where:
+TP: True positive
+TN: True negative
+FP: False positive
+FN: False negative
+
+
+## How to Use
+
+At minimum, this metric requires predictions and references as inputs.
+
+```python
+>>> accuracy_metric = datasets.load_metric("accuracy")
+>>> results = accuracy_metric.compute(references=[0, 1], predictions=[0, 1])
+>>> print(results)
+{'accuracy': 1.0}
+```
+
+
+### Inputs
+- **predictions** (`list` of `int`): Predicted labels.
+- **references** (`list` of `int`): Ground truth labels.
+- **normalize** (`boolean`): If set to False, returns the number of correctly classified samples. Otherwise, returns the fraction of correctly classified samples. Defaults to True.
+- **sample_weight** (`list` of `float`): Sample weights Defaults to None.
+
+
+### Output Values
+- **accuracy**(`float` or `int`): Accuracy score. Minimum possible value is 0. Maximum possible value is 1.0, or the number of examples input, if `normalize` is set to `True`.. A higher score means higher accuracy.
+
+Output Example(s):
+```python
+{'accuracy': 1.0}
+```
+
+This metric outputs a dictionary, containing the accuracy score.
+
+
+#### Values from Popular Papers
+
+Top-1 or top-5 accuracy is often used to report performance on supervised classification tasks such as image classification (e.g. on [ImageNet](https://paperswithcode.com/sota/image-classification-on-imagenet)) or sentiment analysis (e.g. on [IMDB](https://paperswithcode.com/sota/text-classification-on-imdb)). 
+
+
+### Examples
+
+Example 1-A simple example
+```python
+>>> accuracy_metric = datasets.load_metric("accuracy")
+>>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])
+>>> print(results)
+{'accuracy': 0.5}
+```
+
+Example 2-The same as Example 1, except with `normalize` set to `False`.
+```python
+>>> accuracy_metric = datasets.load_metric("accuracy")
+>>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], normalize=False)
+>>> print(results)
+{'accuracy': 3.0}
+```
+
+Example 3-The same as Example 1, except with `sample_weight` set.
+```python
+>>> accuracy_metric = datasets.load_metric("accuracy")
+>>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], sample_weight=[0.5, 2, 0.7, 0.5, 9, 0.4])
+>>> print(results)
+{'accuracy': 0.8778625954198473}
+```
+
+
+## Limitations and Bias
+This metric can be easily misleading, especially in the case of unbalanced classes. For example, a high accuracy might be because a model is doing well, but if the data is unbalanced, it might also be because the model is only accurately labeling the high-frequency class. In such cases, a more detailed analysis of the model's behavior, or the use of a different metric entirely, is necessary to determine how well the model is actually performing.
+
+
+## Citation(s)
+```bibtex
+@article{scikit-learn,
+  title={Scikit-learn: Machine Learning in {P}ython},
+  author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
+         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
+         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
+         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
+  journal={Journal of Machine Learning Research},
+  volume={12},
+  pages={2825--2830},
+  year={2011}
+}
+```
+
+
+## Further References

testbed/huggingface__datasets/metrics/bertscore/README.md

@@ -0,0 +1,111 @@
+# Metric Card for BERT Score
+
+## Metric description
+
+BERTScore is an automatic evaluation metric for text generation that computes a similarity score for each token in the candidate sentence with each token in the reference sentence. It leverages the pre-trained contextual embeddings from [BERT](https://huggingface.co/bert-base-uncased) models and matches words in candidate and reference sentences by cosine similarity. 
+
+Moreover, BERTScore computes precision, recall, and F1 measure, which can be useful for evaluating different language generation tasks. 
+
+## How to use 
+
+BERTScore takes 3 mandatory arguments : `predictions` (a list of string of candidate sentences), `references` (a list of strings or list of list of strings of reference sentences) and either `lang` (a string of two letters indicating the language of the sentences, in [ISO 639-1 format](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)) or `model_type` (a string specififying which model to use, according to the BERT specification). The default behavior of the metric is to use the suggested model for the target language when one is specified, otherwise to use the `model_type` indicated.
+
+```python
+from datasets import load_metric
+bertscore = load_metric("bertscore")
+predictions = ["hello there", "general kenobi"]
+references = ["hello there", "general kenobi"]
+results = bertscore.compute(predictions=predictions, references=references, lang="en")
+```
+
+BERTScore also accepts multiple optional arguments: 
+
+
+`num_layers` (int): The layer of representation to use. The default is the number of layers tuned on WMT16 correlation data, which depends on the `model_type` used.
+
+`verbose` (bool): Turn on intermediate status update. The default value is `False`. 
+
+`idf` (bool or dict): Use idf weighting; can also be a precomputed idf_dict. 
+
+`device` (str): On which the contextual embedding model will be allocated on. If this argument is `None`, the model lives on `cuda:0` if cuda is available.
+
+`nthreads` (int): Number of threads used for computation. The default value is `4`. 
+
+`rescale_with_baseline` (bool): Rescale BERTScore with the  pre-computed baseline. The default value is `False`. 
+
+`batch_size` (int): BERTScore processing batch size, at least one of `model_type` or `lang`. `lang` needs to be specified when `rescale_with_baseline` is `True`.
+
+`baseline_path` (str): Customized baseline file.
+
+`use_fast_tokenizer` (bool): `use_fast` parameter passed to HF tokenizer. The default value is `False`. 
+
+
+## Output values
+
+BERTScore outputs a dictionary with the following values:
+
+`precision`: The [precision](https://huggingface.co/metrics/precision) for each sentence from the `predictions` + `references` lists, which ranges from 0.0 to 1.0. 
+
+`recall`: The [recall](https://huggingface.co/metrics/recall) for each sentence from the `predictions` + `references` lists, which ranges from 0.0 to 1.0.
+
+`f1`: The [F1 score](https://huggingface.co/metrics/f1) for each sentence from the `predictions` + `references` lists, which ranges from 0.0 to 1.0.
+ 
+`hashcode:` The hashcode of the library.
+
+
+### Values from popular papers
+The [original BERTScore paper](https://openreview.net/pdf?id=SkeHuCVFDr) reported average model selection accuracies (Hits@1) on WMT18 hybrid systems for different language pairs, which ranged from 0.004 for `en<->tr` to 0.824 for `en<->de`.
+
+For more recent model performance, see the [metric leaderboard](https://paperswithcode.com/paper/bertscore-evaluating-text-generation-with).
+
+## Examples 
+
+Maximal values with the `distilbert-base-uncased` model:
+
+```python
+from datasets import load_metric
+bertscore = load_metric("bertscore")
+predictions = ["hello world", "general kenobi"]
+references = ["hello world", "general kenobi"]
+results = bertscore.compute(predictions=predictions, references=references, model_type="distilbert-base-uncased")
+print(results)
+{'precision': [1.0, 1.0], 'recall': [1.0, 1.0], 'f1': [1.0, 1.0], 'hashcode': 'distilbert-base-uncased_L5_no-idf_version=0.3.10(hug_trans=4.10.3)'}
+```
+
+Partial match with the `bert-base-uncased` model:
+
+```python
+from datasets import load_metric
+bertscore = load_metric("bertscore")
+predictions = ["hello world", "general kenobi"]
+references = ["goodnight moon", "the sun is shining"]
+results = bertscore.compute(predictions=predictions, references=references, model_type="distilbert-base-uncased")
+print(results)
+{'precision': [0.7380737066268921, 0.5584042072296143], 'recall': [0.7380737066268921, 0.5889028906822205], 'f1': [0.7380737066268921, 0.5732481479644775], 'hashcode': 'bert-base-uncased_L5_no-idf_version=0.3.10(hug_trans=4.10.3)'}
+```
+
+## Limitations and bias
+
+The [original BERTScore paper](https://openreview.net/pdf?id=SkeHuCVFDr) showed that BERTScore correlates well with human judgment on sentence-level and system-level evaluation, but this depends on the model and language pair selected.
+
+Furthermore, not all languages are supported by the metric -- see the [BERTScore supported language list](https://github.com/google-research/bert/blob/master/multilingual.md#list-of-languages) for more information.
+
+Finally, calculating the BERTScore metric involves downloading the BERT model that is used to compute the score-- the default model for `en`, `roberta-large`, takes over 1.4GB of storage space and downloading it can take a significant amount of time depending on the speed of your internet connection. If this is an issue, choose a smaller model; for instance `distilbert-base-uncased` is 268MB. A full list of compatible models can be found [here](https://docs.google.com/spreadsheets/d/1RKOVpselB98Nnh_EOC4A2BYn8_201tmPODpNWu4w7xI/edit#gid=0).  
+
+
+## Citation
+
+```bibtex
+@inproceedings{bert-score,
+  title={BERTScore: Evaluating Text Generation with BERT},
+  author={Tianyi Zhang* and Varsha Kishore* and Felix Wu* and Kilian Q. Weinberger and Yoav Artzi},
+  booktitle={International Conference on Learning Representations},
+  year={2020},
+  url={https://openreview.net/forum?id=SkeHuCVFDr}
+}
+```
+    
+## Further References 
+
+- [BERTScore Project README](https://github.com/Tiiiger/bert_score#readme)
+- [BERTScore ICLR 2020 Poster Presentation](https://iclr.cc/virtual_2020/poster_SkeHuCVFDr.html)

testbed/huggingface__datasets/metrics/bleurt/bleurt.py

@@ -0,0 +1,122 @@
+# Copyright 2020 The HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" BLEURT metric. """
+
+import os
+
+from bleurt import score  # From: git+https://github.com/google-research/bleurt.git
+
+import datasets
+
+
+logger = datasets.logging.get_logger(__name__)
+
+
+_CITATION = """\
+@inproceedings{bleurt,
+  title={BLEURT: Learning Robust Metrics for Text Generation},
+  author={Thibault Sellam and Dipanjan Das and Ankur P. Parikh},
+  booktitle={ACL},
+  year={2020},
+  url={https://arxiv.org/abs/2004.04696}
+}
+"""
+
+_DESCRIPTION = """\
+BLEURT a learnt evaluation metric for Natural Language Generation. It is built using multiple phases of transfer learning starting from a pretrained BERT model (Devlin et al. 2018)
+and then employing another pre-training phrase using synthetic data. Finally it is trained on WMT human annotations. You may run BLEURT out-of-the-box or fine-tune
+it for your specific application (the latter is expected to perform better).
+
+See the project's README at https://github.com/google-research/bleurt#readme for more information.
+"""
+
+_KWARGS_DESCRIPTION = """
+BLEURT score.
+
+Args:
+    `predictions` (list of str): prediction/candidate sentences
+    `references` (list of str): reference sentences
+    `checkpoint` BLEURT checkpoint. Will default to BLEURT-tiny if None.
+
+Returns:
+    'scores': List of scores.
+Examples:
+
+    >>> predictions = ["hello there", "general kenobi"]
+    >>> references = ["hello there", "general kenobi"]
+    >>> bleurt = datasets.load_metric("bleurt")
+    >>> results = bleurt.compute(predictions=predictions, references=references)
+    >>> print([round(v, 2) for v in results["scores"]])
+    [1.03, 1.04]
+"""
+
+CHECKPOINT_URLS = {
+    "bleurt-tiny-128": "https://storage.googleapis.com/bleurt-oss/bleurt-tiny-128.zip",
+    "bleurt-tiny-512": "https://storage.googleapis.com/bleurt-oss/bleurt-tiny-512.zip",
+    "bleurt-base-128": "https://storage.googleapis.com/bleurt-oss/bleurt-base-128.zip",
+    "bleurt-base-512": "https://storage.googleapis.com/bleurt-oss/bleurt-base-512.zip",
+    "bleurt-large-128": "https://storage.googleapis.com/bleurt-oss/bleurt-large-128.zip",
+    "bleurt-large-512": "https://storage.googleapis.com/bleurt-oss/bleurt-large-512.zip",
+    "BLEURT-20-D3": "https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D3.zip",
+    "BLEURT-20-D6": "https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D6.zip",
+    "BLEURT-20-D12": "https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D12.zip",
+    "BLEURT-20": "https://storage.googleapis.com/bleurt-oss-21/BLEURT-20.zip",
+}
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class BLEURT(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            homepage="https://github.com/google-research/bleurt",
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Value("string", id="sequence"),
+                    "references": datasets.Value("string", id="sequence"),
+                }
+            ),
+            codebase_urls=["https://github.com/google-research/bleurt"],
+            reference_urls=["https://github.com/google-research/bleurt", "https://arxiv.org/abs/2004.04696"],
+        )
+
+    def _download_and_prepare(self, dl_manager):
+        # check that config name specifies a valid BLEURT model
+        if self.config_name == "default":
+            logger.warning(
+                "Using default BLEURT-Base checkpoint for sequence maximum length 128. "
+                "You can use a bigger model for better results with e.g.: datasets.load_metric('bleurt', 'bleurt-large-512')."
+            )
+            self.config_name = "bleurt-base-128"
+
+        if self.config_name.lower() in CHECKPOINT_URLS:
+            checkpoint_name = self.config_name.lower()
+
+        elif self.config_name.upper() in CHECKPOINT_URLS:
+            checkpoint_name = self.config_name.upper()
+
+        else:
+            raise KeyError(
+                f"{self.config_name} model not found. You should supply the name of a model checkpoint for bleurt in {CHECKPOINT_URLS.keys()}"
+            )
+
+        # download the model checkpoint specified by self.config_name and set up the scorer
+        model_path = dl_manager.download_and_extract(CHECKPOINT_URLS[checkpoint_name])
+        self.scorer = score.BleurtScorer(os.path.join(model_path, checkpoint_name))
+
+    def _compute(self, predictions, references):
+        scores = self.scorer.score(references=references, candidates=predictions)
+        return {"scores": scores}

testbed/huggingface__datasets/metrics/cer/cer.py

@@ -0,0 +1,158 @@
+# Copyright 2021 The HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" Character Error Ratio (CER) metric. """
+
+from typing import List
+
+import jiwer
+import jiwer.transforms as tr
+from packaging import version
+
+import datasets
+from datasets.config import PY_VERSION
+
+
+if PY_VERSION < version.parse("3.8"):
+    import importlib_metadata
+else:
+    import importlib.metadata as importlib_metadata
+
+
+SENTENCE_DELIMITER = ""
+
+
+if version.parse(importlib_metadata.version("jiwer")) < version.parse("2.3.0"):
+
+    class SentencesToListOfCharacters(tr.AbstractTransform):
+        def __init__(self, sentence_delimiter: str = " "):
+            self.sentence_delimiter = sentence_delimiter
+
+        def process_string(self, s: str):
+            return list(s)
+
+        def process_list(self, inp: List[str]):
+            chars = []
+            for sent_idx, sentence in enumerate(inp):
+                chars.extend(self.process_string(sentence))
+                if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(inp) - 1:
+                    chars.append(self.sentence_delimiter)
+            return chars
+
+    cer_transform = tr.Compose(
+        [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
+    )
+else:
+    cer_transform = tr.Compose(
+        [
+            tr.RemoveMultipleSpaces(),
+            tr.Strip(),
+            tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
+            tr.ReduceToListOfListOfChars(),
+        ]
+    )
+
+
+_CITATION = """\
+@inproceedings{inproceedings,
+    author = {Morris, Andrew and Maier, Viktoria and Green, Phil},
+    year = {2004},
+    month = {01},
+    pages = {},
+    title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}
+}
+"""
+
+_DESCRIPTION = """\
+Character error rate (CER) is a common metric of the performance of an automatic speech recognition system.
+
+CER is similar to Word Error Rate (WER), but operates on character instead of word. Please refer to docs of WER for further information.
+
+Character error rate can be computed as:
+
+CER = (S + D + I) / N = (S + D + I) / (S + D + C)
+
+where
+
+S is the number of substitutions,
+D is the number of deletions,
+I is the number of insertions,
+C is the number of correct characters,
+N is the number of characters in the reference (N=S+D+C).
+
+CER's output is not always a number between 0 and 1, in particular when there is a high number of insertions. This value is often associated to the percentage of characters that were incorrectly predicted. The lower the value, the better the
+performance of the ASR system with a CER of 0 being a perfect score.
+"""
+
+_KWARGS_DESCRIPTION = """
+Computes CER score of transcribed segments against references.
+Args:
+    references: list of references for each speech input.
+    predictions: list of transcribtions to score.
+    concatenate_texts: Whether or not to concatenate sentences before evaluation, set to True for more accurate result.
+Returns:
+    (float): the character error rate
+
+Examples:
+
+    >>> predictions = ["this is the prediction", "there is an other sample"]
+    >>> references = ["this is the reference", "there is another one"]
+    >>> cer = datasets.load_metric("cer")
+    >>> cer_score = cer.compute(predictions=predictions, references=references)
+    >>> print(cer_score)
+    0.34146341463414637
+"""
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class CER(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Value("string", id="sequence"),
+                    "references": datasets.Value("string", id="sequence"),
+                }
+            ),
+            codebase_urls=["https://github.com/jitsi/jiwer/"],
+            reference_urls=[
+                "https://en.wikipedia.org/wiki/Word_error_rate",
+                "https://sites.google.com/site/textdigitisation/qualitymeasures/computingerrorrates",
+            ],
+        )
+
+    def _compute(self, predictions, references, concatenate_texts=False):
+        if concatenate_texts:
+            return jiwer.compute_measures(
+                references,
+                predictions,
+                truth_transform=cer_transform,
+                hypothesis_transform=cer_transform,
+            )["wer"]
+
+        incorrect = 0
+        total = 0
+        for prediction, reference in zip(predictions, references):
+            measures = jiwer.compute_measures(
+                reference,
+                prediction,
+                truth_transform=cer_transform,
+                hypothesis_transform=cer_transform,
+            )
+            incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
+            total += measures["substitutions"] + measures["deletions"] + measures["hits"]
+
+        return incorrect / total

testbed/huggingface__datasets/metrics/cer/test_cer.py

@@ -0,0 +1,128 @@
+# Copyright 2021 The HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import unittest
+
+from cer import CER
+
+
+cer = CER()
+
+
+class TestCER(unittest.TestCase):
+    def test_cer_case_senstive(self):
+        refs = ["White House"]
+        preds = ["white house"]
+        # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.1818181818) < 1e-6)
+
+    def test_cer_whitespace(self):
+        refs = ["were wolf"]
+        preds = ["werewolf"]
+        # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.1111111) < 1e-6)
+
+        refs = ["werewolf"]
+        preds = ["weae     wolf"]
+        # S = 1, D = 1, I = 0, N = 8, CER = 0.25
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.25) < 1e-6)
+
+        # consecutive whitespaces case 1
+        refs = ["were wolf"]
+        preds = ["were               wolf"]
+        # S = 0, D = 0, I = 0, N = 9, CER = 0
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.0) < 1e-6)
+
+        # consecutive whitespaces case 2
+        refs = ["were   wolf"]
+        preds = ["were               wolf"]
+        # S = 0, D = 0, I = 0, N = 9, CER = 0
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.0) < 1e-6)
+
+    def test_cer_sub(self):
+        refs = ["werewolf"]
+        preds = ["weaewolf"]
+        # S = 1, D = 0, I = 0, N = 8, CER = 0.125
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.125) < 1e-6)
+
+    def test_cer_del(self):
+        refs = ["werewolf"]
+        preds = ["wereawolf"]
+        # S = 0, D = 1, I = 0, N = 8, CER = 0.125
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.125) < 1e-6)
+
+    def test_cer_insert(self):
+        refs = ["werewolf"]
+        preds = ["wereolf"]
+        # S = 0, D = 0, I = 1, N = 8, CER = 0.125
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.125) < 1e-6)
+
+    def test_cer_equal(self):
+        refs = ["werewolf"]
+        char_error_rate = cer.compute(predictions=refs, references=refs)
+        self.assertEqual(char_error_rate, 0.0)
+
+    def test_cer_list_of_seqs(self):
+        refs = ["werewolf", "I am your father"]
+        char_error_rate = cer.compute(predictions=refs, references=refs)
+        self.assertEqual(char_error_rate, 0.0)
+
+        refs = ["werewolf", "I am your father", "doge"]
+        preds = ["werxwolf", "I       am your father", "doge"]
+        # S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.03571428) < 1e-6)
+
+    def test_correlated_sentences(self):
+        refs = ["My hovercraft", "is full of eels"]
+        preds = ["My hovercraft is full", " of eels"]
+        # S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
+        # whitespace at the front of " of eels" will be strip during preporcessing
+        # so need to insert 2 whitespaces
+        char_error_rate = cer.compute(predictions=preds, references=refs, concatenate_texts=True)
+        self.assertTrue(abs(char_error_rate - 0.071428) < 1e-6)
+
+    def test_cer_unicode(self):
+        refs = ["我能吞下玻璃而不伤身体"]
+        preds = [" 能吞虾玻璃而 不霜身体啦"]
+        # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.4545454545) < 1e-6)
+
+        refs = ["我能吞下玻璃", "而不伤身体"]
+        preds = ["我    能 吞 下 玻 璃", "而不伤身体"]
+        # S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
+        char_error_rate = cer.compute(predictions=preds, references=refs)
+        self.assertTrue(abs(char_error_rate - 0.454545454545) < 1e-6)
+
+        refs = ["我能吞下玻璃而不伤身体"]
+        char_error_rate = cer.compute(predictions=refs, references=refs)
+        self.assertFalse(char_error_rate, 0.0)
+
+    def test_cer_empty(self):
+        refs = [""]
+        preds = ["Hypothesis"]
+        with self.assertRaises(ValueError):
+            cer.compute(predictions=preds, references=refs)
+
+
+if __name__ == "__main__":
+    unittest.main()

testbed/huggingface__datasets/metrics/chrf/README.md

@@ -0,0 +1,133 @@
+# Metric Card for chrF(++)
+
+
+## Metric Description
+ChrF and ChrF++ are two MT evaluation metrics that use the F-score statistic for character n-gram matches. ChrF++ additionally includes word n-grams, which correlate more strongly with direct assessment. We use the implementation that is already present in sacrebleu.
+
+While this metric is included in sacreBLEU, the implementation here is slightly different from sacreBLEU in terms of the required input format. Here, the length of the references and hypotheses lists need to be the same, so you may need to transpose your references compared to sacrebleu's required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534
+
+See the [sacreBLEU README.md](https://github.com/mjpost/sacreBLEU#chrf--chrf) for more information.
+
+
+## How to Use
+At minimum, this metric requires a `list` of predictions and a `list` of `list`s of references:
+```python
+>>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
+>>> reference = [["The relationship between dogs and cats is not exactly friendly.", ], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
+>>> chrf = datasets.load_metric("chrf")
+>>> results = chrf.compute(predictions=prediction, references=reference)
+>>> print(results)
+{'score': 84.64214891738334, 'char_order': 6, 'word_order': 0, 'beta': 2}
+```
+
+### Inputs
+- **`predictions`** (`list` of `str`): The predicted sentences.
+- **`references`** (`list` of `list` of `str`): The references. There should be one reference sub-list for each prediction sentence.
+- **`char_order`** (`int`): Character n-gram order. Defaults to `6`. 
+- **`word_order`** (`int`): Word n-gram order. If equals to 2, the metric is referred to as chrF++. Defaults to `0`.
+- **`beta`** (`int`): Determine the importance of recall w.r.t precision. Defaults to `2`.
+- **`lowercase`** (`bool`): If `True`, enables case-insensitivity. Defaults to `False`.
+- **`whitespace`** (`bool`): If `True`, include whitespaces when extracting character n-grams. Defaults to `False`.
+- **`eps_smoothing`** (`bool`): If `True`, applies epsilon smoothing similar to reference chrF++.py, NLTK, and Moses implementations. If `False`, takes into account effective match order similar to sacreBLEU < 2.0.0. Defaults to `False`.
+
+
+
+### Output Values
+The output is a dictionary containing the following fields:
+- **`'score'`** (`float`): The chrF (chrF++) score.
+- **`'char_order'`** (`int`): The character n-gram order.
+- **`'word_order'`** (`int`): The word n-gram order. If equals to `2`, the metric is referred to as chrF++.
+- **`'beta'`** (`int`): Determine the importance of recall w.r.t precision.
+
+
+The output is formatted as below:
+```python
+{'score': 61.576379378113785, 'char_order': 6, 'word_order': 0, 'beta': 2}
+```
+
+The chrF(++) score can be any value between `0.0` and `100.0`, inclusive.
+
+#### Values from Popular Papers
+
+
+### Examples
+A simple example of calculating chrF:
+```python
+>>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
+>>> reference = [["The relationship between dogs and cats is not exactly friendly.", ], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
+>>> chrf = datasets.load_metric("chrf")
+>>> results = chrf.compute(predictions=prediction, references=reference)
+>>> print(results)
+{'score': 84.64214891738334, 'char_order': 6, 'word_order': 0, 'beta': 2}
+```
+
+The same example, but with the argument `word_order=2`, to calculate chrF++ instead of chrF:
+```python
+>>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
+>>> reference = [["The relationship between dogs and cats is not exactly friendly.", ], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
+>>> chrf = datasets.load_metric("chrf")
+>>> results = chrf.compute(predictions=prediction,
+...                         references=reference,
+...                         word_order=2)
+>>> print(results)
+{'score': 82.87263732906315, 'char_order': 6, 'word_order': 2, 'beta': 2}
+```
+
+The same chrF++ example as above, but with `lowercase=True` to normalize all case:
+```python
+>>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
+>>> reference = [["The relationship between dogs and cats is not exactly friendly.", ], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
+>>> chrf = datasets.load_metric("chrf")
+>>> results = chrf.compute(predictions=prediction,
+...                         references=reference,
+...                         word_order=2,
+...                         lowercase=True)
+>>> print(results)
+{'score': 92.12853119829202, 'char_order': 6, 'word_order': 2, 'beta': 2}
+```
+
+
+## Limitations and Bias
+- According to [Popović 2017](https://www.statmt.org/wmt17/pdf/WMT70.pdf), chrF+ (where `word_order=1`) and chrF++ (where `word_order=2`) produce scores that correlate better with human judgements than chrF (where `word_order=0`) does. 
+
+## Citation
+```bibtex
+@inproceedings{popovic-2015-chrf,
+    title = "chr{F}: character n-gram {F}-score for automatic {MT} evaluation",
+    author = "Popovi{\'c}, Maja",
+    booktitle = "Proceedings of the Tenth Workshop on Statistical Machine Translation",
+    month = sep,
+    year = "2015",
+    address = "Lisbon, Portugal",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/W15-3049",
+    doi = "10.18653/v1/W15-3049",
+    pages = "392--395",
+}
+@inproceedings{popovic-2017-chrf,
+    title = "chr{F}++: words helping character n-grams",
+    author = "Popovi{\'c}, Maja",
+    booktitle = "Proceedings of the Second Conference on Machine Translation",
+    month = sep,
+    year = "2017",
+    address = "Copenhagen, Denmark",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/W17-4770",
+    doi = "10.18653/v1/W17-4770",
+    pages = "612--618",
+}
+@inproceedings{post-2018-call,
+    title = "A Call for Clarity in Reporting {BLEU} Scores",
+    author = "Post, Matt",
+    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",
+    month = oct,
+    year = "2018",
+    address = "Belgium, Brussels",
+    publisher = "Association for Computational Linguistics",
+    url = "https://www.aclweb.org/anthology/W18-6319",
+    pages = "186--191",
+}
+```
+
+## Further References
+- See the [sacreBLEU README.md](https://github.com/mjpost/sacreBLEU#chrf--chrf) for more information on this implementation.

testbed/huggingface__datasets/metrics/chrf/chrf.py

@@ -0,0 +1,174 @@
+# Copyright 2021 The HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" Chrf(++) metric as available in sacrebleu. """
+import sacrebleu as scb
+from packaging import version
+from sacrebleu import CHRF
+
+import datasets
+
+
+_CITATION = """\
+@inproceedings{popovic-2015-chrf,
+    title = "chr{F}: character n-gram {F}-score for automatic {MT} evaluation",
+    author = "Popovi{\'c}, Maja",
+    booktitle = "Proceedings of the Tenth Workshop on Statistical Machine Translation",
+    month = sep,
+    year = "2015",
+    address = "Lisbon, Portugal",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/W15-3049",
+    doi = "10.18653/v1/W15-3049",
+    pages = "392--395",
+}
+@inproceedings{popovic-2017-chrf,
+    title = "chr{F}++: words helping character n-grams",
+    author = "Popovi{\'c}, Maja",
+    booktitle = "Proceedings of the Second Conference on Machine Translation",
+    month = sep,
+    year = "2017",
+    address = "Copenhagen, Denmark",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/W17-4770",
+    doi = "10.18653/v1/W17-4770",
+    pages = "612--618",
+}
+@inproceedings{post-2018-call,
+    title = "A Call for Clarity in Reporting {BLEU} Scores",
+    author = "Post, Matt",
+    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",
+    month = oct,
+    year = "2018",
+    address = "Belgium, Brussels",
+    publisher = "Association for Computational Linguistics",
+    url = "https://www.aclweb.org/anthology/W18-6319",
+    pages = "186--191",
+}
+"""
+
+_DESCRIPTION = """\
+ChrF and ChrF++ are two MT evaluation metrics. They both use the F-score statistic for character n-gram matches,
+and ChrF++ adds word n-grams as well which correlates more strongly with direct assessment. We use the implementation
+that is already present in sacrebleu.
+
+The implementation here is slightly different from sacrebleu in terms of the required input format. The length of
+the references and hypotheses lists need to be the same, so you may need to transpose your references compared to
+sacrebleu's required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534
+
+See the README.md file at https://github.com/mjpost/sacreBLEU#chrf--chrf for more information.
+"""
+
+_KWARGS_DESCRIPTION = """
+Produces ChrF(++) scores for hypotheses given reference translations.
+
+Args:
+    predictions (list of str): The predicted sentences.
+    references (list of list of str): The references. There should be one reference sub-list for each prediction sentence.
+    char_order (int): Character n-gram order. Defaults to `6`.
+    word_order (int): Word n-gram order. If equals to `2`, the metric is referred to as chrF++. Defaults to `0`.
+    beta (int): Determine the importance of recall w.r.t precision. Defaults to `2`.
+    lowercase (bool): if `True`, enables case-insensitivity. Defaults to `False`.
+    whitespace (bool): If `True`, include whitespaces when extracting character n-grams.
+    eps_smoothing (bool): If `True`, applies epsilon smoothing similar
+    to reference chrF++.py, NLTK and Moses implementations. If `False`,
+    it takes into account effective match order similar to sacreBLEU < 2.0.0. Defaults to `False`.
+
+Returns:
+    'score' (float): The chrF (chrF++) score,
+    'char_order' (int): The character n-gram order,
+    'word_order' (int): The word n-gram order. If equals to 2, the metric is referred to as chrF++,
+    'beta' (int): Determine the importance of recall w.r.t precision
+
+Examples:
+    Example 1--a simple example of calculating chrF:
+        >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
+        >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
+        >>> chrf = datasets.load_metric("chrf")
+        >>> results = chrf.compute(predictions=prediction, references=reference)
+        >>> print(results)
+        {'score': 84.64214891738334, 'char_order': 6, 'word_order': 0, 'beta': 2}
+
+    Example 2--the same example, but with the argument word_order=2, to calculate chrF++ instead of chrF:
+        >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
+        >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
+        >>> chrf = datasets.load_metric("chrf")
+        >>> results = chrf.compute(predictions=prediction,
+        ...                         references=reference,
+        ...                         word_order=2)
+        >>> print(results)
+        {'score': 82.87263732906315, 'char_order': 6, 'word_order': 2, 'beta': 2}
+
+    Example 3--the same chrF++ example as above, but with `lowercase=True` to normalize all case:
+        >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]
+        >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]
+        >>> chrf = datasets.load_metric("chrf")
+        >>> results = chrf.compute(predictions=prediction,
+        ...                         references=reference,
+        ...                         word_order=2,
+        ...                         lowercase=True)
+        >>> print(results)
+        {'score': 92.12853119829202, 'char_order': 6, 'word_order': 2, 'beta': 2}
+"""
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class ChrF(datasets.Metric):
+    def _info(self):
+        if version.parse(scb.__version__) < version.parse("1.4.12"):
+            raise ImportWarning(
+                "To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn't match this condition.\n"
+                'You can install it with `pip install "sacrebleu>=1.4.12"`.'
+            )
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            homepage="https://github.com/mjpost/sacreBLEU#chrf--chrf",
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Value("string", id="sequence"),
+                    "references": datasets.Sequence(datasets.Value("string", id="sequence"), id="references"),
+                }
+            ),
+            codebase_urls=["https://github.com/mjpost/sacreBLEU#chrf--chrf"],
+            reference_urls=[
+                "https://github.com/m-popovic/chrF",
+            ],
+        )
+
+    def _compute(
+        self,
+        predictions,
+        references,
+        char_order: int = CHRF.CHAR_ORDER,
+        word_order: int = CHRF.WORD_ORDER,
+        beta: int = CHRF.BETA,
+        lowercase: bool = False,
+        whitespace: bool = False,
+        eps_smoothing: bool = False,
+    ):
+        references_per_prediction = len(references[0])
+        if any(len(refs) != references_per_prediction for refs in references):
+            raise ValueError("Sacrebleu requires the same number of references for each prediction")
+        transformed_references = [[refs[i] for refs in references] for i in range(references_per_prediction)]
+
+        sb_chrf = CHRF(char_order, word_order, beta, lowercase, whitespace, eps_smoothing)
+        output = sb_chrf.corpus_score(predictions, transformed_references)
+
+        return {
+            "score": output.score,
+            "char_order": output.char_order,
+            "word_order": output.word_order,
+            "beta": output.beta,
+        }

testbed/huggingface__datasets/metrics/code_eval/README.md

@@ -0,0 +1,128 @@
+# Metric Card for Code Eval
+
+## Metric description
+
+The CodeEval metric estimates the pass@k metric for code synthesis. 
+
+It implements the evaluation harness for the HumanEval problem solving dataset described in the paper ["Evaluating Large Language Models Trained on Code"](https://arxiv.org/abs/2107.03374).
+
+
+## How to use 
+
+The Code Eval metric calculates how good are predictions given a set of references. Its arguments are:
+
+`predictions`: a list of candidates to evaluate. Each candidate should be a list of strings with several code candidates to solve the problem.
+
+`references`: a list with a test for each prediction. Each test should evaluate the correctness of a code candidate.
+
+`k`: number of code candidates to consider in the evaluation. The default value is `[1, 10, 100]`.
+
+`num_workers`: the number of workers used to evaluate the candidate programs (The default value is `4`).
+
+`timeout`: The maximum time taken to produce a prediction before it is considered a "timeout". The default value is `3.0` (i.e. 3 seconds).
+
+```python
+from datasets import load_metric
+code_eval = load_metric("code_eval")
+test_cases = ["assert add(2,3)==5"]
+candidates = [["def add(a,b): return a*b", "def add(a, b): return a+b"]]
+pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2])
+```
+
+N.B.
+This metric exists to run untrusted model-generated code. Users are strongly encouraged not to do so outside of a robust security sandbox. Before running this metric and once you've taken the necessary precautions, you will need to set the `HF_ALLOW_CODE_EVAL` environment variable. Use it at your own risk:
+```python
+import os
+os.environ["HF_ALLOW_CODE_EVAL"] = "1"` 
+```
+
+## Output values
+
+The Code Eval metric outputs two things:
+
+`pass_at_k`: a dictionary with the pass rates for each k value defined in the arguments.
+
+`results`: a dictionary with granular results of each unit test.
+
+### Values from popular papers
+The [original CODEX paper](https://arxiv.org/pdf/2107.03374.pdf) reported that the CODEX-12B model had a pass@k score of 28.8% at `k=1`, 46.8% at `k=10` and 72.3% at `k=100`. However, since the CODEX model is not open source, it is hard to verify these numbers. 
+
+
+
+## Examples 
+
+Full match at `k=1`:
+
+```python
+from datasets import load_metric
+code_eval = load_metric("code_eval")
+test_cases = ["assert add(2,3)==5"]
+candidates = [["def add(a, b): return a+b"]]
+pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1])
+print(pass_at_k)
+{'pass@1': 1.0}
+```
+
+No match for k = 1:
+
+```python
+from datasets import load_metric
+code_eval = load_metric("code_eval")
+test_cases = ["assert add(2,3)==5"]
+candidates = [["def add(a,b): return a*b"]]
+pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1])
+print(pass_at_k)
+{'pass@1': 0.0}
+```
+
+Partial match at k=1, full match at k=2:
+
+```python
+from datasets import load_metric
+code_eval = load_metric("code_eval")
+test_cases = ["assert add(2,3)==5"]
+candidates = [["def add(a, b): return a+b", "def add(a,b): return a*b"]]
+pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2])
+print(pass_at_k)
+{'pass@1': 0.5, 'pass@2': 1.0}
+```
+
+## Limitations and bias
+
+As per the warning included in the metric code itself:
+> This program exists to execute untrusted model-generated code. Although it is highly unlikely that model-generated code will do something overtly malicious in response to this test suite, model-generated code may act destructively due to a lack of model capability or alignment. Users are strongly encouraged to sandbox this evaluation suite so that it does not perform destructive actions on their host or network. For more  information on how OpenAI sandboxes its code, see the accompanying paper. Once you have read this disclaimer and taken appropriate precautions, uncomment the following line and proceed at your own risk:
+
+More information about the limitations of the code can be found on the [Human Eval Github repository](https://github.com/openai/human-eval).
+
+## Citation
+
+```bibtex
+@misc{chen2021evaluating,
+      title={Evaluating Large Language Models Trained on Code},
+      author={Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan \
+and Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards \
+and Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray \
+and Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf \
+and Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray \
+and Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser \
+and Mohammad Bavarian and Clemens Winter and Philippe Tillet \
+and Felipe Petroski Such and Dave Cummings and Matthias Plappert \
+and Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss \
+and William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak \
+and Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain \
+and William Saunders and Christopher Hesse and Andrew N. Carr \
+and Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa \
+and Alec Radford and Matthew Knight and Miles Brundage and Mira Murati \
+and Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei \
+and Sam McCandlish and Ilya Sutskever and Wojciech Zaremba},
+      year={2021},
+      eprint={2107.03374},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+```
+    
+## Further References 
+
+- [Human Eval Github repository](https://github.com/openai/human-eval)
+- [OpenAI Codex website](https://openai.com/blog/openai-codex/)

testbed/huggingface__datasets/metrics/code_eval/code_eval.py

@@ -0,0 +1,212 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""The CodeEval metric estimates the pass@k metric for code synthesis.
+This is an evaluation harness for the HumanEval problem solving dataset
+described in the paper "Evaluating Large Language Models Trained on Code"
+(https://arxiv.org/abs/2107.03374)."""
+
+import itertools
+import os
+from collections import Counter, defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import numpy as np
+
+import datasets
+
+from .execute import check_correctness
+
+
+_CITATION = """\
+@misc{chen2021evaluating,
+      title={Evaluating Large Language Models Trained on Code},
+      author={Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan \
+and Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards \
+and Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray \
+and Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf \
+and Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray \
+and Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser \
+and Mohammad Bavarian and Clemens Winter and Philippe Tillet \
+and Felipe Petroski Such and Dave Cummings and Matthias Plappert \
+and Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss \
+and William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak \
+and Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain \
+and William Saunders and Christopher Hesse and Andrew N. Carr \
+and Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa \
+and Alec Radford and Matthew Knight and Miles Brundage and Mira Murati \
+and Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei \
+and Sam McCandlish and Ilya Sutskever and Wojciech Zaremba},
+      year={2021},
+      eprint={2107.03374},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
+"""
+
+_DESCRIPTION = """\
+This metric implements the evaluation harness for the HumanEval problem solving dataset
+described in the paper "Evaluating Large Language Models Trained on Code"
+(https://arxiv.org/abs/2107.03374).
+"""
+
+
+_KWARGS_DESCRIPTION = """
+Calculates how good are predictions given some references, using certain scores
+Args:
+    predictions: list of candidates to evaluate. Each candidates should be a list
+        of strings with several code candidates to solve the problem.
+    references: a list with a test for each prediction. Each test should evaluate the
+        correctness of a code candidate.
+    k: number of code candidates to consider in the evaluation (Default: [1, 10, 100])
+    num_workers: number of workers used to evaluate the canidate programs (Default: 4).
+    timeout:
+Returns:
+    pass_at_k: dict with pass rates for each k
+    results: dict with granular results of each unittest
+Examples:
+    >>> code_eval = datasets.load_metric("code_eval")
+    >>> test_cases = ["assert add(2,3)==5"]
+    >>> candidates = [["def add(a,b): return a*b", "def add(a, b): return a+b"]]
+    >>> pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2])
+    >>> print(pass_at_k)
+    {'pass@1': 0.5, 'pass@2': 1.0}
+"""
+
+
+_WARNING = """
+################################################################################
+                                  !!!WARNING!!!
+################################################################################
+The "code_eval" metric executes untrusted model-generated code in Python.
+Although it is highly unlikely that model-generated code will do something
+overtly malicious in response to this test suite, model-generated code may act
+destructively due to a lack of model capability or alignment.
+Users are strongly encouraged to sandbox this evaluation suite so that it
+does not perform destructive actions on their host or network. For more
+information on how OpenAI sandboxes its code, see the paper "Evaluating Large
+Language Models Trained on Code" (https://arxiv.org/abs/2107.03374).
+
+Once you have read this disclaimer and taken appropriate precautions,
+set the environment variable HF_ALLOW_CODE_EVAL="1". Within Python you can to this
+with:
+
+>>> import os
+>>> os.environ["HF_ALLOW_CODE_EVAL"] = "1"
+
+################################################################################\
+"""
+
+_LICENSE = """The MIT License
+
+Copyright (c) OpenAI (https://openai.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE."""
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class CodeEval(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            # This is the description that will appear on the metrics page.
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            # This defines the format of each prediction and reference
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Sequence(datasets.Value("string")),
+                    "references": datasets.Value("string"),
+                }
+            ),
+            homepage="https://github.com/openai/human-eval",
+            codebase_urls=["https://github.com/openai/human-eval"],
+            reference_urls=["https://github.com/openai/human-eval"],
+            license=_LICENSE,
+        )
+
+    def _compute(self, predictions, references, k=[1, 10, 100], num_workers=4, timeout=3.0):
+        """Returns the scores"""
+
+        if os.getenv("HF_ALLOW_CODE_EVAL", 0) != "1":
+            raise ValueError(_WARNING)
+
+        if os.name == "nt":
+            raise NotImplementedError("This metric is currently not supported on Windows.")
+
+        with ThreadPoolExecutor(max_workers=num_workers) as executor:
+            futures = []
+            completion_id = Counter()
+            n_samples = 0
+            results = defaultdict(list)
+
+            for task_id, (candidates, test_case) in enumerate(zip(predictions, references)):
+                for candidate in candidates:
+                    test_program = candidate + "\n" + test_case
+                    args = (test_program, timeout, task_id, completion_id[task_id])
+                    future = executor.submit(check_correctness, *args)
+                    futures.append(future)
+                    completion_id[task_id] += 1
+                    n_samples += 1
+
+            for future in as_completed(futures):
+                result = future.result()
+                results[result["task_id"]].append((result["completion_id"], result))
+
+        total, correct = [], []
+        for result in results.values():
+            result.sort()
+            passed = [r[1]["passed"] for r in result]
+            total.append(len(passed))
+            correct.append(sum(passed))
+        total = np.array(total)
+        correct = np.array(correct)
+
+        ks = k
+        pass_at_k = {f"pass@{k}": estimate_pass_at_k(total, correct, k).mean() for k in ks if (total >= k).all()}
+
+        return pass_at_k, results
+
+
+def estimate_pass_at_k(num_samples, num_correct, k):
+    """Estimates pass@k of each problem and returns them in an array."""
+
+    def estimator(n: int, c: int, k: int) -> float:
+        """Calculates 1 - comb(n - c, k) / comb(n, k)."""
+        if n - c < k:
+            return 1.0
+        return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))
+
+    if isinstance(num_samples, int):
+        num_samples_it = itertools.repeat(num_samples, len(num_correct))
+    else:
+        assert len(num_samples) == len(num_correct)
+        num_samples_it = iter(num_samples)
+
+    return np.array([estimator(int(n), int(c), k) for n, c in zip(num_samples_it, num_correct)])

testbed/huggingface__datasets/metrics/code_eval/execute.py

@@ -0,0 +1,234 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This code is adapted from OpenAI's release
+# https://github.com/openai/human-eval/blob/master/human_eval/execution.py
+
+import contextlib
+import faulthandler
+import io
+import multiprocessing
+import os
+import platform
+import signal
+import tempfile
+
+
+def check_correctness(check_program, timeout, task_id, completion_id):
+    """
+    Evaluates the functional correctness of a completion by running the test
+    suite provided in the problem.
+
+    :param completion_id: an optional completion ID so we can match
+        the results later even if execution finishes asynchronously.
+    """
+    manager = multiprocessing.Manager()
+    result = manager.list()
+
+    p = multiprocessing.Process(target=unsafe_execute, args=(check_program, result, timeout))
+    p.start()
+    p.join(timeout=timeout + 1)
+    if p.is_alive():
+        p.kill()
+
+    if not result:
+        result.append("timed out")
+
+    return {
+        "task_id": task_id,
+        "passed": result[0] == "passed",
+        "result": result[0],
+        "completion_id": completion_id,
+    }
+
+
+def unsafe_execute(check_program, result, timeout):
+    with create_tempdir():
+        # These system calls are needed when cleaning up tempdir.
+        import os
+        import shutil
+
+        rmtree = shutil.rmtree
+        rmdir = os.rmdir
+        chdir = os.chdir
+
+        # Disable functionalities that can make destructive changes to the test.
+        reliability_guard()
+
+        # Run program.
+        try:
+            exec_globals = {}
+            with swallow_io():
+                with time_limit(timeout):
+                    exec(check_program, exec_globals)
+            result.append("passed")
+        except TimeoutException:
+            result.append("timed out")
+        except BaseException as e:
+            result.append(f"failed: {e}")
+
+        # Needed for cleaning up.
+        shutil.rmtree = rmtree
+        os.rmdir = rmdir
+        os.chdir = chdir
+
+
+@contextlib.contextmanager
+def time_limit(seconds):
+    def signal_handler(signum, frame):
+        raise TimeoutException("Timed out!")
+
+    signal.setitimer(signal.ITIMER_REAL, seconds)
+    signal.signal(signal.SIGALRM, signal_handler)
+    try:
+        yield
+    finally:
+        signal.setitimer(signal.ITIMER_REAL, 0)
+
+
+@contextlib.contextmanager
+def swallow_io():
+    stream = WriteOnlyStringIO()
+    with contextlib.redirect_stdout(stream):
+        with contextlib.redirect_stderr(stream):
+            with redirect_stdin(stream):
+                yield
+
+
+@contextlib.contextmanager
+def create_tempdir():
+    with tempfile.TemporaryDirectory() as dirname:
+        with chdir(dirname):
+            yield dirname
+
+
+class TimeoutException(Exception):
+    pass
+
+
+class WriteOnlyStringIO(io.StringIO):
+    """StringIO that throws an exception when it's read from"""
+
+    def read(self, *args, **kwargs):
+        raise OSError
+
+    def readline(self, *args, **kwargs):
+        raise OSError
+
+    def readlines(self, *args, **kwargs):
+        raise OSError
+
+    def readable(self, *args, **kwargs):
+        """Returns True if the IO object can be read."""
+        return False
+
+
+class redirect_stdin(contextlib._RedirectStream):  # type: ignore
+    _stream = "stdin"
+
+
+@contextlib.contextmanager
+def chdir(root):
+    if root == ".":
+        yield
+        return
+    cwd = os.getcwd()
+    os.chdir(root)
+    try:
+        yield
+    except BaseException as exc:
+        raise exc
+    finally:
+        os.chdir(cwd)
+
+
+def reliability_guard(maximum_memory_bytes=None):
+    """
+    This disables various destructive functions and prevents the generated code
+    from interfering with the test (e.g. fork bomb, killing other processes,
+    removing filesystem files, etc.)
+
+    WARNING
+    This function is NOT a security sandbox. Untrusted code, including, model-
+    generated code, should not be blindly executed outside of one. See the
+    Codex paper for more information about OpenAI's code sandbox, and proceed
+    with caution.
+    """
+
+    if maximum_memory_bytes is not None:
+        import resource
+
+        resource.setrlimit(resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes))
+        resource.setrlimit(resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes))
+        if not platform.uname().system == "Darwin":
+            resource.setrlimit(resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes))
+
+    faulthandler.disable()
+
+    import builtins
+
+    builtins.exit = None
+    builtins.quit = None
+
+    import os
+
+    os.environ["OMP_NUM_THREADS"] = "1"
+
+    os.kill = None
+    os.system = None
+    os.putenv = None
+    os.remove = None
+    os.removedirs = None
+    os.rmdir = None
+    os.fchdir = None
+    os.setuid = None
+    os.fork = None
+    os.forkpty = None
+    os.killpg = None
+    os.rename = None
+    os.renames = None
+    os.truncate = None
+    os.replace = None
+    os.unlink = None
+    os.fchmod = None
+    os.fchown = None
+    os.chmod = None
+    os.chown = None
+    os.chroot = None
+    os.fchdir = None
+    os.lchflags = None
+    os.lchmod = None
+    os.lchown = None
+    os.getcwd = None
+    os.chdir = None
+
+    import shutil
+
+    shutil.rmtree = None
+    shutil.move = None
+    shutil.chown = None
+
+    import subprocess
+
+    subprocess.Popen = None  # type: ignore
+
+    __builtins__["help"] = None
+
+    import sys
+
+    sys.modules["ipdb"] = None
+    sys.modules["joblib"] = None
+    sys.modules["resource"] = None
+    sys.modules["psutil"] = None
+    sys.modules["tkinter"] = None

testbed/huggingface__datasets/metrics/comet/README.md

@@ -0,0 +1,128 @@
+# Metric Card for COMET
+
+## Metric description
+
+Crosslingual Optimized Metric for Evaluation of Translation (COMET) is an open-source framework used to train Machine Translation metrics that achieve high levels of correlation with different types of human judgments.
+
+## How to use
+
+COMET takes 3 lists of strings as input: `sources` (a list of source sentences), `predictions` (a list of candidate translations) and `references` (a list of reference translations).
+
+```python
+from datasets import load_metric
+comet_metric = load_metric('comet')
+source = ["Dem Feuer konnte Einhalt geboten werden", "Schulen und Kindergärten wurden eröffnet."]
+hypothesis = ["The fire could be stopped", "Schools and kindergartens were open"]
+reference = ["They were able to control the fire.", "Schools and kindergartens opened"]
+comet_score = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)
+```
+
+It has several configurations, named after the COMET model to be used. It will default to `wmt20-comet-da` (previously known as `wmt-large-da-estimator-1719`). Alternate models that can be chosen include `wmt20-comet-qe-da`, `wmt21-comet-mqm`, `wmt21-cometinho-da`, `wmt21-comet-qe-mqm` and `emnlp20-comet-rank`.
+
+It also has several optional arguments:
+
+`gpus`: optional, an integer (number of GPUs to train on) or a list of integers (which GPUs to train on). Set to 0 to use CPU. The default value is `None` (uses one GPU if possible, else use CPU).
+
+`progress_bar`a boolean -- if set to `True`, progress updates will be printed out. The default value is `False`.
+
+More information about model characteristics can be found on the [COMET website](https://unbabel.github.io/COMET/html/models.html).
+
+## Output values
+
+The COMET metric outputs two lists:
+
+`scores`: a list of COMET scores for each of the input sentences, ranging from 0-1.
+
+`mean_score`: the mean value of COMET scores `scores` over all the input sentences, ranging from 0-1.
+
+### Values from popular papers
+
+The [original COMET paper](https://arxiv.org/pdf/2009.09025.pdf) reported average COMET scores ranging from 0.4 to 0.6, depending on the language pairs used for evaluating translation models. They also illustrate that COMET correlates well with human judgements compared to other metrics such as [BLEU](https://huggingface.co/metrics/bleu) and [CHRF](https://huggingface.co/metrics/chrf).
+
+## Examples
+
+Full match:
+
+```python
+from datasets import load_metric
+comet_metric = load_metric('comet') 
+source = ["Dem Feuer konnte Einhalt geboten werden", "Schulen und Kindergärten wurden eröffnet."]
+hypothesis = ["They were able to control the fire.", "Schools and kindergartens opened"]
+reference = ["They were able to control the fire.", "Schools and kindergartens opened"]
+results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)
+print([round(v, 1) for v in results["scores"]])
+[1.0, 1.0]
+```
+
+Partial match:
+
+```python
+from datasets import load_metric
+comet_metric = load_metric('comet') 
+source = ["Dem Feuer konnte Einhalt geboten werden", "Schulen und Kindergärten wurden eröffnet."]
+hypothesis = ["The fire could be stopped", "Schools and kindergartens were open"]
+reference = ["They were able to control the fire", "Schools and kindergartens opened"]
+results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)
+print([round(v, 2) for v in results["scores"]])
+[0.19, 0.92]
+```
+
+No match:
+
+```python
+from datasets import load_metric
+comet_metric = load_metric('comet') 
+source = ["Dem Feuer konnte Einhalt geboten werden", "Schulen und Kindergärten wurden eröffnet."]
+hypothesis = ["The girl went for a walk", "The boy was sleeping"]
+reference = ["They were able to control the fire", "Schools and kindergartens opened"]
+results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)
+print([round(v, 2) for v in results["scores"]])
+[0.00, 0.00]
+```
+
+## Limitations and bias
+
+The models provided for calculating the COMET metric are built on top of XLM-R and cover the following languages:
+
+Afrikaans, Albanian, Amharic, Arabic, Armenian, Assamese, Azerbaijani, Basque, Belarusian, Bengali, Bengali Romanized, Bosnian, Breton, Bulgarian, Burmese, Burmese, Catalan, Chinese (Simplified), Chinese (Traditional), Croatian, Czech, Danish, Dutch, English, Esperanto, Estonian, Filipino, Finnish, French, Galician, Georgian, German, Greek, Gujarati, Hausa, Hebrew, Hindi, Hindi Romanized, Hungarian, Icelandic, Indonesian, Irish, Italian, Japanese, Javanese, Kannada, Kazakh, Khmer, Korean, Kurdish (Kurmanji), Kyrgyz, Lao, Latin, Latvian, Lithuanian, Macedonian, Malagasy, Malay, Malayalam, Marathi, Mongolian, Nepali, Norwegian, Oriya, Oromo, Pashto, Persian, Polish, Portuguese, Punjabi, Romanian, Russian, Sanskri, Scottish, Gaelic, Serbian, Sindhi, Sinhala, Slovak, Slovenian, Somali, Spanish, Sundanese, Swahili, Swedish, Tamil, Tamil Romanized, Telugu, Telugu Romanized, Thai, Turkish, Ukrainian, Urdu, Urdu Romanized, Uyghur, Uzbek, Vietnamese, Welsh, Western, Frisian, Xhosa, Yiddish.
+
+Thus, results for language pairs containing uncovered languages are unreliable, as per the [COMET website](https://github.com/Unbabel/COMET)
+
+Also, calculating the COMET metric involves downloading the model from which features are obtained -- the default model, `wmt20-comet-da`, takes over 1.79GB of storage space and downloading it can take a significant amount of time depending on the speed of your internet connection. If this is an issue, choose a smaller model; for instance `wmt21-cometinho-da` is 344MB.
+
+## Citation
+
+```bibtex
+@inproceedings{rei-EtAl:2020:WMT,
+   author    = {Rei, Ricardo  and  Stewart, Craig  and  Farinha, Ana C  and  Lavie, Alon},
+   title     = {Unbabel's Participation in the WMT20 Metrics Shared Task},
+   booktitle      = {Proceedings of the Fifth Conference on Machine Translation},
+   month          = {November},
+   year           = {2020},
+   address        = {Online},
+   publisher      = {Association for Computational Linguistics},
+   pages     = {909--918},
+}
+```
+
+```bibtex
+@inproceedings{rei-etal-2020-comet,
+   title = "{COMET}: A Neural Framework for {MT} Evaluation",
+   author = "Rei, Ricardo  and
+      Stewart, Craig  and
+      Farinha, Ana C  and
+      Lavie, Alon",
+   booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
+   month = nov,
+   year = "2020",
+   address = "Online",
+   publisher = "Association for Computational Linguistics",
+   url = "https://www.aclweb.org/anthology/2020.emnlp-main.213",
+   pages = "2685--2702",
+
+```
+
+## Further References
+
+- [COMET website](https://unbabel.github.io/COMET/html/index.html)
+- [Hugging Face Tasks - Machine Translation](https://huggingface.co/tasks/translation)

testbed/huggingface__datasets/metrics/comet/comet.py

@@ -0,0 +1,143 @@
+# Copyright 2020 The HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" COMET metric.
+
+Requirements:
+pip install unbabel-comet
+
+Usage:
+
+```python
+from datasets import load_metric
+comet_metric = load_metric('metrics/comet/comet.py')
+#comet_metric = load_metric('comet')
+#comet_metric = load_metric('comet', 'wmt-large-hter-estimator')
+
+
+source = ["Dem Feuer konnte Einhalt geboten werden", "Schulen und Kindergärten wurden eröffnet."]
+hypothesis = ["The fire could be stopped", "Schools and kindergartens were open"]
+reference = ["They were able to control the fire.", "Schools and kindergartens opened"]
+
+predictions = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)
+predictions['scores']
+```
+"""
+
+import comet  # From: unbabel-comet
+import torch
+
+import datasets
+
+
+logger = datasets.logging.get_logger(__name__)
+
+_CITATION = """\
+@inproceedings{rei-EtAl:2020:WMT,
+   author    = {Rei, Ricardo  and  Stewart, Craig  and  Farinha, Ana C  and  Lavie, Alon},
+   title     = {Unbabel's Participation in the WMT20 Metrics Shared Task},
+   booktitle      = {Proceedings of the Fifth Conference on Machine Translation},
+   month          = {November},
+   year           = {2020},
+   address        = {Online},
+   publisher      = {Association for Computational Linguistics},
+   pages     = {909--918},
+}
+@inproceedings{rei-etal-2020-comet,
+   title = "{COMET}: A Neural Framework for {MT} Evaluation",
+   author = "Rei, Ricardo  and
+      Stewart, Craig  and
+      Farinha, Ana C  and
+      Lavie, Alon",
+   booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
+   month = nov,
+   year = "2020",
+   address = "Online",
+   publisher = "Association for Computational Linguistics",
+   url = "https://www.aclweb.org/anthology/2020.emnlp-main.213",
+   pages = "2685--2702",
+}
+"""
+
+_DESCRIPTION = """\
+Crosslingual Optimized Metric for Evaluation of Translation (COMET) is an open-source framework used to train Machine Translation metrics that achieve high levels of correlation with different types of human judgments (HTER, DA's or MQM).
+With the release of the framework the authors also released fully trained models that were used to compete in the WMT20 Metrics Shared Task achieving SOTA in that years competition.
+
+See the [README.md] file at https://unbabel.github.io/COMET/html/models.html for more information.
+"""
+
+_KWARGS_DESCRIPTION = """
+COMET score.
+
+Args:
+
+`sources` (list of str): Source sentences
+`predictions` (list of str): candidate translations
+`references` (list of str): reference translations
+`cuda` (bool): If set to True, runs COMET using GPU
+`show_progress` (bool): Shows progress
+`model`: COMET model to be used. Will default to `wmt-large-da-estimator-1719` if None.
+
+Returns:
+    `samples`: List of dictionaries with `src`, `mt`, `ref` and `score`.
+    `scores`: List of scores.
+
+Examples:
+
+    >>> comet_metric = datasets.load_metric('comet')
+    >>> # comet_metric = load_metric('comet', 'wmt20-comet-da')  # you can also choose which model to use
+    >>> source = ["Dem Feuer konnte Einhalt geboten werden", "Schulen und Kindergärten wurden eröffnet."]
+    >>> hypothesis = ["The fire could be stopped", "Schools and kindergartens were open"]
+    >>> reference = ["They were able to control the fire.", "Schools and kindergartens opened"]
+    >>> results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)
+    >>> print([round(v, 2) for v in results["scores"]])
+    [0.19, 0.92]
+"""
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class COMET(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            homepage="https://unbabel.github.io/COMET/html/index.html",
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "sources": datasets.Value("string", id="sequence"),
+                    "predictions": datasets.Value("string", id="sequence"),
+                    "references": datasets.Value("string", id="sequence"),
+                }
+            ),
+            codebase_urls=["https://github.com/Unbabel/COMET"],
+            reference_urls=[
+                "https://github.com/Unbabel/COMET",
+                "https://www.aclweb.org/anthology/2020.emnlp-main.213/",
+                "http://www.statmt.org/wmt20/pdf/2020.wmt-1.101.pdf6",
+            ],
+        )
+
+    def _download_and_prepare(self, dl_manager):
+        if self.config_name == "default":
+            self.scorer = comet.load_from_checkpoint(comet.download_model("wmt20-comet-da"))
+        else:
+            self.scorer = comet.load_from_checkpoint(comet.download_model(self.config_name))
+
+    def _compute(self, sources, predictions, references, gpus=None, progress_bar=False):
+        if gpus is None:
+            gpus = 1 if torch.cuda.is_available() else 0
+        data = {"src": sources, "mt": predictions, "ref": references}
+        data = [dict(zip(data, t)) for t in zip(*data.values())]
+        scores, mean_score = self.scorer.predict(data, gpus=gpus, progress_bar=progress_bar)
+        return {"mean_score": mean_score, "scores": scores}

testbed/huggingface__datasets/metrics/competition_math/README.md

@@ -0,0 +1,103 @@
+# Metric Card for Competition MATH
+
+## Metric description
+
+This metric is used to assess performance on the [Mathematics Aptitude Test of Heuristics (MATH) dataset](https://huggingface.co/datasets/competition_math). 
+
+It first canonicalizes the inputs (e.g., converting `1/2` to `\\frac{1}{2}`) and then computes accuracy.
+
+## How to use 
+
+This metric takes two arguments:
+
+`predictions`: a list of predictions to score. Each prediction is a string that contains natural language and LaTeX.
+
+`references`: list of reference for each prediction. Each reference is a string that contains natural language and LaTeX.
+
+
+```python
+>>> from datasets import load_metric
+>>> math = load_metric("competition_math")
+>>> references = ["\\frac{1}{2}"]
+>>> predictions = ["1/2"]
+>>> results = math.compute(references=references, predictions=predictions)
+```
+
+N.B. To be able to use Competition MATH, you need to install the `math_equivalence` dependency using `pip install git+https://github.com/hendrycks/math.git`. 
+
+
+## Output values
+
+This metric returns a dictionary that contains the [accuracy](https://huggingface.co/metrics/accuracy) after canonicalizing inputs, on a scale between 0.0 and 1.0.
+
+### Values from popular papers
+The [original MATH dataset paper](https://arxiv.org/abs/2103.03874) reported accuracies ranging from 3.0% to 6.9% by different large language models. 
+
+More recent progress on the dataset can be found on the [dataset leaderboard](https://paperswithcode.com/sota/math-word-problem-solving-on-math).
+
+## Examples 
+
+Maximal values (full match):
+
+```python
+>>> from datasets import load_metric
+>>> math = load_metric("competition_math")
+>>> references = ["\\frac{1}{2}"]
+>>> predictions = ["1/2"]
+>>> results = math.compute(references=references, predictions=predictions)
+>>> print(results)
+{'accuracy': 1.0}
+```
+
+Minimal values (no match):
+
+```python
+>>> from datasets import load_metric
+>>> math = load_metric("competition_math")
+>>> references = ["\\frac{1}{2}"]
+>>> predictions = ["3/4"]
+>>> results = math.compute(references=references, predictions=predictions)
+>>> print(results)
+{'accuracy': 0.0}
+```
+
+Partial match:
+
+```python
+>>> from datasets import load_metric
+>>> math = load_metric("competition_math")
+>>> references = ["\\frac{1}{2}","\\frac{3}{4}"]
+>>> predictions = ["1/5", "3/4"]
+>>> results = math.compute(references=references, predictions=predictions)
+>>> print(results)
+{'accuracy': 0.5}
+```
+
+## Limitations and bias
+
+This metric is limited to datasets with the same format as the [Mathematics Aptitude Test of Heuristics (MATH) dataset](https://huggingface.co/datasets/competition_math), and is meant to evaluate the performance of large language models at solving mathematical problems.
+
+N.B. The MATH dataset also assigns levels of difficulty to different problems, so disagregating model performance by difficulty level (similarly to what was done in the [original paper](https://arxiv.org/abs/2103.03874) can give a better indication of how a given model does on a given difficulty of math problem, compared to overall accuracy. 
+
+## Citation
+
+```bibtex
+@article{hendrycksmath2021,
+  title={Measuring Mathematical Problem Solving With the MATH Dataset},
+  author={Dan Hendrycks
+    and Collin Burns
+    and Saurav Kadavath
+    and Akul Arora
+    and Steven Basart
+    and Eric Tang
+    and Dawn Song
+    and Jacob Steinhardt},
+  journal={arXiv preprint arXiv:2103.03874},
+  year={2021}
+}
+```
+    
+## Further References 
+- [MATH dataset](https://huggingface.co/datasets/competition_math)
+- [MATH leaderboard](https://paperswithcode.com/sota/math-word-problem-solving-on-math)
+- [MATH paper](https://arxiv.org/abs/2103.03874)

testbed/huggingface__datasets/metrics/competition_math/competition_math.py

@@ -0,0 +1,94 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Accuracy metric for the Mathematics Aptitude Test of Heuristics (MATH) dataset."""
+
+import math_equivalence  # From: git+https://github.com/hendrycks/math.git
+
+import datasets
+
+
+_CITATION = """\
+@article{hendrycksmath2021,
+  title={Measuring Mathematical Problem Solving With the MATH Dataset},
+  author={Dan Hendrycks
+    and Collin Burns
+    and Saurav Kadavath
+    and Akul Arora
+    and Steven Basart
+    and Eric Tang
+    and Dawn Song
+    and Jacob Steinhardt},
+  journal={arXiv preprint arXiv:2103.03874},
+  year={2021}
+}
+"""
+
+
+_DESCRIPTION = """\
+This metric is used to assess performance on the Mathematics Aptitude Test of Heuristics (MATH) dataset.
+It first canonicalizes the inputs (e.g., converting "1/2" to "\\frac{1}{2}") and then computes accuracy.
+"""
+
+
+_KWARGS_DESCRIPTION = r"""
+Calculates accuracy after canonicalizing inputs.
+
+Args:
+    predictions: list of predictions to score. Each prediction
+        is a string that contains natural language and LaTex.
+    references: list of reference for each prediction. Each
+        reference is a string that contains natural language
+        and LaTex.
+Returns:
+    accuracy: accuracy after canonicalizing inputs
+        (e.g., converting "1/2" to "\\frac{1}{2}")
+
+Examples:
+    >>> metric = datasets.load_metric("competition_math")
+    >>> results = metric.compute(references=["\\frac{1}{2}"], predictions=["1/2"])
+    >>> print(results)
+    {'accuracy': 1.0}
+"""
+
+
+@datasets.utils.file_utils.add_end_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class CompetitionMathMetric(datasets.Metric):
+    """Accuracy metric for the MATH dataset."""
+
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Value("string"),
+                    "references": datasets.Value("string"),
+                }
+            ),
+            # Homepage of the metric for documentation
+            homepage="https://github.com/hendrycks/math",
+            # Additional links to the codebase or references
+            codebase_urls=["https://github.com/hendrycks/math"],
+        )
+
+    def _compute(self, predictions, references):
+        """Returns the scores"""
+        n_correct = 0.0
+        for i, j in zip(predictions, references):
+            n_correct += 1.0 if math_equivalence.is_equiv(i, j) else 0.0
+        accuracy = n_correct / len(predictions)
+        return {
+            "accuracy": accuracy,
+        }

testbed/huggingface__datasets/metrics/coval/README.md

@@ -0,0 +1,170 @@
+# Metric Card for COVAL
+
+## Metric description
+
+CoVal is a coreference evaluation tool for the [CoNLL](https://huggingface.co/datasets/conll2003) and [ARRAU](https://catalog.ldc.upenn.edu/LDC2013T22) datasets which implements of the common evaluation metrics including MUC [Vilain et al, 1995](https://aclanthology.org/M95-1005.pdf), B-cubed [Bagga and Baldwin, 1998](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.34.2578&rep=rep1&type=pdf), CEAFe [Luo et al., 2005](https://aclanthology.org/H05-1004.pdf), LEA [Moosavi and Strube, 2016](https://aclanthology.org/P16-1060.pdf) and the averaged CoNLL score (the average of the F1 values of MUC, B-cubed and CEAFe). 
+
+CoVal code was written by [`@ns-moosavi`](https://github.com/ns-moosavi), with some parts borrowed from [Deep Coref](https://github.com/clarkkev/deep-coref/blob/master/evaluation.py). The test suite is taken from the [official CoNLL code](https://github.com/conll/reference-coreference-scorers/), with additions by [`@andreasvc`](https://github.com/andreasvc) and file parsing developed by Leo Born.
+
+## How to use 
+
+The metric takes two lists of sentences as input: one representing `predictions` and `references`, with the sentences consisting of words in the CoNLL format (see the [Limitations and bias](#Limitations-and-bias) section below for more details on the CoNLL format). 
+
+```python
+from datasets import load_metric
+coval = load_metric('coval')
+words = ['bc/cctv/00/cctv_0005   0   0       Thank   VBP  (TOP(S(VP*    thank  01   1    Xu_li  *           (V*)        *       -',
+... 'bc/cctv/00/cctv_0005   0   1         you   PRP        (NP*)      -    -   -    Xu_li  *        (ARG1*)   (ARG0*)   (116)',
+... 'bc/cctv/00/cctv_0005   0   2    everyone    NN        (NP*)      -    -   -    Xu_li  *    (ARGM-DIS*)        *    (116)',
+... 'bc/cctv/00/cctv_0005   0   3         for    IN        (PP*       -    -   -    Xu_li  *        (ARG2*         *       -',
+... 'bc/cctv/00/cctv_0005   0   4    watching   VBG   (S(VP*))))   watch  01   1    Xu_li  *             *)      (V*)      -',
+... 'bc/cctv/00/cctv_0005   0   5           .     .          *))      -    -   -    Xu_li  *             *         *       -']
+references = [words]
+predictions = [words]
+results = coval.compute(predictions=predictions, references=references)
+```
+It also has several optional arguments:
+
+`keep_singletons`: After extracting all mentions of key or system file mentions whose corresponding coreference chain is of size one are considered as singletons. The default evaluation mode will include singletons in evaluations if they are included in the key or the system files. By setting `keep_singletons=False`, all singletons in the key and system files will be excluded from the evaluation.
+
+`NP_only`: Most of the recent coreference resolvers only resolve NP mentions and leave out the resolution of VPs. By setting the `NP_only` option, the scorer will only evaluate the resolution of NPs.
+
+`min_span`: By setting `min_span`, the scorer reports the results based on automatically detected minimum spans. Minimum spans are determined using the [MINA algorithm](https://arxiv.org/pdf/1906.06703.pdf).
+        
+
+## Output values
+
+The metric outputs a dictionary with the following key-value pairs:
+
+`mentions`: number of mentions, ranges from 0-1
+
+`muc`: MUC metric, which expresses performance in terms of recall and precision, ranging from 0-1.
+
+`bcub`: B-cubed metric, which is the averaged precision of all items in the distribution, ranging from 0-1.
+
+`ceafe`: CEAFe (Constrained Entity Alignment F-Measure) is computed by aligning reference and system entities with the constraint that a reference entity is aligned with at most one reference entity. It ranges from 0-1
+
+`lea`: LEA is a Link-Based Entity-Aware metric which, for each entity, considers how important the entity is and how well it is resolved. It ranges from 0-1.
+
+`conll_score`: averaged CoNLL score (the average of the F1 values of `muc`, `bcub` and `ceafe`), ranging from 0 to 100. 
+   
+
+### Values from popular papers
+
+Given that many of the metrics returned by COVAL come from different sources, is it hard to cite reference values for all of them.
+
+The CoNLL score is used to track progress on different datasets such as the [ARRAU corpus](https://paperswithcode.com/sota/coreference-resolution-on-the-arrau-corpus) and [CoNLL 2012](https://paperswithcode.com/sota/coreference-resolution-on-conll-2012).
+
+## Examples 
+
+Maximal values
+
+```python
+from datasets import load_metric
+coval = load_metric('coval')
+words = ['bc/cctv/00/cctv_0005   0   0       Thank   VBP  (TOP(S(VP*    thank  01   1    Xu_li  *           (V*)        *       -',
+... 'bc/cctv/00/cctv_0005   0   1         you   PRP        (NP*)      -    -   -    Xu_li  *        (ARG1*)   (ARG0*)   (116)',
+... 'bc/cctv/00/cctv_0005   0   2    everyone    NN        (NP*)      -    -   -    Xu_li  *    (ARGM-DIS*)        *    (116)',
+... 'bc/cctv/00/cctv_0005   0   3         for    IN        (PP*       -    -   -    Xu_li  *        (ARG2*         *       -',
+... 'bc/cctv/00/cctv_0005   0   4    watching   VBG   (S(VP*))))   watch  01   1    Xu_li  *             *)      (V*)      -',
+... 'bc/cctv/00/cctv_0005   0   5           .     .          *))      -    -   -    Xu_li  *             *         *       -']
+references = [words]
+predictions = [words]
+results = coval.compute(predictions=predictions, references=references)
+print(results)
+{'mentions/recall': 1.0, 'mentions/precision': 1.0, 'mentions/f1': 1.0, 'muc/recall': 1.0, 'muc/precision': 1.0, 'muc/f1': 1.0, 'bcub/recall': 1.0, 'bcub/precision': 1.0, 'bcub/f1': 1.0, 'ceafe/recall': 1.0, 'ceafe/precision': 1.0, 'ceafe/f1': 1.0, 'lea/recall': 1.0, 'lea/precision': 1.0, 'lea/f1': 1.0, 'conll_score': 100.0}
+```
+
+## Limitations and bias
+
+This wrapper of CoVal currently only works with [CoNLL line format](https://huggingface.co/datasets/conll2003), which has one word per line with all the annotation for this word in column separated by spaces:
+
+| Column | Type                  | Description                                                                                                                                                                                                                                                                                             |
+|:-------|:----------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| 1      | Document ID           | This is a variation on the document filename                                                                                                                                                                                                                                                            |
+| 2      | Part number           | Some files are divided into multiple parts numbered as 000, 001, 002, ... etc.                                                                                                                                                                                                                          |
+| 3      | Word number           |                                                                                                                                                                                                                                                                                                         |
+| 4      | Word                  | This is the token as segmented/tokenized in the Treebank. Initially the *_skel file contain the placeholder [WORD] which gets replaced by the actual token from the Treebank which is part of the OntoNotes release.                                                                                    |
+| 5      | Part-of-Speech        |                                                                                                                                                                                                                                                                                                         |
+| 6      | Parse bit             | This is the bracketed structure broken before the first open parenthesis in the parse, and the word/part-of-speech leaf replaced with a *. The full parse can be created by substituting the asterix with the "([pos] [word])" string (or leaf) and concatenating the items in the rows of that column. |
+| 7      | Predicate lemma       | The predicate lemma is mentioned for the rows for which we have semantic role information. All other rows are marked with a "-".                                                                                                                                                                        |
+| 8      | Predicate Frameset ID | This is the PropBank frameset ID of the predicate in Column 7.                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                          
+| 9      | Word sense            | This is the word sense of the word in Column 3.                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                        
+| 10     | Speaker/Author        | This is the speaker or author name where available. Mostly in Broadcast Conversation and Web Log data.                                                                                                                                                                                                  |                                                                                                                                                                                                 
+| 11     | Named Entities        | These columns identifies the spans representing various named entities.                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                
+| 12:N   | Predicate Arguments   | There is one column each of predicate argument structure information for the predicate mentioned in Column 7.                                                                                                                                                                                           |
+| N      | Coreference           | Coreference chain information encoded in a parenthesis structure.                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                     
+
+## Citations
+
+```bibtex
+@InProceedings{moosavi2019minimum,
+  author = { Nafise Sadat Moosavi, Leo Born, Massimo Poesio and Michael Strube},
+  title = {Using Automatically Extracted Minimum Spans to Disentangle Coreference Evaluation from Boundary Detection},
+  year = {2019},
+  booktitle = {Proceedings of the 57th Annual Meeting of
+      the Association for Computational Linguistics (Volume 1: Long Papers)},
+  publisher = {Association for Computational Linguistics},
+  address = {Florence, Italy},
+}
+```
+```bibtex
+@inproceedings{10.3115/1072399.1072405,
+  author = {Vilain, Marc and Burger, John and Aberdeen, John and Connolly, Dennis and Hirschman, Lynette},
+  title = {A Model-Theoretic Coreference Scoring Scheme},
+  year = {1995},
+  isbn = {1558604022},
+  publisher = {Association for Computational Linguistics},
+  address = {USA},
+  url = {https://doi.org/10.3115/1072399.1072405},
+  doi = {10.3115/1072399.1072405},
+  booktitle = {Proceedings of the 6th Conference on Message Understanding},
+  pages = {45–52},
+  numpages = {8},
+  location = {Columbia, Maryland},
+  series = {MUC6 ’95}
+}
+```
+
+```bibtex
+@INPROCEEDINGS{Bagga98algorithmsfor,
+    author = {Amit Bagga and Breck Baldwin},
+    title = {Algorithms for Scoring Coreference Chains},
+    booktitle = {In The First International Conference on Language Resources and Evaluation Workshop on Linguistics Coreference},
+    year = {1998},
+    pages = {563--566}
+}
+```
+```bibtex
+@INPROCEEDINGS{Luo05oncoreference,
+    author = {Xiaoqiang Luo},
+    title = {On coreference resolution performance metrics},
+    booktitle = {In Proc. of HLT/EMNLP},
+    year = {2005},
+    pages = {25--32},
+    publisher = {URL}
+}
+```
+
+```bibtex
+@inproceedings{moosavi-strube-2016-coreference,
+    title = "Which Coreference Evaluation Metric Do You Trust? A Proposal for a Link-based Entity Aware Metric",
+    author = "Moosavi, Nafise Sadat  and
+      Strube, Michael",
+    booktitle = "Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
+    month = aug,
+    year = "2016",
+    address = "Berlin, Germany",
+    publisher = "Association for Computational Linguistics",
+    url = "https://www.aclweb.org/anthology/P16-1060",
+    doi = "10.18653/v1/P16-1060",
+    pages = "632--642",
+}
+```
+    
+## Further References 
+
+- [CoNLL 2012 Task Description](http://www.conll.cemantix.org/2012/data.html): for information on the format (section "*_conll File Format")
+- [CoNLL Evaluation details](https://github.com/ns-moosavi/coval/blob/master/conll/README.md)
+- [Hugging Face - Neural Coreference Resolution (Neuralcoref)](https://huggingface.co/coref/)
+

testbed/huggingface__datasets/metrics/coval/coval.py

@@ -0,0 +1,319 @@
+# Copyright 2020 The HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" CoVal metric. """
+import coval  # From: git+https://github.com/ns-moosavi/coval.git # noqa: F401
+from coval.conll import reader, util
+from coval.eval import evaluator
+
+import datasets
+
+
+logger = datasets.logging.get_logger(__name__)
+
+
+_CITATION = """\
+@InProceedings{moosavi2019minimum,
+    author = { Nafise Sadat Moosavi, Leo Born, Massimo Poesio and Michael Strube},
+    title = {Using Automatically Extracted Minimum Spans to Disentangle Coreference Evaluation from Boundary Detection},
+    year = {2019},
+    booktitle = {Proceedings of the 57th Annual Meeting of
+        the Association for Computational Linguistics (Volume 1: Long Papers)},
+    publisher = {Association for Computational Linguistics},
+    address = {Florence, Italy},
+}
+
+@inproceedings{10.3115/1072399.1072405,
+author = {Vilain, Marc and Burger, John and Aberdeen, John and Connolly, Dennis and Hirschman, Lynette},
+title = {A Model-Theoretic Coreference Scoring Scheme},
+year = {1995},
+isbn = {1558604022},
+publisher = {Association for Computational Linguistics},
+address = {USA},
+url = {https://doi.org/10.3115/1072399.1072405},
+doi = {10.3115/1072399.1072405},
+booktitle = {Proceedings of the 6th Conference on Message Understanding},
+pages = {45–52},
+numpages = {8},
+location = {Columbia, Maryland},
+series = {MUC6 ’95}
+}
+
+@INPROCEEDINGS{Bagga98algorithmsfor,
+    author = {Amit Bagga and Breck Baldwin},
+    title = {Algorithms for Scoring Coreference Chains},
+    booktitle = {In The First International Conference on Language Resources and Evaluation Workshop on Linguistics Coreference},
+    year = {1998},
+    pages = {563--566}
+}
+
+@INPROCEEDINGS{Luo05oncoreference,
+    author = {Xiaoqiang Luo},
+    title = {On coreference resolution performance metrics},
+    booktitle = {In Proc. of HLT/EMNLP},
+    year = {2005},
+    pages = {25--32},
+    publisher = {URL}
+}
+
+@inproceedings{moosavi-strube-2016-coreference,
+    title = "Which Coreference Evaluation Metric Do You Trust? A Proposal for a Link-based Entity Aware Metric",
+    author = "Moosavi, Nafise Sadat  and
+      Strube, Michael",
+    booktitle = "Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)",
+    month = aug,
+    year = "2016",
+    address = "Berlin, Germany",
+    publisher = "Association for Computational Linguistics",
+    url = "https://www.aclweb.org/anthology/P16-1060",
+    doi = "10.18653/v1/P16-1060",
+    pages = "632--642",
+}
+
+"""
+
+_DESCRIPTION = """\
+CoVal is a coreference evaluation tool for the CoNLL and ARRAU datasets which
+implements of the common evaluation metrics including MUC [Vilain et al, 1995],
+B-cubed [Bagga and Baldwin, 1998], CEAFe [Luo et al., 2005],
+LEA [Moosavi and Strube, 2016] and the averaged CoNLL score
+(the average of the F1 values of MUC, B-cubed and CEAFe)
+[Denis and Baldridge, 2009a; Pradhan et al., 2011].
+
+This wrapper of CoVal currently only work with CoNLL line format:
+The CoNLL format has one word per line with all the annotation for this word in column separated by spaces:
+Column	Type	Description
+1	Document ID	This is a variation on the document filename
+2	Part number	Some files are divided into multiple parts numbered as 000, 001, 002, ... etc.
+3	Word number
+4	Word itself	This is the token as segmented/tokenized in the Treebank. Initially the *_skel file contain the placeholder [WORD] which gets replaced by the actual token from the Treebank which is part of the OntoNotes release.
+5	Part-of-Speech
+6	Parse bit	This is the bracketed structure broken before the first open parenthesis in the parse, and the word/part-of-speech leaf replaced with a *. The full parse can be created by substituting the asterix with the "([pos] [word])" string (or leaf) and concatenating the items in the rows of that column.
+7	Predicate lemma	The predicate lemma is mentioned for the rows for which we have semantic role information. All other rows are marked with a "-"
+8	Predicate Frameset ID	This is the PropBank frameset ID of the predicate in Column 7.
+9	Word sense	This is the word sense of the word in Column 3.
+10	Speaker/Author	This is the speaker or author name where available. Mostly in Broadcast Conversation and Web Log data.
+11	Named Entities	These columns identifies the spans representing various named entities.
+12:N	Predicate Arguments	There is one column each of predicate argument structure information for the predicate mentioned in Column 7.
+N	Coreference	Coreference chain information encoded in a parenthesis structure.
+More informations on the format can be found here (section "*_conll File Format"): http://www.conll.cemantix.org/2012/data.html
+
+Details on the evaluation on CoNLL can be found here: https://github.com/ns-moosavi/coval/blob/master/conll/README.md
+
+CoVal code was written by @ns-moosavi.
+Some parts are borrowed from https://github.com/clarkkev/deep-coref/blob/master/evaluation.py
+The test suite is taken from https://github.com/conll/reference-coreference-scorers/
+Mention evaluation and the test suite are added by @andreasvc.
+Parsing CoNLL files is developed by Leo Born.
+"""
+
+_KWARGS_DESCRIPTION = """
+Calculates coreference evaluation metrics.
+Args:
+    predictions: list of sentences. Each sentence is a list of word predictions to score in the CoNLL format.
+        Each prediction is a word with its annotations as a string made of columns joined with spaces.
+        Only columns 4, 5, 6 and the last column are used (word, POS, Pars and coreference annotation)
+        See the details on the format in the description of the metric.
+    references: list of sentences. Each sentence is a list of word reference to score in the CoNLL format.
+        Each reference is a word with its annotations as a string made of columns joined with spaces.
+        Only columns 4, 5, 6 and the last column are used (word, POS, Pars and coreference annotation)
+        See the details on the format in the description of the metric.
+    keep_singletons: After extracting all mentions of key or system files,
+        mentions whose corresponding coreference chain is of size one,
+        are considered as singletons. The default evaluation mode will include
+        singletons in evaluations if they are included in the key or the system files.
+        By setting 'keep_singletons=False', all singletons in the key and system files
+        will be excluded from the evaluation.
+    NP_only: Most of the recent coreference resolvers only resolve NP mentions and
+        leave out the resolution of VPs. By setting the 'NP_only' option, the scorer will only evaluate the resolution of NPs.
+    min_span: By setting 'min_span', the scorer reports the results based on automatically detected minimum spans.
+        Minimum spans are determined using the MINA algorithm.
+
+Returns:
+    'mentions': mentions
+    'muc': MUC metric [Vilain et al, 1995]
+    'bcub': B-cubed [Bagga and Baldwin, 1998]
+    'ceafe': CEAFe [Luo et al., 2005]
+    'lea': LEA [Moosavi and Strube, 2016]
+    'conll_score': averaged CoNLL score (the average of the F1 values of MUC, B-cubed and CEAFe)
+
+Examples:
+
+    >>> coval = datasets.load_metric('coval')
+    >>> words = ['bc/cctv/00/cctv_0005   0   0       Thank   VBP  (TOP(S(VP*    thank  01   1    Xu_li  *           (V*)        *       -',
+    ... 'bc/cctv/00/cctv_0005   0   1         you   PRP        (NP*)      -    -   -    Xu_li  *        (ARG1*)   (ARG0*)   (116)',
+    ... 'bc/cctv/00/cctv_0005   0   2    everyone    NN        (NP*)      -    -   -    Xu_li  *    (ARGM-DIS*)        *    (116)',
+    ... 'bc/cctv/00/cctv_0005   0   3         for    IN        (PP*       -    -   -    Xu_li  *        (ARG2*         *       -',
+    ... 'bc/cctv/00/cctv_0005   0   4    watching   VBG   (S(VP*))))   watch  01   1    Xu_li  *             *)      (V*)      -',
+    ... 'bc/cctv/00/cctv_0005   0   5           .     .          *))      -    -   -    Xu_li  *             *         *       -']
+    >>> references = [words]
+    >>> predictions = [words]
+    >>> results = coval.compute(predictions=predictions, references=references)
+    >>> print(results) # doctest:+ELLIPSIS
+    {'mentions/recall': 1.0,[...] 'conll_score': 100.0}
+"""
+
+
+def get_coref_infos(
+    key_lines, sys_lines, NP_only=False, remove_nested=False, keep_singletons=True, min_span=False, doc="dummy_doc"
+):
+    key_doc_lines = {doc: key_lines}
+    sys_doc_lines = {doc: sys_lines}
+
+    doc_coref_infos = {}
+
+    key_nested_coref_num = 0
+    sys_nested_coref_num = 0
+    key_removed_nested_clusters = 0
+    sys_removed_nested_clusters = 0
+    key_singletons_num = 0
+    sys_singletons_num = 0
+
+    key_clusters, singletons_num = reader.get_doc_mentions(doc, key_doc_lines[doc], keep_singletons)
+    key_singletons_num += singletons_num
+
+    if NP_only or min_span:
+        key_clusters = reader.set_annotated_parse_trees(key_clusters, key_doc_lines[doc], NP_only, min_span)
+
+    sys_clusters, singletons_num = reader.get_doc_mentions(doc, sys_doc_lines[doc], keep_singletons)
+    sys_singletons_num += singletons_num
+
+    if NP_only or min_span:
+        sys_clusters = reader.set_annotated_parse_trees(sys_clusters, key_doc_lines[doc], NP_only, min_span)
+
+    if remove_nested:
+        nested_mentions, removed_clusters = reader.remove_nested_coref_mentions(key_clusters, keep_singletons)
+        key_nested_coref_num += nested_mentions
+        key_removed_nested_clusters += removed_clusters
+
+        nested_mentions, removed_clusters = reader.remove_nested_coref_mentions(sys_clusters, keep_singletons)
+        sys_nested_coref_num += nested_mentions
+        sys_removed_nested_clusters += removed_clusters
+
+    sys_mention_key_cluster = reader.get_mention_assignments(sys_clusters, key_clusters)
+    key_mention_sys_cluster = reader.get_mention_assignments(key_clusters, sys_clusters)
+
+    doc_coref_infos[doc] = (key_clusters, sys_clusters, key_mention_sys_cluster, sys_mention_key_cluster)
+
+    if remove_nested:
+        logger.info(
+            "Number of removed nested coreferring mentions in the key "
+            f"annotation: {key_nested_coref_num}; and system annotation: {sys_nested_coref_num}"
+        )
+        logger.info(
+            "Number of resulting singleton clusters in the key "
+            f"annotation: {key_removed_nested_clusters}; and system annotation: {sys_removed_nested_clusters}"
+        )
+
+    if not keep_singletons:
+        logger.info(
+            f"{key_singletons_num:d} and {sys_singletons_num:d} singletons are removed from the key and system "
+            "files, respectively"
+        )
+
+    return doc_coref_infos
+
+
+def evaluate(key_lines, sys_lines, metrics, NP_only, remove_nested, keep_singletons, min_span):
+    doc_coref_infos = get_coref_infos(key_lines, sys_lines, NP_only, remove_nested, keep_singletons, min_span)
+
+    output_scores = {}
+    conll = 0
+    conll_subparts_num = 0
+
+    for name, metric in metrics:
+        recall, precision, f1 = evaluator.evaluate_documents(doc_coref_infos, metric, beta=1)
+        if name in ["muc", "bcub", "ceafe"]:
+            conll += f1
+            conll_subparts_num += 1
+        output_scores.update({f"{name}/recall": recall, f"{name}/precision": precision, f"{name}/f1": f1})
+
+        logger.info(
+            name.ljust(10),
+            f"Recall: {recall * 100:.2f}",
+            f" Precision: {precision * 100:.2f}",
+            f" F1: {f1 * 100:.2f}",
+        )
+
+    if conll_subparts_num == 3:
+        conll = (conll / 3) * 100
+        logger.info(f"CoNLL score: {conll:.2f}")
+        output_scores.update({"conll_score": conll})
+
+    return output_scores
+
+
+def check_gold_parse_annotation(key_lines):
+    has_gold_parse = False
+    for line in key_lines:
+        if not line.startswith("#"):
+            if len(line.split()) > 6:
+                parse_col = line.split()[5]
+                if not parse_col == "-":
+                    has_gold_parse = True
+                    break
+                else:
+                    break
+    return has_gold_parse
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class Coval(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Sequence(datasets.Value("string")),
+                    "references": datasets.Sequence(datasets.Value("string")),
+                }
+            ),
+            codebase_urls=["https://github.com/ns-moosavi/coval"],
+            reference_urls=[
+                "https://github.com/ns-moosavi/coval",
+                "https://www.aclweb.org/anthology/P16-1060",
+                "http://www.conll.cemantix.org/2012/data.html",
+            ],
+        )
+
+    def _compute(
+        self, predictions, references, keep_singletons=True, NP_only=False, min_span=False, remove_nested=False
+    ):
+        allmetrics = [
+            ("mentions", evaluator.mentions),
+            ("muc", evaluator.muc),
+            ("bcub", evaluator.b_cubed),
+            ("ceafe", evaluator.ceafe),
+            ("lea", evaluator.lea),
+        ]
+
+        if min_span:
+            has_gold_parse = util.check_gold_parse_annotation(references)
+            if not has_gold_parse:
+                raise NotImplementedError("References should have gold parse annotation to use 'min_span'.")
+                # util.parse_key_file(key_file)
+                # key_file = key_file + ".parsed"
+
+        score = evaluate(
+            key_lines=references,
+            sys_lines=predictions,
+            metrics=allmetrics,
+            NP_only=NP_only,
+            remove_nested=remove_nested,
+            keep_singletons=keep_singletons,
+            min_span=min_span,
+        )
+
+        return score

testbed/huggingface__datasets/metrics/cuad/README.md

@@ -0,0 +1,112 @@
+# Metric Card for CUAD
+
+## Metric description
+
+This metric wraps the official scoring script for version 1 of the [Contract Understanding Atticus Dataset (CUAD)](https://huggingface.co/datasets/cuad), which is a corpus of more than 13,000 labels in 510 commercial legal contracts that have been manually labeled to identify 41 categories of important clauses that lawyers look for when reviewing contracts in connection with corporate transactions.
+
+The CUAD metric computes several scores: [Exact Match](https://huggingface.co/metrics/exact_match), [F1 score](https://huggingface.co/metrics/f1), Area Under the Precision-Recall Curve, [Precision](https://huggingface.co/metrics/precision) at 80% [recall](https://huggingface.co/metrics/recall) and Precision at 90% recall.
+
+## How to use 
+
+The CUAD metric takes two inputs :
+
+
+`predictions`, a list of question-answer dictionaries with the following key-values:
+- `id`: the id of the question-answer pair as given in the references.
+- `prediction_text`: a list of possible texts for the answer, as a list of strings depending on a threshold on the confidence probability of each prediction.
+
+
+`references`: a list of question-answer dictionaries with the following key-values:
+ - `id`: the id of the question-answer pair (the same as above).
+ - `answers`: a dictionary *in the CUAD dataset format* with the following keys:
+   - `text`: a list of possible texts for the answer, as a list of strings.
+   - `answer_start`: a list of start positions for the answer, as a list of ints.
+
+ Note that `answer_start` values are not taken into account to compute the metric.
+
+```python
+from datasets import load_metric
+cuad_metric = load_metric("cuad")
+predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]
+references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]
+results = cuad_metric.compute(predictions=predictions, references=references)
+```
+## Output values
+
+The output of the CUAD metric consists of a dictionary that contains one or several of the following metrics:
+
+`exact_match`: The normalized answers that exactly match the reference answer, with a range between 0.0 and 1.0 (see [exact match](https://huggingface.co/metrics/exact_match) for more information).
+
+`f1`: The harmonic mean of the precision and recall (see [F1 score](https://huggingface.co/metrics/f1) for more information). Its range is between 0.0 and 1.0 -- its lowest possible value is 0, if either the precision or the recall is 0, and its highest possible value is 1.0, which means perfect precision and recall.
+
+`aupr`: The Area Under the Precision-Recall curve, with a range between 0.0 and 1.0, with a higher value representing both high recall and high precision, and a low value representing low values for both. See the [Wikipedia article](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve) for more information.
+
+`prec_at_80_recall`: The fraction of true examples among the predicted examples at a recall rate of 80%. Its range is between 0.0 and 1.0. For more information, see [precision](https://huggingface.co/metrics/precision) and [recall](https://huggingface.co/metrics/recall).
+
+`prec_at_90_recall`: The fraction of true examples among the predicted examples at a recall rate of 90%. Its range is between 0.0 and 1.0. 
+
+
+### Values from popular papers
+The [original CUAD paper](https://arxiv.org/pdf/2103.06268.pdf) reports that a [DeBERTa model](https://huggingface.co/microsoft/deberta-base) attains
+an AUPR of 47.8%, a Precision at 80% Recall of 44.0%, and a Precision at 90% Recall of 17.8% (they do not report F1 or Exact Match separately).
+
+For more recent model performance, see the [dataset leaderboard](https://paperswithcode.com/dataset/cuad).
+
+## Examples 
+
+Maximal values :
+
+```python
+from datasets import load_metric
+cuad_metric = load_metric("cuad")
+predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]
+references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]
+results = cuad_metric.compute(predictions=predictions, references=references)
+print(results)
+{'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0}
+```
+
+Minimal values:
+
+```python
+from datasets import load_metric
+cuad_metric = load_metric("cuad")
+predictions = [{'prediction_text': ['The Company appoints the Distributor as an exclusive distributor of Products in the Market, subject to the terms and conditions of this Agreement.'], 'id': 'LIMEENERGYCO_09_09_1999-EX-10-DISTRIBUTOR AGREEMENT__Exclusivity_0'}]
+references = [{'answers': {'answer_start': [143], 'text': 'The seller'}, 'id': 'LIMEENERGYCO_09_09_1999-EX-10-DISTRIBUTOR AGREEMENT__Exclusivity_0'}]
+results = cuad_metric.compute(predictions=predictions, references=references)
+print(results)
+{'exact_match': 0.0, 'f1': 0.0, 'aupr': 0.0, 'prec_at_80_recall': 0, 'prec_at_90_recall': 0}
+```
+
+Partial match: 
+
+```python
+from datasets import load_metric
+cuad_metric = load_metric("cuad")
+predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]
+predictions = [{'prediction_text': ['The Company appoints the Distributor as an exclusive distributor of Products in the Market, subject to the terms and conditions of this Agreement.', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]
+results = cuad_metric.compute(predictions=predictions, references=references)
+print(results)
+{'exact_match': 100.0, 'f1': 50.0, 'aupr': 0.0, 'prec_at_80_recall': 0, 'prec_at_90_recall': 0}
+```
+
+## Limitations and bias
+This metric works only with datasets that have the same format as the [CUAD dataset](https://huggingface.co/datasets/cuad). The limitations of the biases of this dataset are not discussed, but could exhibit annotation bias given the homogeneity of annotators for this dataset.
+
+In terms of the metric itself, the accuracy of AUPR has been debated because its estimates are quite noisy and because of the fact that reducing the Precision-Recall Curve to a single number ignores the fact that it is about the tradeoffs between the different systems or performance points plotted and not the performance of an individual system. Reporting the original F1 and exact match scores is therefore useful to ensure a more complete representation of system performance.
+
+
+## Citation
+
+```bibtex
+@article{hendrycks2021cuad,
+      title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review},
+      author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball},
+      journal={arXiv preprint arXiv:2103.06268},
+      year={2021}
+}
+```
+    
+## Further References 
+
+- [CUAD dataset homepage](https://www.atticusprojectai.org/cuad-v1-performance-announcements)

testbed/huggingface__datasets/metrics/cuad/cuad.py

@@ -0,0 +1,115 @@
+# Copyright 2020 The HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" CUAD metric. """
+
+import datasets
+
+from .evaluate import evaluate
+
+
+_CITATION = """\
+@article{hendrycks2021cuad,
+      title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review},
+      author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball},
+      journal={arXiv preprint arXiv:2103.06268},
+      year={2021}
+}
+"""
+
+_DESCRIPTION = """
+This metric wrap the official scoring script for version 1 of the Contract
+Understanding Atticus Dataset (CUAD).
+Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510
+commercial legal contracts that have been manually labeled to identify 41 categories of important
+clauses that lawyers look for when reviewing contracts in connection with corporate transactions.
+"""
+
+_KWARGS_DESCRIPTION = """
+Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall).
+Args:
+    predictions: List of question-answers dictionaries with the following key-values:
+        - 'id': id of the question-answer pair as given in the references (see below)
+        - 'prediction_text': list of possible texts for the answer, as a list of strings
+        depending on a threshold on the confidence probability of each prediction.
+    references: List of question-answers dictionaries with the following key-values:
+        - 'id': id of the question-answer pair (see above),
+        - 'answers': a Dict in the CUAD dataset format
+            {
+                'text': list of possible texts for the answer, as a list of strings
+                'answer_start': list of start positions for the answer, as a list of ints
+            }
+            Note that answer_start values are not taken into account to compute the metric.
+Returns:
+    'exact_match': Exact match (the normalized answer exactly match the gold answer)
+    'f1': The F-score of predicted tokens versus the gold answer
+    'aupr': Area Under the Precision-Recall curve
+    'prec_at_80_recall': Precision at 80% recall
+    'prec_at_90_recall': Precision at 90% recall
+Examples:
+    >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]
+    >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]
+    >>> cuad_metric = datasets.load_metric("cuad")
+    >>> results = cuad_metric.compute(predictions=predictions, references=references)
+    >>> print(results)
+    {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0}
+"""
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class CUAD(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": {
+                        "id": datasets.Value("string"),
+                        "prediction_text": datasets.features.Sequence(datasets.Value("string")),
+                    },
+                    "references": {
+                        "id": datasets.Value("string"),
+                        "answers": datasets.features.Sequence(
+                            {
+                                "text": datasets.Value("string"),
+                                "answer_start": datasets.Value("int32"),
+                            }
+                        ),
+                    },
+                }
+            ),
+            codebase_urls=["https://www.atticusprojectai.org/cuad"],
+            reference_urls=["https://www.atticusprojectai.org/cuad"],
+        )
+
+    def _compute(self, predictions, references):
+        pred_dict = {prediction["id"]: prediction["prediction_text"] for prediction in predictions}
+        dataset = [
+            {
+                "paragraphs": [
+                    {
+                        "qas": [
+                            {
+                                "answers": [{"text": answer_text} for answer_text in ref["answers"]["text"]],
+                                "id": ref["id"],
+                            }
+                            for ref in references
+                        ]
+                    }
+                ]
+            }
+        ]
+        score = evaluate(dataset=dataset, predictions=pred_dict)
+        return score

testbed/huggingface__datasets/metrics/cuad/evaluate.py

@@ -0,0 +1,205 @@
+""" Official evaluation script for CUAD dataset. """
+
+import argparse
+import json
+import re
+import string
+import sys
+
+import numpy as np
+
+
+IOU_THRESH = 0.5
+
+
+def get_jaccard(prediction, ground_truth):
+    remove_tokens = [".", ",", ";", ":"]
+
+    for token in remove_tokens:
+        ground_truth = ground_truth.replace(token, "")
+        prediction = prediction.replace(token, "")
+
+    ground_truth, prediction = ground_truth.lower(), prediction.lower()
+    ground_truth, prediction = ground_truth.replace("/", " "), prediction.replace("/", " ")
+    ground_truth, prediction = set(ground_truth.split(" ")), set(prediction.split(" "))
+
+    intersection = ground_truth.intersection(prediction)
+    union = ground_truth.union(prediction)
+    jaccard = len(intersection) / len(union)
+    return jaccard
+
+
+def normalize_answer(s):
+    """Lower text and remove punctuation, articles and extra whitespace."""
+
+    def remove_articles(text):
+        return re.sub(r"\b(a|an|the)\b", " ", text)
+
+    def white_space_fix(text):
+        return " ".join(text.split())
+
+    def remove_punc(text):
+        exclude = set(string.punctuation)
+        return "".join(ch for ch in text if ch not in exclude)
+
+    def lower(text):
+        return text.lower()
+
+    return white_space_fix(remove_articles(remove_punc(lower(s))))
+
+
+def compute_precision_recall(predictions, ground_truths, qa_id):
+    tp, fp, fn = 0, 0, 0
+
+    substr_ok = "Parties" in qa_id
+
+    # first check if ground truth is empty
+    if len(ground_truths) == 0:
+        if len(predictions) > 0:
+            fp += len(predictions)  # false positive for each one
+    else:
+        for ground_truth in ground_truths:
+            assert len(ground_truth) > 0
+            # check if there is a match
+            match_found = False
+            for pred in predictions:
+                if substr_ok:
+                    is_match = get_jaccard(pred, ground_truth) >= IOU_THRESH or ground_truth in pred
+                else:
+                    is_match = get_jaccard(pred, ground_truth) >= IOU_THRESH
+                if is_match:
+                    match_found = True
+
+            if match_found:
+                tp += 1
+            else:
+                fn += 1
+
+        # now also get any fps by looping through preds
+        for pred in predictions:
+            # Check if there's a match. if so, don't count (don't want to double count based on the above)
+            # but if there's no match, then this is a false positive.
+            # (Note: we get the true positives in the above loop instead of this loop so that we don't double count
+            # multiple predictions that are matched with the same answer.)
+            match_found = False
+            for ground_truth in ground_truths:
+                assert len(ground_truth) > 0
+                if substr_ok:
+                    is_match = get_jaccard(pred, ground_truth) >= IOU_THRESH or ground_truth in pred
+                else:
+                    is_match = get_jaccard(pred, ground_truth) >= IOU_THRESH
+                if is_match:
+                    match_found = True
+
+            if not match_found:
+                fp += 1
+
+    precision = tp / (tp + fp) if tp + fp > 0 else np.nan
+    recall = tp / (tp + fn) if tp + fn > 0 else np.nan
+
+    return precision, recall
+
+
+def process_precisions(precisions):
+    """
+    Processes precisions to ensure that precision and recall don't both get worse.
+    Assumes the list precision is sorted in order of recalls
+    """
+    precision_best = precisions[::-1]
+    for i in range(1, len(precision_best)):
+        precision_best[i] = max(precision_best[i - 1], precision_best[i])
+    precisions = precision_best[::-1]
+    return precisions
+
+
+def get_aupr(precisions, recalls):
+    processed_precisions = process_precisions(precisions)
+    aupr = np.trapz(processed_precisions, recalls)
+    if np.isnan(aupr):
+        return 0
+    return aupr
+
+
+def get_prec_at_recall(precisions, recalls, recall_thresh):
+    """Assumes recalls are sorted in increasing order"""
+    processed_precisions = process_precisions(precisions)
+    prec_at_recall = 0
+    for prec, recall in zip(processed_precisions, recalls):
+        if recall >= recall_thresh:
+            prec_at_recall = prec
+            break
+    return prec_at_recall
+
+
+def exact_match_score(prediction, ground_truth):
+    return normalize_answer(prediction) == normalize_answer(ground_truth)
+
+
+def metric_max_over_ground_truths(metric_fn, predictions, ground_truths):
+    score = 0
+    for pred in predictions:
+        for ground_truth in ground_truths:
+            score = metric_fn(pred, ground_truth)
+            if score == 1:  # break the loop when one prediction matches the ground truth
+                break
+        if score == 1:
+            break
+    return score
+
+
+def evaluate(dataset, predictions):
+    f1 = exact_match = total = 0
+    precisions = []
+    recalls = []
+    for article in dataset:
+        for paragraph in article["paragraphs"]:
+            for qa in paragraph["qas"]:
+                total += 1
+                if qa["id"] not in predictions:
+                    message = "Unanswered question " + qa["id"] + " will receive score 0."
+                    print(message, file=sys.stderr)
+                    continue
+                ground_truths = [x["text"] for x in qa["answers"]]
+                prediction = predictions[qa["id"]]
+                precision, recall = compute_precision_recall(prediction, ground_truths, qa["id"])
+
+                precisions.append(precision)
+                recalls.append(recall)
+
+                if precision == 0 and recall == 0:
+                    f1 += 0
+                else:
+                    f1 += 2 * (precision * recall) / (precision + recall)
+
+                exact_match += metric_max_over_ground_truths(exact_match_score, prediction, ground_truths)
+
+    precisions = [x for _, x in sorted(zip(recalls, precisions))]
+    recalls.sort()
+
+    f1 = 100.0 * f1 / total
+    exact_match = 100.0 * exact_match / total
+    aupr = get_aupr(precisions, recalls)
+
+    prec_at_90_recall = get_prec_at_recall(precisions, recalls, recall_thresh=0.9)
+    prec_at_80_recall = get_prec_at_recall(precisions, recalls, recall_thresh=0.8)
+
+    return {
+        "exact_match": exact_match,
+        "f1": f1,
+        "aupr": aupr,
+        "prec_at_80_recall": prec_at_80_recall,
+        "prec_at_90_recall": prec_at_90_recall,
+    }
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluation for CUAD")
+    parser.add_argument("dataset_file", help="Dataset file")
+    parser.add_argument("prediction_file", help="Prediction File")
+    args = parser.parse_args()
+    with open(args.dataset_file) as dataset_file:
+        dataset_json = json.load(dataset_file)
+        dataset = dataset_json["data"]
+    with open(args.prediction_file) as prediction_file:
+        predictions = json.load(prediction_file)
+    print(json.dumps(evaluate(dataset, predictions)))

testbed/huggingface__datasets/metrics/exact_match/README.md

@@ -0,0 +1,103 @@
+# Metric Card for Exact Match
+
+
+## Metric Description
+A given predicted string's exact match score is 1 if it is the exact same as its reference string, and is 0 otherwise.
+
+- **Example 1**: The exact match score of prediction "Happy Birthday!" is 0, given its reference is "Happy New Year!".
+- **Example 2**: The exact match score of prediction "The Colour of Magic (1983)" is 1, given its reference is also "The Colour of Magic (1983)".
+
+The exact match score of a set of predictions is the sum of all of the individual exact match scores in the set, divided by the total number of predictions in the set.
+
+- **Example**: The exact match score of the set {Example 1, Example 2} (above) is 0.5.
+
+
+## How to Use
+At minimum, this metric takes as input predictions and references:
+```python
+>>> from datasets import load_metric
+>>> exact_match_metric = load_metric("exact_match")
+>>> results = exact_match_metric.compute(predictions=predictions, references=references)
+```
+
+### Inputs
+- **`predictions`** (`list` of `str`): List of predicted texts.
+- **`references`** (`list` of `str`): List of reference texts.
+- **`regexes_to_ignore`** (`list` of `str`): Regex expressions of characters to ignore when calculating the exact matches. Defaults to `None`. Note: the regex changes are applied before capitalization is normalized.
+- **`ignore_case`** (`bool`): If `True`, turns everything to lowercase so that capitalization differences are ignored. Defaults to `False`.
+- **`ignore_punctuation`** (`bool`): If `True`, removes punctuation before comparing strings. Defaults to `False`.
+- **`ignore_numbers`** (`bool`): If `True`, removes all digits before comparing strings. Defaults to `False`.
+
+
+### Output Values
+This metric outputs a dictionary with one value: the average exact match score.
+
+```python
+{'exact_match': 100.0}
+```
+
+This metric's range is 0-100, inclusive. Here, 0.0 means no prediction/reference pairs were matches, while 100.0 means they all were.
+
+#### Values from Popular Papers
+The exact match metric is often included in other metrics, such as SQuAD. For example, the [original SQuAD paper](https://nlp.stanford.edu/pubs/rajpurkar2016squad.pdf) reported an Exact Match score of 40.0%. They also report that the human performance Exact Match score on the dataset was 80.3%.
+
+### Examples
+Without including any regexes to ignore:
+```python
+>>> exact_match = datasets.load_metric("exact_match")
+>>> refs = ["the cat", "theater", "YELLING", "agent007"]
+>>> preds = ["cat?", "theater", "yelling", "agent"]
+>>> results = exact_match.compute(references=refs, predictions=preds)
+>>> print(round(results["exact_match"], 1))
+25.0
+```
+
+Ignoring regexes "the" and "yell", as well as ignoring case and punctuation:
+```python
+>>> exact_match = datasets.load_metric("exact_match")
+>>> refs = ["the cat", "theater", "YELLING", "agent007"]
+>>> preds = ["cat?", "theater", "yelling", "agent"]
+>>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
+>>> print(round(results["exact_match"], 1))
+50.0
+```
+Note that in the example above, because the regexes are ignored before the case is normalized, "yell" from "YELLING" is not deleted.
+
+Ignoring "the", "yell", and "YELL", as well as ignoring case and punctuation:
+```python
+>>> exact_match = datasets.load_metric("exact_match")
+>>> refs = ["the cat", "theater", "YELLING", "agent007"]
+>>> preds = ["cat?", "theater", "yelling", "agent"]
+>>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
+>>> print(round(results["exact_match"], 1))
+75.0
+```
+
+Ignoring "the", "yell", and "YELL", as well as ignoring case, punctuation, and numbers:
+```python
+>>> exact_match = datasets.load_metric("exact_match")
+>>> refs = ["the cat", "theater", "YELLING", "agent007"]
+>>> preds = ["cat?", "theater", "yelling", "agent"]
+>>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
+>>> print(round(results["exact_match"], 1))
+100.0
+```
+
+An example that includes sentences:
+```python
+>>> exact_match = datasets.load_metric("exact_match")
+>>> refs = ["The cat sat on the mat.", "Theaters are great.", "It's like comparing oranges and apples."]
+>>> preds = ["The cat sat on the mat?", "Theaters are great.", "It's like comparing apples and oranges."]
+>>> results = exact_match.compute(references=refs, predictions=preds)
+>>> print(round(results["exact_match"], 1))
+33.3
+```
+
+
+## Limitations and Bias
+This metric is limited in that it outputs the same score for something that is completely wrong as for something that is correct except for a single character. In other words, there is no award for being *almost* right.
+
+## Citation
+
+## Further References
+- Also used in the [SQuAD metric](https://github.com/huggingface/datasets/tree/main/metrics/squad) 

testbed/huggingface__datasets/metrics/exact_match/exact_match.py

@@ -0,0 +1,135 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Exact Match metric."""
+import re
+import string
+
+import numpy as np
+
+import datasets
+
+
+_DESCRIPTION = """
+Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
+"""
+
+_KWARGS_DESCRIPTION = """
+Args:
+    predictions: List of predicted texts.
+    references: List of reference texts.
+    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
+        ignore when calculating the exact matches. Note: these regexes are removed
+        from the input data before the changes based on the options below (e.g. ignore_case,
+        ignore_punctuation, ignore_numbers) are applied.
+    ignore_case: Boolean, defaults to False. If true, turns everything
+        to lowercase so that capitalization differences are ignored.
+    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
+        comparing predictions and references.
+    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
+        comparing predictions and references.
+Returns:
+    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
+Examples:
+    >>> exact_match = datasets.load_metric("exact_match")
+    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
+    >>> preds = ["cat?", "theater", "yelling", "agent"]
+    >>> results = exact_match.compute(references=refs, predictions=preds)
+    >>> print(round(results["exact_match"], 1))
+    25.0
+
+    >>> exact_match = datasets.load_metric("exact_match")
+    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
+    >>> preds = ["cat?", "theater", "yelling", "agent"]
+    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
+    >>> print(round(results["exact_match"], 1))
+    50.0
+
+
+    >>> exact_match = datasets.load_metric("exact_match")
+    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
+    >>> preds = ["cat?", "theater", "yelling", "agent"]
+    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
+    >>> print(round(results["exact_match"], 1))
+    75.0
+
+    >>> exact_match = datasets.load_metric("exact_match")
+    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
+    >>> preds = ["cat?", "theater", "yelling", "agent"]
+    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
+    >>> print(round(results["exact_match"], 1))
+    100.0
+
+    >>> exact_match = datasets.load_metric("exact_match")
+    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It's like comparing oranges and apples."]
+    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It's like comparing apples and oranges."]
+    >>> results = exact_match.compute(references=refs, predictions=preds)
+    >>> print(round(results["exact_match"], 1))
+    33.3
+
+"""
+
+_CITATION = """
+"""
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class ExactMatch(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Value("string", id="sequence"),
+                    "references": datasets.Value("string", id="sequence"),
+                }
+            ),
+            reference_urls=[],
+        )
+
+    def _compute(
+        self,
+        predictions,
+        references,
+        regexes_to_ignore=None,
+        ignore_case=False,
+        ignore_punctuation=False,
+        ignore_numbers=False,
+    ):
+        if regexes_to_ignore is not None:
+            for s in regexes_to_ignore:
+                predictions = np.array([re.sub(s, "", x) for x in predictions])
+                references = np.array([re.sub(s, "", x) for x in references])
+        else:
+            predictions = np.asarray(predictions)
+            references = np.asarray(references)
+
+        if ignore_case:
+            predictions = np.char.lower(predictions)
+            references = np.char.lower(references)
+
+        if ignore_punctuation:
+            repl_table = string.punctuation.maketrans("", "", string.punctuation)
+            predictions = np.char.translate(predictions, table=repl_table)
+            references = np.char.translate(references, table=repl_table)
+
+        if ignore_numbers:
+            repl_table = string.digits.maketrans("", "", string.digits)
+            predictions = np.char.translate(predictions, table=repl_table)
+            references = np.char.translate(references, table=repl_table)
+
+        score_list = predictions == references
+
+        return {"exact_match": np.mean(score_list) * 100}

testbed/huggingface__datasets/metrics/f1/README.md

@@ -0,0 +1,120 @@
+# Metric Card for F1
+
+
+## Metric Description
+
+The F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:
+F1 = 2 * (precision * recall) / (precision + recall)
+
+
+## How to Use
+
+At minimum, this metric requires predictions and references as input
+
+```python
+>>> f1_metric = datasets.load_metric("f1")
+>>> results = f1_metric.compute(predictions=[0, 1], references=[0, 1])
+>>> print(results)
+["{'f1': 1.0}"]
+```
+
+
+### Inputs
+- **predictions** (`list` of `int`): Predicted labels.
+- **references** (`list` of `int`): Ground truth labels.
+- **labels** (`list` of `int`): The set of labels to include when `average` is not set to `'binary'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.
+- **pos_label** (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.
+- **average** (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `'binary'`.
+    - 'binary': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.
+    - 'micro': Calculate metrics globally by counting the total true positives, false negatives and false positives.
+    - 'macro': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.
+    - 'weighted': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `'macro'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.
+    - 'samples': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).
+- **sample_weight** (`list` of `float`): Sample weights Defaults to None.
+
+
+### Output Values
+- **f1**(`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.
+
+Output Example(s):
+```python
+{'f1': 0.26666666666666666}
+```
+```python
+{'f1': array([0.8, 0.0, 0.0])}
+```
+
+This metric outputs a dictionary, with either a single f1 score, of type `float`, or an array of f1 scores, with entries of type `float`.
+
+
+#### Values from Popular Papers
+
+
+
+
+### Examples
+
+Example 1-A simple binary example
+```python
+>>> f1_metric = datasets.load_metric("f1")
+>>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])
+>>> print(results)
+{'f1': 0.5}
+```
+
+Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.
+```python
+>>> f1_metric = datasets.load_metric("f1")
+>>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)
+>>> print(round(results['f1'], 2))
+0.67
+```
+
+Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.
+```python
+>>> f1_metric = datasets.load_metric("f1")
+>>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])
+>>> print(round(results['f1'], 2))
+0.35
+```
+
+Example 4-A multiclass example, with different values for the `average` input.
+```python
+>>> predictions = [0, 2, 1, 0, 0, 1]
+>>> references = [0, 1, 2, 0, 1, 2]
+>>> results = f1_metric.compute(predictions=predictions, references=references, average="macro")
+>>> print(round(results['f1'], 2))
+0.27
+>>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")
+>>> print(round(results['f1'], 2))
+0.33
+>>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")
+>>> print(round(results['f1'], 2))
+0.27
+>>> results = f1_metric.compute(predictions=predictions, references=references, average=None)
+>>> print(results)
+{'f1': array([0.8, 0. , 0. ])}
+```
+
+
+## Limitations and Bias
+
+
+
+## Citation(s)
+```bibtex
+@article{scikit-learn,
+    title={Scikit-learn: Machine Learning in {P}ython},
+    author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
+           and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
+           and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
+           Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
+    journal={Journal of Machine Learning Research},
+    volume={12},
+    pages={2825--2830},
+    year={2011}
+}
+```
+
+
+## Further References

testbed/huggingface__datasets/metrics/f1/f1.py

@@ -0,0 +1,123 @@
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""F1 metric."""
+
+from sklearn.metrics import f1_score
+
+import datasets
+
+
+_DESCRIPTION = """
+The F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:
+F1 = 2 * (precision * recall) / (precision + recall)
+"""
+
+
+_KWARGS_DESCRIPTION = """
+Args:
+    predictions (`list` of `int`): Predicted labels.
+    references (`list` of `int`): Ground truth labels.
+    labels (`list` of `int`): The set of labels to include when `average` is not set to `'binary'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.
+    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.
+    average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `'binary'`.
+
+        - 'binary': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.
+        - 'micro': Calculate metrics globally by counting the total true positives, false negatives and false positives.
+        - 'macro': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.
+        - 'weighted': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `'macro'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.
+        - 'samples': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).
+    sample_weight (`list` of `float`): Sample weights Defaults to None.
+
+Returns:
+    f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.
+
+Examples:
+
+    Example 1-A simple binary example
+        >>> f1_metric = datasets.load_metric("f1")
+        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])
+        >>> print(results)
+        {'f1': 0.5}
+
+    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.
+        >>> f1_metric = datasets.load_metric("f1")
+        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)
+        >>> print(round(results['f1'], 2))
+        0.67
+
+    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.
+        >>> f1_metric = datasets.load_metric("f1")
+        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])
+        >>> print(round(results['f1'], 2))
+        0.35
+
+    Example 4-A multiclass example, with different values for the `average` input.
+        >>> predictions = [0, 2, 1, 0, 0, 1]
+        >>> references = [0, 1, 2, 0, 1, 2]
+        >>> results = f1_metric.compute(predictions=predictions, references=references, average="macro")
+        >>> print(round(results['f1'], 2))
+        0.27
+        >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")
+        >>> print(round(results['f1'], 2))
+        0.33
+        >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")
+        >>> print(round(results['f1'], 2))
+        0.27
+        >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)
+        >>> print(results)
+        {'f1': array([0.8, 0. , 0. ])}
+"""
+
+
+_CITATION = """
+@article{scikit-learn,
+    title={Scikit-learn: Machine Learning in {P}ython},
+    author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
+           and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
+           and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
+           Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
+    journal={Journal of Machine Learning Research},
+    volume={12},
+    pages={2825--2830},
+    year={2011}
+}
+"""
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class F1(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Sequence(datasets.Value("int32")),
+                    "references": datasets.Sequence(datasets.Value("int32")),
+                }
+                if self.config_name == "multilabel"
+                else {
+                    "predictions": datasets.Value("int32"),
+                    "references": datasets.Value("int32"),
+                }
+            ),
+            reference_urls=["https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html"],
+        )
+
+    def _compute(self, predictions, references, labels=None, pos_label=1, average="binary", sample_weight=None):
+        score = f1_score(
+            references, predictions, labels=labels, pos_label=pos_label, average=average, sample_weight=sample_weight
+        )
+        return {"f1": float(score) if score.size == 1 else score}

testbed/huggingface__datasets/metrics/frugalscore/README.md

@@ -0,0 +1,105 @@
+# Metric Card for FrugalScore
+
+
+## Metric Description
+FrugalScore is a reference-based metric for Natural Language Generation (NLG) model evaluation. It is based on a distillation approach that allows to learn a fixed, low cost version of any expensive NLG metric, while retaining most of its original performance.
+
+The FrugalScore models are obtained by continuing the pretraining of small models on a synthetic dataset constructed using summarization, backtranslation and denoising models. During the training, the small models learn the internal mapping of the expensive metric, including any similarity function.
+
+## How to use 
+
+When loading FrugalScore, you can indicate the model you wish to use to compute the score. The default model is `moussaKam/frugalscore_tiny_bert-base_bert-score`, and a full list of models can be found in the [Limitations and bias](#Limitations-and-bias) section.
+
+```python
+>>> from datasets import load_metric
+>>> frugalscore = load_metric("frugalscore", "moussaKam/frugalscore_medium_bert-base_mover-score")
+```
+
+FrugalScore calculates how good are the predictions given some references, based on a set of scores.
+
+The inputs it takes are:
+
+`predictions`: a list of strings representing the predictions to score. 
+
+`references`: a list of string representing the references for each prediction. 
+
+Its optional arguments are:
+
+`batch_size`: the batch size for predictions (default value is `32`).
+
+`max_length`: the maximum sequence length (default value is `128`).
+
+`device`: either "gpu" or "cpu" (default value is `None`). 
+
+```python
+>>> results = frugalscore.compute(predictions=['hello there', 'huggingface'], references=['hello world', 'hugging face'], batch_size=16, max_length=64, device="gpu")
+```
+
+## Output values
+
+The output of FrugalScore is a dictionary with the list of scores for each prediction-reference pair:
+```python
+{'scores': [0.6307541, 0.6449357]}
+```
+
+### Values from popular papers
+The [original FrugalScore paper](https://arxiv.org/abs/2110.08559) reported that FrugalScore-Tiny retains 97.7/94.7% of the original performance compared to [BertScore](https://huggingface.co/metrics/bertscore) while running 54 times faster and having 84 times less parameters.
+
+## Examples 
+
+Maximal values (exact match between `references` and `predictions`): 
+
+```python
+>>> from datasets import load_metric
+>>> frugalscore = load_metric("frugalscore")
+>>> results = frugalscore.compute(predictions=['hello world'], references=['hello world'])
+>>> print(results)
+{'scores': [0.9891098]}
+```
+
+Partial values: 
+
+```python
+>>> from datasets import load_metric
+>>> frugalscore = load_metric("frugalscore")
+>>> results = frugalscore.compute(predictions=['hello world'], references=['hugging face'])
+>>> print(results)
+{'scores': [0.42482382]}
+```
+
+## Limitations and bias
+
+FrugalScore is based on [BertScore](https://huggingface.co/metrics/bertscore) and [MoverScore](https://arxiv.org/abs/1909.02622), and the models used are based on the original models used for these scores.
+
+The full list of available models for FrugalScore is:
+
+| FrugalScore                                        | Student     | Teacher        | Method     |
+|----------------------------------------------------|-------------|----------------|------------|
+| [moussaKam/frugalscore_tiny_bert-base_bert-score](https://huggingface.co/moussaKam/frugalscore_tiny_bert-base_bert-score)    | BERT-tiny   | BERT-Base      | BERTScore  |
+| [moussaKam/frugalscore_small_bert-base_bert-score](https://huggingface.co/moussaKam/frugalscore_small_bert-base_bert-score)   | BERT-small  | BERT-Base      | BERTScore  |
+| [moussaKam/frugalscore_medium_bert-base_bert-score](https://huggingface.co/moussaKam/frugalscore_medium_bert-base_bert-score) | BERT-medium | BERT-Base      | BERTScore  |
+| [moussaKam/frugalscore_tiny_roberta_bert-score](https://huggingface.co/moussaKam/frugalscore_tiny_roberta_bert-score)     | BERT-tiny   | RoBERTa-Large  | BERTScore  |
+| [moussaKam/frugalscore_small_roberta_bert-score](https://huggingface.co/moussaKam/frugalscore_small_roberta_bert-score)     | BERT-small  | RoBERTa-Large  | BERTScore  |
+| [moussaKam/frugalscore_medium_roberta_bert-score](https://huggingface.co/moussaKam/frugalscore_medium_roberta_bert-score)    | BERT-medium | RoBERTa-Large  | BERTScore  |
+| [moussaKam/frugalscore_tiny_deberta_bert-score](https://huggingface.co/moussaKam/frugalscore_tiny_deberta_bert-score)      | BERT-tiny   | DeBERTa-XLarge | BERTScore  |
+| [moussaKam/frugalscore_small_deberta_bert-score](https://huggingface.co/moussaKam/frugalscore_small_deberta_bert-score)     | BERT-small  | DeBERTa-XLarge | BERTScore  |
+| [moussaKam/frugalscore_medium_deberta_bert-score](https://huggingface.co/moussaKam/frugalscore_medium_deberta_bert-score)    | BERT-medium | DeBERTa-XLarge | BERTScore  |
+| [moussaKam/frugalscore_tiny_bert-base_mover-score](https://huggingface.co/moussaKam/frugalscore_tiny_bert-base_mover-score)   | BERT-tiny   | BERT-Base      | MoverScore |
+| [moussaKam/frugalscore_small_bert-base_mover-score](https://huggingface.co/moussaKam/frugalscore_small_bert-base_mover-score)  | BERT-small  | BERT-Base      | MoverScore |
+| [moussaKam/frugalscore_medium_bert-base_mover-score](https://huggingface.co/moussaKam/frugalscore_medium_bert-base_mover-score) | BERT-medium | BERT-Base      | MoverScore |
+
+Depending on the size of the model picked, the loading time will vary: the `tiny` models will load very quickly, whereas the `medium` ones can take several minutes, depending on your Internet connection. 
+
+## Citation
+```bibtex
+@article{eddine2021frugalscore,
+  title={FrugalScore: Learning Cheaper, Lighter and Faster Evaluation Metrics for Automatic Text Generation},
+  author={Eddine, Moussa Kamal and Shang, Guokan and Tixier, Antoine J-P and Vazirgiannis, Michalis},
+  journal={arXiv preprint arXiv:2110.08559},
+  year={2021}
+}
+```
+
+## Further References
+- [Original FrugalScore code](https://github.com/moussaKam/FrugalScore)
+- [FrugalScore paper](https://arxiv.org/abs/2110.08559) 

testbed/huggingface__datasets/metrics/frugalscore/frugalscore.py

@@ -0,0 +1,116 @@
+# Copyright 2022 The HuggingFace Datasets Authors and the current metric script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""FrugalScore metric."""
+
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments
+
+import datasets
+
+
+_CITATION = """\
+@article{eddine2021frugalscore,
+  title={FrugalScore: Learning Cheaper, Lighter and Faster Evaluation Metrics for Automatic Text Generation},
+  author={Eddine, Moussa Kamal and Shang, Guokan and Tixier, Antoine J-P and Vazirgiannis, Michalis},
+  journal={arXiv preprint arXiv:2110.08559},
+  year={2021}
+}
+"""
+
+_DESCRIPTION = """\
+FrugalScore is a reference-based metric for NLG models evaluation. It is based on a distillation approach that allows to learn a fixed, low cost version of any expensive NLG metric, while retaining most of its original performance.
+"""
+
+
+_KWARGS_DESCRIPTION = """
+Calculates how good are predictions given some references, using certain scores.
+Args:
+    predictions (list of str): list of predictions to score. Each predictions
+        should be a string.
+    references (list of str): list of reference for each prediction. Each
+        reference should be a string.
+    batch_size (int): the batch size for predictions.
+    max_length (int): maximum sequence length.
+    device (str): either gpu or cpu
+Returns:
+    scores (list of int): list of scores.
+Examples:
+    >>> frugalscore = datasets.load_metric("frugalscore")
+    >>> results = frugalscore.compute(predictions=['hello there', 'huggingface'], references=['hello world', 'hugging face'])
+    >>> print([round(s, 3) for s in results["scores"]])
+    [0.631, 0.645]
+"""
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class FRUGALSCORE(datasets.Metric):
+    def _info(self):
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Value("string"),
+                    "references": datasets.Value("string"),
+                }
+            ),
+            homepage="https://github.com/moussaKam/FrugalScore",
+        )
+
+    def _download_and_prepare(self, dl_manager):
+        if self.config_name == "default":
+            checkpoint = "moussaKam/frugalscore_tiny_bert-base_bert-score"
+        else:
+            checkpoint = self.config_name
+        self.model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+        self.tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+
+    def _compute(
+        self,
+        predictions,
+        references,
+        batch_size=32,
+        max_length=128,
+        device=None,
+    ):
+        """Returns the scores"""
+        assert len(predictions) == len(
+            references
+        ), "predictions and references should have the same number of sentences."
+        if device is not None:
+            assert device in ["gpu", "cpu"], "device should be either gpu or cpu."
+        else:
+            device = "gpu" if torch.cuda.is_available() else "cpu"
+        training_args = TrainingArguments(
+            "trainer",
+            fp16=(device == "gpu"),
+            per_device_eval_batch_size=batch_size,
+            report_to="all",
+            no_cuda=(device == "cpu"),
+            log_level="warning",
+        )
+        dataset = {"sentence1": predictions, "sentence2": references}
+        raw_datasets = datasets.Dataset.from_dict(dataset)
+
+        def tokenize_function(data):
+            return self.tokenizer(
+                data["sentence1"], data["sentence2"], max_length=max_length, truncation=True, padding=True
+            )
+
+        tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
+        tokenized_datasets.remove_columns(["sentence1", "sentence2"])
+        trainer = Trainer(self.model, training_args, tokenizer=self.tokenizer)
+        predictions = trainer.predict(tokenized_datasets)
+        return {"scores": list(predictions.predictions.squeeze(-1))}

testbed/huggingface__datasets/metrics/glue/README.md

@@ -0,0 +1,105 @@
+# Metric Card for GLUE
+
+## Metric description
+This metric is used to compute the GLUE evaluation metric associated to each [GLUE dataset](https://huggingface.co/datasets/glue). 
+
+GLUE, the General Language Understanding Evaluation benchmark is a collection of resources for training, evaluating, and analyzing natural language understanding systems.
+
+## How to use 
+
+There are two steps: (1) loading the GLUE metric relevant to the subset of the GLUE dataset being used for evaluation; and (2) calculating the metric.
+
+1. **Loading the relevant GLUE metric** : the subsets of GLUE are the following: `sst2`,  `mnli`, `mnli_mismatched`, `mnli_matched`, `qnli`, `rte`, `wnli`, `cola`,`stsb`, `mrpc`, `qqp`, and `hans`.
+
+More information about the different subsets of the GLUE dataset can be found on the [GLUE dataset page](https://huggingface.co/datasets/glue).
+
+2. **Calculating the metric**: the metric takes two inputs : one list with the predictions of the model to score and one lists of references for each translation.
+
+```python
+from datasets import load_metric
+glue_metric = load_metric('glue', 'sst2')
+references = [0, 1]
+predictions = [0, 1]
+results = glue_metric.compute(predictions=predictions, references=references)
+```
+## Output values
+
+The output of the metric depends on the GLUE subset chosen, consisting of a dictionary that contains one or several of the following metrics:
+
+`accuracy`: the proportion of correct predictions among the total number of cases processed, with a range between 0 and 1 (see [accuracy](https://huggingface.co/metrics/accuracy) for more information). 
+
+`f1`: the harmonic mean of the precision and recall (see [F1 score](https://huggingface.co/metrics/f1) for more information). Its range is 0-1 -- its lowest possible value is 0, if either the precision or the recall is 0, and its highest possible value is 1.0, which means perfect precision and recall.
+
+`pearson`: a measure of the linear relationship between two datasets (see [Pearson correlation](https://huggingface.co/metrics/pearsonr) for more information). Its range is between -1 and +1, with 0 implying no correlation, and -1/+1 implying an exact linear relationship. Positive correlations imply that as x increases, so does y, whereas negative correlations imply that as x increases, y decreases. 
+
+`spearmanr`:  a nonparametric measure of the monotonicity of the relationship between two datasets(see [Spearman Correlation](https://huggingface.co/metrics/spearmanr) for more information). `spearmanr` has the same range as `pearson`.
+
+`matthews_correlation`: a measure of the quality of binary and multiclass classifications (see [Matthews Correlation](https://huggingface.co/metrics/matthews_correlation) for more information). Its range of values is between -1 and +1, where a coefficient of +1 represents a perfect prediction, 0 an average random prediction and -1 an inverse prediction.
+
+The `cola` subset returns `matthews_correlation`, the `stsb` subset returns `pearson` and `spearmanr`, the `mrpc` and `qqp` subsets return both `accuracy` and `f1`, and all other subsets of GLUE return only accuracy. 
+
+### Values from popular papers
+The [original GLUE paper](https://huggingface.co/datasets/glue) reported average scores ranging from 58 to 64%, depending on the model used (with all evaluation values scaled by 100 to make computing the average possible).
+
+For more recent model performance, see the [dataset leaderboard](https://paperswithcode.com/dataset/glue).
+
+## Examples 
+
+Maximal values for the MRPC subset (which outputs `accuracy` and `f1`):
+
+```python
+from datasets import load_metric
+glue_metric = load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'
+references = [0, 1]
+predictions = [0, 1]
+results = glue_metric.compute(predictions=predictions, references=references)
+print(results)
+{'accuracy': 1.0, 'f1': 1.0}
+```
+
+Minimal values for the STSB subset (which outputs `pearson` and `spearmanr`):
+
+```python
+from datasets import load_metric
+glue_metric = load_metric('glue', 'stsb')
+references = [0., 1., 2., 3., 4., 5.]
+predictions = [-10., -11., -12., -13., -14., -15.]
+results = glue_metric.compute(predictions=predictions, references=references)
+print(results)
+{'pearson': -1.0, 'spearmanr': -1.0}
+```
+
+Partial match for the COLA subset (which outputs `matthews_correlation`) 
+
+```python
+from datasets import load_metric
+glue_metric = load_metric('glue', 'cola')
+references = [0, 1]
+predictions = [1, 1]
+results = glue_metric.compute(predictions=predictions, references=references)
+results
+{'matthews_correlation': 0.0}
+```
+
+## Limitations and bias
+This metric works only with datasets that have the same format as the [GLUE dataset](https://huggingface.co/datasets/glue).
+
+While the GLUE dataset is meant to represent "General Language Understanding", the tasks represented in it are not necessarily representative of language understanding, and should not be interpreted as such. 
+
+Also, while the GLUE subtasks were considered challenging during its creation in 2019, they are no longer considered as such given the impressive progress made since then. A more complex (or "stickier") version of it, called [SuperGLUE](https://huggingface.co/datasets/super_glue), was subsequently created.
+
+## Citation
+
+```bibtex
+ @inproceedings{wang2019glue,
+  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
+  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
+  note={In the Proceedings of ICLR.},
+  year={2019}
+}
+```
+    
+## Further References 
+
+- [GLUE benchmark homepage](https://gluebenchmark.com/)
+- [Fine-tuning a model with the Trainer API](https://huggingface.co/course/chapter3/3?)

testbed/huggingface__datasets/metrics/glue/glue.py

@@ -0,0 +1,155 @@
+# Copyright 2020 The HuggingFace Datasets Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" GLUE benchmark metric. """
+
+from scipy.stats import pearsonr, spearmanr
+from sklearn.metrics import f1_score, matthews_corrcoef
+
+import datasets
+
+
+_CITATION = """\
+@inproceedings{wang2019glue,
+  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
+  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
+  note={In the Proceedings of ICLR.},
+  year={2019}
+}
+"""
+
+_DESCRIPTION = """\
+GLUE, the General Language Understanding Evaluation benchmark
+(https://gluebenchmark.com/) is a collection of resources for training,
+evaluating, and analyzing natural language understanding systems.
+"""
+
+_KWARGS_DESCRIPTION = """
+Compute GLUE evaluation metric associated to each GLUE dataset.
+Args:
+    predictions: list of predictions to score.
+        Each translation should be tokenized into a list of tokens.
+    references: list of lists of references for each translation.
+        Each reference should be tokenized into a list of tokens.
+Returns: depending on the GLUE subset, one or several of:
+    "accuracy": Accuracy
+    "f1": F1 score
+    "pearson": Pearson Correlation
+    "spearmanr": Spearman Correlation
+    "matthews_correlation": Matthew Correlation
+Examples:
+
+    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of ["mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]
+    >>> references = [0, 1]
+    >>> predictions = [0, 1]
+    >>> results = glue_metric.compute(predictions=predictions, references=references)
+    >>> print(results)
+    {'accuracy': 1.0}
+
+    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'
+    >>> references = [0, 1]
+    >>> predictions = [0, 1]
+    >>> results = glue_metric.compute(predictions=predictions, references=references)
+    >>> print(results)
+    {'accuracy': 1.0, 'f1': 1.0}
+
+    >>> glue_metric = datasets.load_metric('glue', 'stsb')
+    >>> references = [0., 1., 2., 3., 4., 5.]
+    >>> predictions = [0., 1., 2., 3., 4., 5.]
+    >>> results = glue_metric.compute(predictions=predictions, references=references)
+    >>> print({"pearson": round(results["pearson"], 2), "spearmanr": round(results["spearmanr"], 2)})
+    {'pearson': 1.0, 'spearmanr': 1.0}
+
+    >>> glue_metric = datasets.load_metric('glue', 'cola')
+    >>> references = [0, 1]
+    >>> predictions = [0, 1]
+    >>> results = glue_metric.compute(predictions=predictions, references=references)
+    >>> print(results)
+    {'matthews_correlation': 1.0}
+"""
+
+
+def simple_accuracy(preds, labels):
+    return float((preds == labels).mean())
+
+
+def acc_and_f1(preds, labels):
+    acc = simple_accuracy(preds, labels)
+    f1 = float(f1_score(y_true=labels, y_pred=preds))
+    return {
+        "accuracy": acc,
+        "f1": f1,
+    }
+
+
+def pearson_and_spearman(preds, labels):
+    pearson_corr = float(pearsonr(preds, labels)[0])
+    spearman_corr = float(spearmanr(preds, labels)[0])
+    return {
+        "pearson": pearson_corr,
+        "spearmanr": spearman_corr,
+    }
+
+
+@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION)
+class Glue(datasets.Metric):
+    def _info(self):
+        if self.config_name not in [
+            "sst2",
+            "mnli",
+            "mnli_mismatched",
+            "mnli_matched",
+            "cola",
+            "stsb",
+            "mrpc",
+            "qqp",
+            "qnli",
+            "rte",
+            "wnli",
+            "hans",
+        ]:
+            raise KeyError(
+                "You should supply a configuration name selected in "
+                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
+                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'
+            )
+        return datasets.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Value("int64" if self.config_name != "stsb" else "float32"),
+                    "references": datasets.Value("int64" if self.config_name != "stsb" else "float32"),
+                }
+            ),
+            codebase_urls=[],
+            reference_urls=[],
+            format="numpy",
+        )
+
+    def _compute(self, predictions, references):
+        if self.config_name == "cola":
+            return {"matthews_correlation": matthews_corrcoef(references, predictions)}
+        elif self.config_name == "stsb":
+            return pearson_and_spearman(predictions, references)
+        elif self.config_name in ["mrpc", "qqp"]:
+            return acc_and_f1(predictions, references)
+        elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
+            return {"accuracy": simple_accuracy(predictions, references)}
+        else:
+            raise KeyError(
+                "You should supply a configuration name selected in "
+                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
+                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'
+            )