remove unrelated files

.gitattributes

@@ -1,104 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-feeds_m/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-fos/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-paper_reviewer_matching/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-search/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-tweet_mentions/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-cite_count/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-feeds_1/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-feeds_title/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-high_influence_cite/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-peer_review_score_hIndex/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-pub_year/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-scidocs_view_cite_read/dataset_dict.json filter=lfs diff=lfs merge=lfs -text
-search/validation/state.json filter=lfs diff=lfs merge=lfs -text
-cite_count/validation/state.json filter=lfs diff=lfs merge=lfs -text
-feeds_title/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-fos/validation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-pub_year/validation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-pub_year/validation/state.json filter=lfs diff=lfs merge=lfs -text
-feeds_m/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-fos/train/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-fos/validation/state.json filter=lfs diff=lfs merge=lfs -text
-search/validation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-feeds_m/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-pub_year/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-search/train/state.json filter=lfs diff=lfs merge=lfs -text
-tweet_mentions/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-feeds_1/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-fos/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-fos/train/state.json filter=lfs diff=lfs merge=lfs -text
-paper_reviewer_matching/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-pub_year/train/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-tweet_mentions/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-cite_count/train/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-peer_review_score_hIndex/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-pub_year/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-search/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-search/train/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-peer_review_score_hIndex/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-pub_year/train/state.json filter=lfs diff=lfs merge=lfs -text
-cite_count/train/state.json filter=lfs diff=lfs merge=lfs -text
-cite_count/validation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-feeds_1/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-feeds_title/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-fos/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-cite_count/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-cite_count/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-paper_reviewer_matching/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-scidocs_view_cite_read/evaluation/state.json filter=lfs diff=lfs merge=lfs -text
-scidocs_view_cite_read/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text
-search/evaluation/dataset_info.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,162 +0,0 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#pdm.lock
-#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
-#   in version control.
-#   https://pdm.fming.dev/#use-with-ide
-.pdm.toml
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-huggingface_hub/
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-.idea/
-results/
-data/

BENCHMARKING.md

@@ -1,190 +0,0 @@
-## Benchmarking
-We provide our trained models on the HuggingFace models [hub](https://huggingface.co/models?search=scirepeval) to replicate the results in Table 2 from the paper.
-
-|Model|In-Train|Out-of-Train|SciDocs|Average|
-|--|--|--|--|--|
-|[SciBERT](https://huggingface.co/allenai/scibert_scivocab_uncased)|51.5|52.5|69.0|58.2|
-|[SPECTER](https://huggingface.co/allenai/specter)|54.7|57.4|89.1|68.0|
-|[SciNCL](https://huggingface.co/malteos/scincl)|55.6|57.8|**90.8**|69.0|
-|SciNCL + MTL CLS|60.1|56.6|89.6|69.3|
-|[SciNCL + MTL CTRL](https://huggingface.co/allenai/scirepeval_ctrl)|62.1|57.7|89.9|70.3|
-|[SciNCL PALs](https://huggingface.co/allenai/scirepeval_pals)|62.3|58.4|90.0|70.7|
-|SciNCL Adapters ([CLF](https://huggingface.co/allenai/scirepeval_adapters_clf), [QRY](https://huggingface.co/allenai/scirepeval_adapters_qry), [RGN](https://huggingface.co/allenai/scirepeval_adapters_rgn), [PRX](https://huggingface.co/allenai/scirepeval_adapters_prx))|61.9|**59.0**|90.3|70.9|
-|[SciNCL Adapters Fusion](https://us-east-1.console.aws.amazon.com/s3/buckets/ai2-s2-research-public?region=us-west-2&prefix=scirepeval/adapters/&showversions=false)|62.0|58.6|89.9|70.6|
-|SciNCL Adapters + MTL CTRL|**62.5**|58.9|**90.7**|**71.2**|
-
-The detailed, task-wise results for all our experiments can be found [here](https://docs.google.com/spreadsheets/d/1JMq-jR4M8KU119cvglUDmMwwzd60Z3vyvn3VqhPn9EY/view#gid=1450677429?usp=sharing).
-
-We provide a test script - [scirepeval.py](https://github.com/allenai/scirepeval/blob/main/scirepeval.py) to evaluate one of the above models or a custom trained model on all the tasks in the benchmark.
-The tasks can be configured as required in [scirepeval_tasks.jsonl](https://github.com/allenai/scirepeval/blob/main/scirepeval_tasks.jsonl).
-
-The following are used as task ids in the code and serve as either control codes or module identifiers for each task type:
-
-``TASK_IDS = {"classification": "[CLF]", "regression": "[RGN]", "proximity": "[PRX]",
-            "adhoc_search": {"query": "[QRY]", "candidates": "[PRX]"}}``
-
-Execute one of the following commands to evaluate a model on SciRepEval:
-<a name="models"></a>
-
-**Base/MTL CLS**
-```bash
-python scirepeval.py -m allenai/specter
-```
-**MTL CTRL**
-```bash
-python scirepeval.py -m allenai/scirepeval_ctrl --ctrl-tokens
-```
-**PALs**
-```bash
-python scirepeval.py --mtype pals -m allenai/scirepeval_pals
-```
-**Adapters**
-```bash
-python scirepeval.py --mtype adapters -m malteos/scincl --adapters-dir <local checkpoint directory with adapter module weights>
-									OR
-python scirepeval.py --mtype adapters -m malteos/scincl --adapters-chkpt '{"[CLF]": "allenai/scirepeval_adapters_clf", "[QRY]": "allenai/scirepeval_adapters_qry", "[RGN]": "allenai/scirepeval_adapters_rgn", "[PRX]": "allenai/scirepeval_adapters_prx"}'
-```
-
-**Fusion**
-```bash
-python scirepeval.py --mtype fusion -m <huggingface base model name/local checkpoint path> --adapters-dir <local checkpoint directory with adapter module weights> --fusion-dir <local checkpoint directory with fusion module weights>
-									OR
-python scirepeval.py --mtype fusion -m <huggingface base model name/local checkpoint path> --adapters-chkpt '{"[CLF]": "allenai/scirepeval_adapters_clf", "[QRY]": "allenai/scirepeval_adapters_qry", "[RGN]": "allenai/scirepeval_adapters_rgn", "[PRX]": "allenai/scirepeval_adapters_prx"}' --fusion-dir <local checkpoint directory with fusion module weights>
-
-```
-
-**Open AI Embeddings**
-
-We provide additional option for evaluating [Open AI](https://platform.openai.com/docs/guides/embeddings/use-cases) embeddings on SciRepEval.
-If you have an Open AI license key, set it as an environment variable.
-```bash
-export OPENAI_API_KEY=<open ai api key>
-python scirepeval.py --gpt3-model text-embedding-ada-002
-```
-
-**Instructor**
-
-You can also evaluate the [Instructor](https://instructor-embedding.github.io/) models available on Hugging Face.
-The prompts for each task format are present in [instructor.py](https://github.com/allenai/scirepeval/blob/main/evaluation/instructor.py).
-
-```bash
-python scirepeval.py --instructor -m hkunlp/instructor-large
-```
-
-
-The script generates embeddings and evaluates on each task as per the metric mentioned in the paper. By default the result report is created in `<ROOT>/scirepeval_results.json`
-
-### Sample Report
-```json
-{
-    "Biomimicry": {
-        "complete": {
-            "f1": 71.18
-        },
-        "few_shot": [
-            {
-                "sample_size": 64,
-                "results": {
-                    "f1": 38.514
-                }
-            },
-            {
-                "sample_size": 16,
-                "results": {
-                    "f1": 22.3444
-                }
-            }
-        ]
-    },
-    "DRSM": {
-        "complete": {
-            "f1_macro": 76.36
-        },
-        "few_shot": [
-            {
-                "sample_size": 64,
-                "results": {
-                    "f1_macro": 61.842000000000006
-                }
-            },
-            {
-                "sample_size": 24,
-                "results": {
-                    "f1_macro": 53.21420000000001
-                }
-            }
-        ]
-    },
-    "Feeds-1": {
-        "map": 81.03
-    },
-    "Feeds Title": {
-        "map": 78.85
-    }
-}
-```
-
-<a name="s2and"></a>
-### S2AND evaluation
-S2AND evaluation requires the data to be cached locally in a specific format. We provide a helper script to generate the document representations for S2AND before evaluating them.
-
-**Step 1**
-
-Obtain the data from AWS S3:
-```bash
-mkdir s2and && cd s2and
-aws s3 --no-sign-request sync s3://ai2-s2-research-public/scirepeval/test/s2and .
-```
-**Step 2** 
-
-Generate Embeddings for all the paper blocks. The various model parameters are same as scirepeval.py, provide those to initialize the required model type.
-```bash
-python s2and_embeddings.py --mtype <model type> -m <model checkpoint> --adapters-dir <adapters dir or chkpt> --data-dir <path to S2AND data> --suffix <suffix for embedding file name>
-```
-**Step 3**
-
-Run S2AND evaluation.
-Setup S2AND as in [repo](https://github.com/allenai/S2AND) and change the configuration to point to your data location.
-
-Run the following command:
-```bash
-python scripts/custom_block_transfer_experiment_seed_paper.py --custom_block_path <data>/blocks --experiment_name mini_customblock_phantasm_v1 --exclude_medline --emb_suffix _<suffix>.pkl
-```
-### Filtering Tasks
-#### By Name
-```python
-from scirepeval import SciRepEval
-from evaluation.encoders import Model
-
-#Base/MTL CLS
-model = Model(variant="default", base_checkpoint="allenai/specter")
-
-#MTL CTRL
-model = Model(variant="default", base_checkpoint="allenai/scirepeval_ctrl", use_ctrl_codes=True)
-
-#PALs
-model = Model(variant="pals", base_checkpoint="allenai/scirepeval_pals", all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"])
-
-#Adapters/Fusion
-adapters_dict = {"[CLF]": "allenai/scirepeval_adapters_clf", "[QRY]": "allenai/scirepeval_adapters_qry", "[RGN]": "allenai/scirepeval_adapters_rgn", "[PRX]": "allenai/scirepeval_adapters_prx"}
-model = Model(variant=<"adapters"|"fusion">, base_checkpoint="malteos/scincl", adapters_load_from=adapters_dict, all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"])
-
-#Choose the task names from scirepeval_tasks.jsonl
-evaluator = SciRepEval(task_list=["Biomimicry", "DRSM", "TREC-CoVID", "Feeds-1"])
-evaluator.evaluate(model, "scirepeval_results.json") 
-```
-
-#### By Task Type
-```python
-from scirepeval import SciRepEval
-from evaluation.encoders import Model
-
-#Create a model instance as in previous example
-model = Model(variant="default", base_checkpoint="allenai/specter")
-
-#Choose the task types from (classification, regression, proximity and adhoc_search)
-evaluator = SciRepEval(task_formats=["classification", "regression"])
-evaluator.evaluate(model, "scirepeval_results.json") 
-```
-
-

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Autonomous Vision Group 
-
-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.

LICENSE.md

@@ -1,201 +0,0 @@
-                                 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.

README.md

@@ -1,98 +1,3 @@
-# SciRepEval: A Multi-Format Benchmark for Scientific Document Representations
-This repo contains the code to train, evaluate and reproduce the representation learning models and results on the benchmark introduced in [SciRepEval](https://api.semanticscholar.org/CorpusID:254018137).
+# SuperSciRep: A Multi-Format Benchmark for Full-text Scientific Document Representations
 
-## Quick Setup
-Clone the repo and setup the environment as follows:
-```bash
-git clone git@github.com:allenai/scirepeval.git
-cd scirepeval
-conda create -n scirepeval python=3.8
-conda activate scirepeval
-pip install -r requirements.txt
-```
-## Usage
-Please refer to the following for further usage:
-
-[Training](https://github.com/allenai/scirepeval/blob/main/training/TRAINING.md) - Train multi-task/multi-format transformer models or adapter modules
-
-[Inference](https://github.com/allenai/scirepeval/blob/main/evaluation/INFERENCE.md) - Using the trained SciRepEval models to generate embeddings.
-
-[Evaluation](https://github.com/allenai/scirepeval/blob/main/evaluation/EVALUATION.md) - Evaluate trained models on custom tasks OR customize existing evaluation config for SciRepEval benchmark tasks
-
-[Benchmarking](https://github.com/allenai/scirepeval/blob/main/BENCHMARKING.md) - Simply evaluate models(pretrained from HuggingFace/local checkpoints) on SciRepEval and generate a report
-
-## Benchmark Details
-SciRepEval consists of 25 scientific document tasks to train and evaluate scientific document representation models. The tasks are divided across 4 task formats- classification **CLF**, regression **RGN**, proximity (nearest neighbors) retrieval **PRX** and ad-hoc search **SRCH**.  The table below gives a brief overview of the tasks with their HuggingFace datasets config names, if applicable. 
-The benchmark dataset can be downloaded from AWS S3 or HuggingFace as follows:
-#### AWS S3 via CLI
-```bash
-mkdir scirepeval_data && mkdir scirepeval_data/train && mkdir scirepeval_data/test && cd scirepeval_data
-aws s3 --no-sign-request sync s3://ai2-s2-research-public/scirepeval/train train
-aws s3 --no-sign-request sync s3://ai2-s2-research-public/scirepeval/test test
-```
-The AWS CLI commands can be run with the `--dryrun`  flag to list the files being copied. The entire dataset is ~24 GB in size.
-
-#### HuggingFace Datasets
-The training, validation and raw evaluation data is available at [allenai/scirepeval](https://huggingface.co/datasets/allenai/scirepeval), while the labelled test examples are available at [allenai/scirepeval_test](https://huggingface.co/datasets/allenai/scirepeval_test).
-
-```python
-import datasets
-#training/validation/eval metadata
-dataset = datasets.load_dataset(allenai/scirepeval, <hf config name>)
-
-#labelled test examples
-dataset = datasets.load_dataset(allenai/scirepeval_test, <hf config name>)
-```
-
-Since we want to evaluate document representations, every dataset consists of two parts: test metadata (text for representation generation available under allenai/scirepeval) and labelled examples (available under allenai/scirepeval_test)
-
-|Format|Name|Train|Metric|HF Config| HF Test Config|
-|--|--|--|--|--|--|
-|CLF|[MeSH Descriptors](https://www.nlm.nih.gov/databases/download/terms_and_conditions_mesh.html)|Y|F1 Macro|[mesh_descriptors](https://huggingface.co/datasets/allenai/scirepeval/viewer/mesh_descriptors)|[mesh_descriptors](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/mesh_descriptors)|
-|CLF|Fields of study|Y|F1 Macro|[fos](https://huggingface.co/datasets/allenai/scirepeval/viewer/fos)|[fos](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/fos)|
-|CLF|[Biomimicry](https://github.com/nasa-petal/PeTaL-db)|N|F1 Binary|[biomimicry](https://huggingface.co/datasets/allenai/scirepeval/viewer/biomimicry)|[biomimicry](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/biomimicry)|
-|CLF|[DRSM](https://github.com/chanzuckerberg/DRSM-corpus)|N|F1 Macro|[drsm](https://huggingface.co/datasets/allenai/scirepeval/viewer/drsm)|[drsm](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/drsm)|
-|CLF|[SciDocs-MAG](https://github.com/allenai/scidocs)|N|F1 Macro|[scidocs_mag_mesh](https://huggingface.co/datasets/allenai/scirepeval/viewer/scidocs_mag_mesh)|[scidocs_mag](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/scidocs_mag)|
-|CLF|[SciDocs-Mesh Diseases](https://github.com/allenai/scidocs)|N|F1 Macro|[scidocs_mag_mesh](https://huggingface.co/datasets/allenai/scirepeval/viewer/scidocs_mesh)|[scidocs_mesh](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/scidocs_mag_mesh)|
-|RGN|Citation Count|Y|Kendall's Tau|[cite_count](https://huggingface.co/datasets/allenai/scirepeval/viewer/cite_count)|[cite_count](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/cite_count)|
-|RGN|Year of Publication|Y|Kendall's Tau|[pub_year](https://huggingface.co/datasets/allenai/scirepeval/viewer/pub_year)|[pub_year](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/pub_year)|
-|RGN|[Peer Review Score](https://api.openreview.net)|N|Kendall's Tau|[peer_review_score_hIndex](https://huggingface.co/datasets/allenai/scirepeval/viewer/peer_review_score_hIndex)|[peer_review_score](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/peer_review_score)|
-|RGN|[Max Author hIndex](https://api.openreview.net)|N|Kendall's Tau|[peer_review_score_hIndex](https://huggingface.co/datasets/allenai/scirepeval/viewer/peer_review_score_hIndex)|[hIndex](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/hIndex)|
-|RGN|[Tweet Mentions](https://github.com/lingo-iitgn/TweetPap)|N|Kendall's Tau|[tweet_mentions](https://huggingface.co/datasets/allenai/scirepeval/viewer/tweet_mentions)|[tweet_mentions](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/tweet_mentions)|
-|PRX|Same Author Detection|Y|MAP|[same_author](https://huggingface.co/datasets/allenai/scirepeval/viewer/same_author)|[same_author](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/same_author)|
-|PRX|Highly Influential Citations|Y|MAP|[high_influence_cite](https://huggingface.co/datasets/allenai/scirepeval/viewer/high_influence_cite)|[high_influence_cite](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/high_influence_cite)|
-|PRX|Citation Prediction|Y|-|[cite_prediction](https://huggingface.co/datasets/allenai/scirepeval/viewer/cite_prediction)|-|
-|PRX|S2AND*|N|B^3 F1|-|-|
-|PRX|Paper-Reviewer Matching**|N|Precision@5,10|[paper_reviewer_matching](https://huggingface.co/datasets/allenai/scirepeval/viewer/paper_reviewer_matching)|[paper_reviewer_matching](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/paper_reviewer_matching), [reviewers](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/reviewers)|
-|PRX|Feeds-1|N|MAP|[feeds_1](https://huggingface.co/datasets/allenai/scirepeval/viewer/feeds_1)|[feeds_1](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/feeds_1)|
-|PRX|Feeds-M|N|MAP|[feeds_m](https://huggingface.co/datasets/allenai/scirepeval/viewer/feeds_m)|[feeds_m](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/feeds_m)|
-|PRX|[SciDocs-Cite](https://github.com/allenai/scidocs)|N|MAP, NDCG|[scidocs_view_cite_read](https://huggingface.co/datasets/allenai/scirepeval/viewer/scidocs_view_cite_read)|[scidocs_cite](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/scidocs_cite)|
-|PRX|[SciDocs-CoCite](https://github.com/allenai/scidocs)|N|MAP, NDCG|[scidocs_view_cite_read](https://huggingface.co/datasets/allenai/scirepeval/viewer/scidocs_view_cite_read)|[scidocs_cocite](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/scidocs_cocite)|
-|PRX|[SciDocs-CoView](https://github.com/allenai/scidocs)|N|MAP, NDCG|[scidocs_view_cite_read](https://huggingface.co/datasets/allenai/scirepeval/viewer/scidocs_view_cite_read)|[scidocs_view](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/scidocs_view)|
-|PRX|[SciDocs-CoRead](https://github.com/allenai/scidocs)|N|MAP, NDCG|[scidocs_view_cite_read](https://huggingface.co/datasets/allenai/scirepeval/viewer/scidocs_view_cite_read)|[scidocs_read](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/scidocs_read)|
-|SRCH|Search|Y|NDCG|[search](https://huggingface.co/datasets/allenai/scirepeval/viewer/search)|[search](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/search)|
-|SRCH|Feeds-Title|N|MAP|[feeds_title](https://huggingface.co/datasets/allenai/scirepeval/viewer/feeds_title)|[feeds_title](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/feeds_title)|
-|SRCH|[TREC-CoVID](https://ir.nist.gov/trec-covid/data.html)|N|NDCG|[trec_covid](https://huggingface.co/datasets/allenai/scirepeval/viewer/trec_covid)|[trec_covid](https://huggingface.co/datasets/allenai/scirepeval_test/viewer/trec_covid)|
-
-*S2AND requires the evaluation dataset in a specific format so to evaluate your model on the task please follow [these](https://github.com/allenai/scirepeval/blob/main/BENCHMARKING.md#s2and) instructions.
-
-**Combinations of multiple datasets - [1](https://mimno.infosci.cornell.edu/data/nips_reviewer_data.tar.gz), [2](https://web.archive.org/web/20211015210300/http://sifaka.cs.uiuc.edu/ir/data/review.html), [3](https://ieee-dataport.org/open-access/retrorevmatchevalicip16-retrospective-reviewer-matching-dataset-and-evaluation-ieee-icip), also dataset of papers authored by potential reviewers is required for evaluation; hence the multiple dataset configs.
-
-## License
-The aggregate benchmark is released under [ODC-BY](https://opendatacommons.org/licenses/by/1.0/) license. By downloading this data you acknowledge that you have read and agreed to all the terms in this license.
-For constituent datasets, also go through the individual licensing requirements, as applicable. 
-
-## Citation
-
-Please cite the SciRepEval work as:
-
-```bibtex
-@article{Singh2022SciRepEvalAM,
-  title={SciRepEval: A Multi-Format Benchmark for Scientific Document Representations},
-  author={Amanpreet Singh and Mike D'Arcy and Arman Cohan and Doug Downey and Sergey Feldman},
-  journal={ArXiv},
-  year={2022},
-  volume={abs/2211.13308}
-}
-```
 

adapter_fusion.py

@@ -1,105 +0,0 @@
-from typing import List, Optional, Union, Dict
-from transformers.adapters import AutoAdapterModel
-from transformers.adapters.composition import Fuse
-from abc import ABC, abstractmethod
-import torch
-import os
-
-
-class AdapterFactory:
-    @staticmethod
-    def get_adapter(checkpoint_name: str, task_ids: List[str], fuse_adapters: bool,
-                    adapters_dir: Union[str, Dict] = None):
-        print(task_ids)
-        if not fuse_adapters:
-            return AdapterEncoder(checkpoint_name, task_ids)
-        else:
-            return AdapterFusion(checkpoint_name, task_ids, adapters_dir)
-
-
-class AbstractAdapter(torch.nn.Module, ABC):
-    def __init__(self, checkpoint_name):
-        super(AbstractAdapter, self).__init__()
-        self.model = AutoAdapterModel.from_pretrained(checkpoint_name)  # checkpoint
-
-    @abstractmethod
-    def save_pretrained(self, save_path: str):
-        self.model.save_all_adapters(save_path)
-
-    def resize_token_embeddings(self, new_num_tokens: Optional[int] = None):
-        return self.model.resize_token_embeddings(new_num_tokens)
-
-
-class AdapterEncoder(AbstractAdapter):
-    def __init__(self, checkpoint_name, task_ids: List[str], load_as=None):
-        super(AdapterEncoder, self).__init__(checkpoint_name)
-        # Add a new adapter
-        for t_id in task_ids:
-            if not load_as:
-                self.model.add_adapter(t_id, config="pfeiffer")
-            else:
-                # load_as can str for a local path or dict to be loaded from adapters hub
-                if type(load_as) == str:
-                    self.model.load_adapter(f"{load_as}/{t_id}/", load_as=t_id)
-                else:
-                    self.model.load_adapter(load_as[t_id], load_as=t_id)
-        self.model.train_adapter(adapter_setup=task_ids, train_embeddings=False)
-
-    def forward(self, input_ids, attention_mask, task_id):
-        self.model.base_model.set_active_adapters(task_id)
-        return self.model(input_ids, attention_mask=attention_mask)
-
-    def save_pretrained(self, save_path: str, adapter_names: List[str] = None):
-        # self.model.save_pretrained(save_path)
-        save_path = f'{save_path}/adapters/'
-        os.makedirs(save_path, exist_ok=True)
-        if not adapter_names:
-            self.model.save_all_adapters(save_path)
-        else:
-            for a_name in adapter_names:
-                self.model.save_adapter(f"{save_path}/{a_name}/", a_name)
-
-
-class AdapterFusion(AbstractAdapter):
-    def __init__(self, checkpoint_name, task_ids: List[str], load_adapters_as: Union[str, dict], fusion_dir: str = None,
-                 inference=False):
-        super(AdapterFusion, self).__init__(checkpoint_name)
-        # Add a new adapter
-        # load_adapters_as can str for a local path with adapters and fusion dirs or dict to be loaded from adapters hub,
-        # the adapters hub version of single adapters should have the suffix _fusion
-        if not fusion_dir:
-            fusion_dir = load_adapters_as.replace("/adapters/", "") if inference and type(
-                load_adapters_as) == str else None
-        load_adapters_as = load_adapters_as.replace("fusion", "adapters") if type(
-            load_adapters_as) == str else load_adapters_as
-        for t_id in task_ids:
-            if type(load_adapters_as) == str and os.path.isdir(load_adapters_as):
-                self.model.load_adapter(f"{load_adapters_as}/{t_id}/", load_as=t_id)
-            else:
-                self.model.load_adapter(load_adapters_as[t_id], load_as=t_id)
-        self.fusion_mods_dict = dict()
-        for i, t_id in enumerate(task_ids):
-            task_fuse = Fuse(*([t_id] + task_ids[:i] + task_ids[i + 1:]))
-            self.fusion_mods_dict[t_id] = task_fuse
-            if not inference:
-                self.model.add_adapter_fusion(task_fuse)
-            else:
-                if fusion_dir:
-                    self.model.load_adapter_fusion(f"{fusion_dir}/{t_id}_fusion/")
-                else:
-                    self.model.load_adapter_fusion(f"{load_adapters_as[t_id]}_fusion")
-        self.model.train_adapter_fusion(list(self.fusion_mods_dict.values()))
-        print(self.model.active_adapters)
-        # self.model.get_input_embeddings().train()
-        # self.model.train_adapter(adapter_setup=task_ids, train_embeddings=True)
-
-    def forward(self, input_ids, attention_mask, task_id):
-        self.model.base_model.set_active_adapters(self.fusion_mods_dict[task_id])
-        return self.model(input_ids, attention_mask=attention_mask)
-
-    def save_pretrained(self, save_path: str):
-        # self.model.save_pretrained(save_path)
-        from pathlib import Path
-        Path(save_path).mkdir(parents=True, exist_ok=True)
-        for t_id, t_fuse in self.fusion_mods_dict.items():
-            self.model.save_adapter_fusion(f'{save_path}/{t_id}_fusion/', t_fuse)

benchmark.sh

@@ -1,2 +0,0 @@
-python scirepeval.py --tasks-config full_scirepeval_tasks.jsonl -m allenai/longformer-base-4096 --batch-size 1 --output longformer_results.json --document
-python scirepeval.py --tasks-config full_scirepeval_tasks.jsonl -m /home/haoyu/code/academic-budget-LMs/logs/htrans/runs/2023-05-02_23-18-37/huggingface_saved --batch-size 2 --output 32_32_8_6_results.json --htrans --document

bert_pals.py

@@ -1,861 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The Google AI Language Team Authors and The HugginFace Inc. team.
-#
-# 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.
-"""PyTorch BERT model."""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import copy
-import json
-import math
-from typing import List, Optional
-
-import os
-import six
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn import CrossEntropyLoss, MSELoss
-from torch.nn.parameter import Parameter
-from transformers.models.bert.modeling_bert import BertPreTrainedModel
-from transformers.models.bert.configuration_bert import BertConfig
-
-
-def gelu(x):
-    """Implementation of the gelu activation function.
-        For information: OpenAI GPT's gelu is slightly different (and gives slightly different results):
-        0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))
-    """
-    return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
-
-
-class BertPalConfig(BertConfig):
-    """Configuration class to store the configuration of a `BertModel`.
-    """
-
-    def __init__(self, vocab_size, hidden_size=768, num_hidden_layers=12, num_attention_heads=12,
-                 intermediate_size=3072, hidden_act="gelu", hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1,
-                 max_position_embeddings=512, type_vocab_size=16, initializer_range=0.02, pals=False, mult=False,
-                 top=False, lhuc=False, houlsby=False, bert_lay_top=False, num_tasks=1, extra_dim=None,
-                 hidden_size_aug=204, **kwargs):
-        """Constructs BertConfig.
-
-        Args:
-            vocab_size: Vocabulary size of `inputs_ids` in `BertModel`.
-            hidden_size: Size of the encoder layers and the pooler layer.
-            num_hidden_layers: Number of hidden layers in the Transformer encoder.
-            num_attention_heads: Number of attention heads for each attention layer in
-                the Transformer encoder.
-            intermediate_size: The size of the "intermediate" (i.e., feed-forward)
-                layer in the Transformer encoder.
-            hidden_act: The non-linear activation function (function or string) in the
-                encoder and pooler.
-            hidden_dropout_prob: The dropout probabilitiy for all fully connected
-                layers in the embeddings, encoder, and pooler.
-            attention_probs_dropout_prob: The dropout ratio for the attention
-                probabilities.
-            max_position_embeddings: The maximum sequence length that this model might
-                ever be used with. Typically set this to something large just in case
-                (e.g., 512 or 1024 or 2048).
-            type_vocab_size: The vocabulary size of the `token_type_ids` passed into
-                `BertModel`.
-            initializer_range: The sttdev of the truncated_normal_initializer for
-                initializing all weight matrices.
-        """
-        super().__init__(vocab_size, hidden_size, num_hidden_layers, num_attention_heads, intermediate_size, hidden_act,
-                         hidden_dropout_prob, attention_probs_dropout_prob, max_position_embeddings, type_vocab_size,
-                         initializer_range, **kwargs)
-        self.vocab_size = vocab_size
-        self.hidden_size = hidden_size
-        self.num_hidden_layers = num_hidden_layers
-        self.num_attention_heads = num_attention_heads
-        self.hidden_act = hidden_act
-        self.intermediate_size = intermediate_size
-        self.hidden_dropout_prob = hidden_dropout_prob
-        self.attention_probs_dropout_prob = attention_probs_dropout_prob
-        self.max_position_embeddings = max_position_embeddings
-        self.type_vocab_size = type_vocab_size
-        self.initializer_range = initializer_range
-        self.hidden_size_aug = hidden_size_aug
-        self.pals = pals
-        self.extra_dim = extra_dim
-        self.houlsby = houlsby
-        self.mult = mult
-        self.top = top
-        self.bert_lay_top = bert_lay_top
-        self.lhuc = lhuc
-        self.num_tasks = num_tasks
-
-    @classmethod
-    def from_json_file(cls, json_file):
-        """Constructs a `BertConfig` from a json file of parameters."""
-        with open(json_file, "r") as reader:
-            text = reader.read()
-        return cls.from_dict(json.loads(text))
-
-    def to_dict(self):
-        """Serializes this instance to a Python dictionary."""
-        output = copy.deepcopy(self.__dict__)
-        return output
-
-    @classmethod
-    def from_dict(cls, json_object):
-        """Constructs a `BertConfig` from a Python dictionary of parameters."""
-        config = BertPalConfig(vocab_size=None)
-        for (key, value) in six.iteritems(json_object):
-            config.__dict__[key] = value
-        return config
-
-    def to_json_string(self, use_diff: bool = True):
-        """Serializes this instance to a JSON string."""
-        return json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n"
-
-
-class BERTLayerNorm(nn.Module):
-    def __init__(self, config, multi_params=None, variance_epsilon=1e-12):
-        """Construct a layernorm module in the TF style (epsilon inside the square root).
-        """
-        super(BERTLayerNorm, self).__init__()
-        if multi_params is not None:
-            self.weight = nn.Parameter(torch.ones(config.hidden_size_aug))
-            self.bias = nn.Parameter(torch.zeros(config.hidden_size_aug))
-        else:
-            self.weight = nn.Parameter(torch.ones(config.hidden_size))
-            self.bias = nn.Parameter(torch.zeros(config.hidden_size))
-        self.variance_epsilon = variance_epsilon
-
-    def forward(self, x):
-        u = x.mean(-1, keepdim=True)
-        s = (x - u).pow(2).mean(-1, keepdim=True)
-        x = (x - u) / torch.sqrt(s + self.variance_epsilon)
-        return self.weight * x + self.bias
-
-
-class BERTEmbeddings(nn.Module):
-    def __init__(self, config):
-        super(BERTEmbeddings, self).__init__()
-        """Construct the embedding module from word, position and token_type embeddings.
-        """
-        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size)
-        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
-        self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
-
-        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
-        # any TensorFlow checkpoint file
-        self.LayerNorm = BERTLayerNorm(config)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-    def forward(self, input_ids, token_type_ids=None):
-        seq_length = input_ids.size(1)
-        position_ids = torch.arange(seq_length, dtype=torch.long, device=input_ids.device)
-        position_ids = position_ids.unsqueeze(0).expand_as(input_ids)
-        if token_type_ids is None:
-            token_type_ids = torch.zeros_like(input_ids)
-
-        words_embeddings = self.word_embeddings(input_ids)
-        position_embeddings = self.position_embeddings(position_ids)
-        token_type_embeddings = self.token_type_embeddings(token_type_ids)
-
-        embeddings = words_embeddings + position_embeddings + token_type_embeddings
-        embeddings = self.LayerNorm(embeddings)
-        embeddings = self.dropout(embeddings)
-        return embeddings
-
-
-class BERTSelfAttention(nn.Module):
-    def __init__(self, config, multi_params=None):
-        super(BERTSelfAttention, self).__init__()
-        if config.hidden_size % config.num_attention_heads != 0:
-            raise ValueError(
-                "The hidden size (%d) is not a multiple of the number of attention "
-                "heads (%d)" % (config.hidden_size, config.num_attention_heads))
-        if multi_params is not None:
-            self.num_attention_heads = multi_params
-            self.attention_head_size = int(config.hidden_size_aug / self.num_attention_heads)
-            self.all_head_size = self.num_attention_heads * self.attention_head_size
-            hidden_size = config.hidden_size_aug
-        else:
-            self.num_attention_heads = config.num_attention_heads
-            self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
-            self.all_head_size = self.num_attention_heads * self.attention_head_size
-            hidden_size = config.hidden_size
-
-        self.query = nn.Linear(hidden_size, self.all_head_size)
-        self.key = nn.Linear(hidden_size, self.all_head_size)
-        self.value = nn.Linear(hidden_size, self.all_head_size)
-
-        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
-
-    def transpose_for_scores(self, x):
-        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
-        x = x.view(*new_x_shape)
-        return x.permute(0, 2, 1, 3)
-
-    def forward(self, hidden_states, attention_mask):
-        mixed_query_layer = self.query(hidden_states)
-        mixed_key_layer = self.key(hidden_states)
-        mixed_value_layer = self.value(hidden_states)
-
-        query_layer = self.transpose_for_scores(mixed_query_layer)
-        key_layer = self.transpose_for_scores(mixed_key_layer)
-        value_layer = self.transpose_for_scores(mixed_value_layer)
-
-        # Take the dot product between "query" and "key" to get the raw attention scores.
-        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
-        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
-        # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
-        attention_scores = attention_scores + attention_mask
-
-        # Normalize the attention scores to probabilities.
-        attention_probs = nn.Softmax(dim=-1)(attention_scores)
-
-        # This is actually dropping out entire tokens to attend to, which might
-        # seem a bit unusual, but is taken from the original Transformer paper.
-        attention_probs = self.dropout(attention_probs)
-
-        context_layer = torch.matmul(attention_probs, value_layer)
-        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
-        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
-        context_layer = context_layer.view(*new_context_layer_shape)
-        return context_layer
-
-
-class BERTMultSelfOutput(nn.Module):
-    def __init__(self, config, multi_params=None):
-        super(BERTMultSelfOutput, self).__init__()
-        self.LayerNorm = BERTLayerNorm(config, multi_params)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-    def forward(self, hidden_states, input_tensor):
-        hidden_states = self.dropout(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states + input_tensor)
-        return hidden_states
-
-
-class BERTSelfOutput(nn.Module):
-    def __init__(self, config, multi_params=None, houlsby=False):
-        super(BERTSelfOutput, self).__init__()
-        if houlsby:
-            multi = BERTLowRank(config)
-            self.multi_layers = nn.ModuleList([copy.deepcopy(multi) for _ in range(config.num_tasks)])
-        if multi_params is not None:
-            self.dense = nn.Linear(config.hidden_size_aug, config.hidden_size_aug)
-        else:
-            self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        self.LayerNorm = BERTLayerNorm(config, multi_params)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.houlsby = houlsby
-
-    def forward(self, hidden_states, input_tensor, attention_mask=None, i=0):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        if self.houlsby:
-            hidden_states = hidden_states + self.multi_layers[i](hidden_states, attention_mask)
-        hidden_states = self.LayerNorm(hidden_states + input_tensor)
-        return hidden_states
-
-
-class BERTAttention(nn.Module):
-    def __init__(self, config, multi_params=None, houlsby=False):
-        super(BERTAttention, self).__init__()
-        self.self = BERTSelfAttention(config, multi_params)
-        self.output = BERTSelfOutput(config, multi_params, houlsby)
-
-    def forward(self, input_tensor, attention_mask, i=0):
-        self_output = self.self(input_tensor, attention_mask)
-        attention_output = self.output(self_output, input_tensor, attention_mask, i=i)
-        return attention_output
-
-
-class BERTPals(nn.Module):
-    def __init__(self, config, extra_dim=None):
-        super(BERTPals, self).__init__()
-        # Encoder and decoder matrices project down to the smaller dimension
-        self.aug_dense = nn.Linear(config.hidden_size, config.hidden_size_aug)
-        self.aug_dense2 = nn.Linear(config.hidden_size_aug, config.hidden_size)
-        # Attention without the final matrix multiply.
-        self.attn = BERTSelfAttention(config, 6)
-        self.config = config
-        self.hidden_act_fn = gelu
-
-    def forward(self, hidden_states, attention_mask=None):
-        hidden_states_aug = self.aug_dense(hidden_states)
-        hidden_states_aug = self.attn(hidden_states_aug, attention_mask)
-        hidden_states = self.aug_dense2(hidden_states_aug)
-        hidden_states = self.hidden_act_fn(hidden_states)
-        return hidden_states
-
-
-class BERTLowRank(nn.Module):
-    def __init__(self, config, extra_dim=None):
-        super(BERTLowRank, self).__init__()
-        # Encoder and decoder matrices project down to the smaller dimension
-        if config.extra_dim:
-            self.aug_dense = nn.Linear(config.hidden_size, config.extra_dim)
-            self.aug_dense2 = nn.Linear(config.extra_dim, config.hidden_size)
-        else:
-            self.aug_dense = nn.Linear(config.hidden_size, config.hidden_size_aug)
-            self.aug_dense2 = nn.Linear(config.hidden_size_aug, config.hidden_size)
-        self.config = config
-        self.hidden_act_fn = gelu
-
-    def forward(self, hidden_states, attention_mask=None):
-        hidden_states_aug = self.aug_dense(hidden_states)
-        hidden_states_aug = self.hidden_act_fn(hidden_states_aug)
-        hidden_states = self.aug_dense2(hidden_states_aug)
-        return hidden_states
-
-
-class BERTIntermediate(nn.Module):
-    def __init__(self, config):
-        super(BERTIntermediate, self).__init__()
-        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
-        self.config = config
-        self.intermediate_act_fn = gelu
-
-    def forward(self, hidden_states):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.intermediate_act_fn(hidden_states)
-        return hidden_states
-
-
-class BERTLhuc(nn.Module):
-    def __init__(self, config):
-        super(BERTLhuc, self).__init__()
-        self.lhuc = Parameter(torch.zeros(config.hidden_size))
-
-    def forward(self, hidden_states):
-        hidden_states = hidden_states * 2. * nn.functional.sigmoid(self.lhuc)
-        return hidden_states
-
-
-class BERTOutput(nn.Module):
-    def __init__(self, config, houlsby=False):
-        super(BERTOutput, self).__init__()
-        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
-        self.LayerNorm = BERTLayerNorm(config)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        if houlsby:
-            if config.pals:
-                multi = BERTPals(config)
-            else:
-                multi = BERTLowRank(config)
-            self.multi_layers = nn.ModuleList([copy.deepcopy(multi) for _ in range(config.num_tasks)])
-        self.houlsby = houlsby
-
-    def forward(self, hidden_states, input_tensor, attention_mask=None, i=0):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        if self.houlsby:
-            hidden_states = hidden_states + self.multi_layers[i](input_tensor, attention_mask)
-        hidden_states = self.LayerNorm(hidden_states + input_tensor)
-        return hidden_states
-
-
-class BERTLayer(nn.Module):
-    def __init__(self, config, mult=False, houlsby=False):
-        super(BERTLayer, self).__init__()
-        self.attention = BERTAttention(config, houlsby=houlsby)
-        self.intermediate = BERTIntermediate(config)
-        self.output = BERTOutput(config, houlsby=houlsby)
-        if config.lhuc:
-            lhuc = BERTLhuc(config)
-            self.multi_lhuc = nn.ModuleList([copy.deepcopy(lhuc) for _ in range(config.num_tasks)])
-        if mult:
-            if config.pals:
-                multi = BERTPals(config)
-            else:
-                multi = BERTLowRank(config)
-            self.multi_layers = nn.ModuleList([copy.deepcopy(multi) for _ in range(config.num_tasks)])
-        self.mult = mult
-        self.lhuc = config.lhuc
-        self.houlsby = houlsby
-
-    def forward(self, hidden_states, attention_mask, i=0):
-        attention_output = self.attention(hidden_states, attention_mask, i)
-        intermediate_output = self.intermediate(attention_output)
-        if self.lhuc and not self.mult:
-            layer_output = self.output(intermediate_output, attention_output)
-            layer_output = self.multi_lhuc[i](layer_output)
-        elif self.mult:
-            extra = self.multi_layers[i](hidden_states, attention_mask)
-            if self.lhuc:
-                extra = self.multi_lhuc[i](extra)
-            layer_output = self.output(intermediate_output, attention_output + extra)
-        elif self.houlsby:
-            layer_output = self.output(intermediate_output, attention_output, attention_mask, i)
-        else:
-            layer_output = self.output(intermediate_output, attention_output)
-        return layer_output
-
-
-class BERTEncoder(nn.Module):
-    def __init__(self, config):
-        super(BERTEncoder, self).__init__()
-        self.config = config
-        if config.houlsby:
-            # Adjust line below to add PALs etc. to different layers. True means add a PAL.
-            self.multis = [True if i < 999 else False for i in range(config.num_hidden_layers)]
-            self.layer = nn.ModuleList([BERTLayer(config, houlsby=mult) for mult in self.multis])
-        elif config.mult:
-            # Adjust line below to add PALs etc. to different layers. True means add a PAL.
-            self.multis = [True if i < 999 else False for i in range(config.num_hidden_layers)]
-            self.layer = nn.ModuleList([BERTLayer(config, mult=mult) for mult in self.multis])
-        else:
-            layer = BERTLayer(config)
-            self.layer = nn.ModuleList([copy.deepcopy(layer) for _ in range(config.num_hidden_layers)])
-
-        if config.top:
-            if config.bert_lay_top:
-                multi = BERTLayer(config)
-            else:
-                # Projection matrices and attention for adding to the top.
-                mult_dense = nn.Linear(config.hidden_size, config.hidden_size_aug)
-                self.mult_dense = nn.ModuleList([copy.deepcopy(mult_dense) for _ in range(config.num_tasks)])
-                mult_dense2 = nn.Linear(config.hidden_size_aug, config.hidden_size)
-                self.mult_dense2 = nn.ModuleList([copy.deepcopy(mult_dense2) for _ in range(config.num_tasks)])
-                multi = nn.ModuleList([copy.deepcopy(BERTAttention(config, 12)) for _ in range(6)])
-
-            self.multi_layers = nn.ModuleList([copy.deepcopy(multi) for _ in range(config.num_tasks)])
-            self.gelu = gelu
-
-        if config.mult and config.pals:
-            dense = nn.Linear(config.hidden_size, config.hidden_size_aug)
-            # Shared encoder and decoder across layers
-            self.mult_aug_dense = nn.ModuleList([copy.deepcopy(dense) for _ in range(config.num_tasks)])
-            dense2 = nn.Linear(config.hidden_size_aug, config.hidden_size)
-            self.mult_aug_dense2 = nn.ModuleList([copy.deepcopy(dense2) for _ in range(config.num_tasks)])
-            for l, layer in enumerate(self.layer):
-                if self.multis[l]:
-                    for i, lay in enumerate(layer.multi_layers):
-                        lay.aug_dense = self.mult_aug_dense[i]
-                        lay.aug_dense2 = self.mult_aug_dense2[i]
-        if config.houlsby and config.pals:
-            dense = nn.Linear(config.hidden_size, config.hidden_size_aug)
-            # Shared encoder and decoder across layers
-            self.mult_aug_dense = nn.ModuleList([copy.deepcopy(dense) for _ in range(config.num_tasks)])
-            dense2 = nn.Linear(config.hidden_size_aug, config.hidden_size)
-            self.mult_aug_dense2 = nn.ModuleList([copy.deepcopy(dense2) for _ in range(config.num_tasks)])
-            dense3 = nn.Linear(config.hidden_size, config.hidden_size_aug)
-            for l, layer in enumerate(self.layer):
-                if self.multis[l]:
-                    for i, lay in enumerate(layer.output.multi_layers):
-                        lay.aug_dense = self.mult_aug_dense[i]
-                        lay.aug_dense2 = self.mult_aug_dense2[i]
-
-    def forward(self, hidden_states, attention_mask, i=0):
-        all_encoder_layers = []
-        for layer_module in self.layer:
-            hidden_states = layer_module(hidden_states, attention_mask, i)
-            all_encoder_layers.append(hidden_states)
-        if self.config.top:
-            if self.config.bert_lay_top:
-                all_encoder_layers[-1] = self.multi_layers[i](hidden_states, attention_mask)
-            else:
-                hidden_states = self.mult_dense[i](hidden_states)
-                for lay in self.multi_layers[i]:
-                    hidden_states = lay(hidden_states, attention_mask)
-                all_encoder_layers[-1] = self.mult_dense2[i](hidden_states)
-        return all_encoder_layers
-
-
-class BERTPooler(nn.Module):
-    def __init__(self, config):
-        super(BERTPooler, self).__init__()
-
-        dense = nn.Linear(config.hidden_size, config.hidden_size)
-        self.activation = nn.Tanh()
-        self.pool = False
-        if self.pool:
-            self.mult_dense_layers = nn.ModuleList([copy.deepcopy(dense) for _ in range(config.num_tasks)])
-        else:
-            self.dense = dense
-        self.mult = config.mult
-        self.top = config.top
-
-    def forward(self, hidden_states, i=0):
-        # We "pool" the model by simply taking the hidden state corresponding
-        # to the first token.
-        first_token_tensor = hidden_states[:, 0]
-        if (self.mult or self.top) and self.pool:
-            pooled_output = self.mult_dense_layers[i](first_token_tensor)
-        else:
-            pooled_output = self.dense(first_token_tensor)
-        pooled_output = self.activation(pooled_output)
-        return pooled_output
-
-
-class BertModel(BertPreTrainedModel):
-    """BERT model ("Bidirectional Embedding Representations from a Transformer").
-
-    Example usage:
-    ```python
-    # Already been converted into WordPiece token ids
-    input_ids = torch.LongTensor([[31, 51, 99], [15, 5, 0]])
-    input_mask = torch.LongTensor([[1, 1, 1], [1, 1, 0]])
-    token_type_ids = torch.LongTensor([[0, 0, 1], [0, 2, 0]])
-
-    config = modeling.BertConfig(vocab_size=32000, hidden_size=512,
-        num_hidden_layers=8, num_attention_heads=6, intermediate_size=1024)
-
-    model = modeling.BertModel(config=config)
-    all_encoder_layers, pooled_output = model(input_ids, token_type_ids, input_mask)
-    ```
-    """
-
-    def __init__(self, config: BertPalConfig):
-        """Constructor for BertModel.
-
-        Args:
-            config: `BertConfig` instance.
-        """
-        super(BertModel, self).__init__(config)
-        self.embeddings = BERTEmbeddings(config)
-        self.encoder = BERTEncoder(config)
-        self.pooler = BERTPooler(config)
-
-    def forward(self, input_ids, token_type_ids=None, attention_mask=None, i=0):
-        if attention_mask is None:
-            attention_mask = torch.ones_like(input_ids)
-        if token_type_ids is None:
-            token_type_ids = torch.zeros_like(input_ids)
-
-        # We create a 3D attention mask from a 2D tensor mask.
-        # Sizes are [batch_size, 1, 1, from_seq_length]
-        # So we can broadcast to [batch_size, num_heads, to_seq_length, from_seq_length]
-        # this attention mask is more simple than the triangular masking of causal attention
-        # used in OpenAI GPT, we just need to prepare the broadcast dimension here.
-        extended_attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)
-
-        # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
-        # masked positions, this operation will create a tensor which is 0.0 for
-        # positions we want to attend and -10000.0 for masked positions.
-        # Since we are adding it to the raw scores before the softmax, this is
-        # effectively the same as removing these entirely.
-        extended_attention_mask = extended_attention_mask.float()
-        extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
-
-        embedding_output = self.embeddings(input_ids, token_type_ids)
-        all_encoder_layers = self.encoder(embedding_output, extended_attention_mask, i)
-        sequence_output = all_encoder_layers[-1]
-        pooled_output = self.pooler(sequence_output, i)
-        return all_encoder_layers, pooled_output
-
-    def get_input_embeddings(self):
-        return self.embeddings.word_embeddings
-
-    def set_input_embeddings(self, value):
-        self.embeddings.word_embeddings = value
-
-
-class BertForMultiTask(nn.Module):
-    """BERT model for classification or regression on GLUE tasks (STS-B is treated as a regression task).
-    This module is composed of the BERT model with a linear layer on top of
-    the pooled output.
-
-    ```
-    """
-
-    def __init__(self, config, tasks):
-        super(BertForMultiTask, self).__init__()
-        self.bert = BertModel(config)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.classifier = nn.ModuleList([nn.Linear(config.hidden_size, num_labels)
-                                         for i, num_labels in enumerate(tasks)])
-
-        def init_weights(module):
-            if isinstance(module, (nn.Linear, nn.Embedding)):
-                # Slightly different from the TF version which uses truncated_normal for initialization
-                # cf https://github.com/pytorch/pytorch/pull/5617
-                module.weight.data.normal_(mean=0.0, std=config.initializer_range)
-            elif isinstance(module, BERTLayerNorm):
-                module.beta.data.normal_(mean=0.0, std=config.initializer_range)
-                module.gamma.data.normal_(mean=0.0, std=config.initializer_range)
-            if isinstance(module, nn.Linear):
-                if module.bias is not None:
-                    module.bias.data.zero_()
-
-        self.apply(init_weights)
-
-    def forward(self, input_ids, token_type_ids, attention_mask, task_id, name='cola', labels=None):
-        _, pooled_output = self.bert(input_ids, token_type_ids, attention_mask, task_id)
-        pooled_output = self.dropout(pooled_output)
-        logits = self.classifier[task_id](pooled_output)
-
-        if labels is not None and name != 'sts':
-            loss_fct = CrossEntropyLoss()
-            loss = loss_fct(logits, labels)
-            return loss, logits
-        # STS is a regression task.
-        elif labels is not None and name == 'sts':
-            loss_fct = MSELoss()
-            loss = loss_fct(logits, labels.unsqueeze(1))
-            return loss, logits
-        else:
-            return logits
-
-
-class BertForSequenceClassification(nn.Module):
-    """BERT model for classification.
-    This module is composed of the BERT model with a linear layer on top of
-    the pooled output.
-
-    Example usage:
-    ```python
-    # Already been converted into WordPiece token ids
-    input_ids = torch.LongTensor([[31, 51, 99], [15, 5, 0]])
-    input_mask = torch.LongTensor([[1, 1, 1], [1, 1, 0]])
-    token_type_ids = torch.LongTensor([[0, 0, 1], [0, 2, 0]])
-
-    config = BertConfig(vocab_size=32000, hidden_size=512,
-        num_hidden_layers=8, num_attention_heads=6, intermediate_size=1024)
-
-    num_labels = 2
-
-    model = BertForSequenceClassification(config, num_labels)
-    logits = model(input_ids, token_type_ids, input_mask)
-    ```
-    """
-
-    def __init__(self, config, num_labels):
-        super(BertForSequenceClassification, self).__init__()
-        self.bert = BertModel(config)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.classifier = nn.Linear(config.hidden_size, num_labels)
-
-        def init_weights(module):
-            if isinstance(module, (nn.Linear, nn.Embedding)):
-                # Slightly different from the TF version which uses truncated_normal for initialization
-                # cf https://github.com/pytorch/pytorch/pull/5617
-                module.weight.data.normal_(mean=0.0, std=config.initializer_range)
-            elif isinstance(module, BERTLayerNorm):
-                module.beta.data.normal_(mean=0.0, std=config.initializer_range)
-                module.gamma.data.normal_(mean=0.0, std=config.initializer_range)
-            if isinstance(module, nn.Linear):
-                if module.bias is not None:
-                    module.bias.data.zero_()
-
-        self.apply(init_weights)
-
-    def forward(self, input_ids, token_type_ids, attention_mask, labels=None):
-        _, pooled_output = self.bert(input_ids, token_type_ids, attention_mask)
-        pooled_output = self.dropout(pooled_output)
-        logits = self.classifier(pooled_output)
-
-        if labels is not None:
-            loss_fct = CrossEntropyLoss()
-            loss = loss_fct(logits, labels)
-            return loss, logits
-        else:
-            return logits
-
-
-class BertForQuestionAnswering(nn.Module):
-    """BERT model for Question Answering (span extraction).
-    This module is composed of the BERT model with a linear layer on top of
-    the sequence output that computes start_logits and end_logits
-
-    Example usage:
-    ```python
-    # Already been converted into WordPiece token ids
-    input_ids = torch.LongTensor([[31, 51, 99], [15, 5, 0]])
-    input_mask = torch.LongTensor([[1, 1, 1], [1, 1, 0]])
-    token_type_ids = torch.LongTensor([[0, 0, 1], [0, 2, 0]])
-
-    config = BertConfig(vocab_size=32000, hidden_size=512,
-        num_hidden_layers=8, num_attention_heads=6, intermediate_size=1024)
-
-    model = BertForQuestionAnswering(config)
-    start_logits, end_logits = model(input_ids, token_type_ids, input_mask)
-    ```
-    """
-
-    def __init__(self, config):
-        super(BertForQuestionAnswering, self).__init__()
-        self.bert = BertModel(config)
-        # TODO check with Google if it's normal there is no dropout on the token classifier of SQuAD in the TF version
-        # self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.qa_outputs = nn.Linear(config.hidden_size, 2)
-
-        def init_weights(module):
-            if isinstance(module, (nn.Linear, nn.Embedding)):
-                # Slightly different from the TF version which uses truncated_normal for initialization
-                # cf https://github.com/pytorch/pytorch/pull/5617
-                module.weight.data.normal_(mean=0.0, std=config.initializer_range)
-            elif isinstance(module, BERTLayerNorm):
-                module.beta.data.normal_(mean=0.0, std=config.initializer_range)
-                module.gamma.data.normal_(mean=0.0, std=config.initializer_range)
-            if isinstance(module, nn.Linear):
-                module.bias.data.zero_()
-
-        self.apply(init_weights)
-
-    def forward(self, input_ids, token_type_ids, attention_mask, start_positions=None, end_positions=None):
-        all_encoder_layers, _ = self.bert(input_ids, token_type_ids, attention_mask)
-        sequence_output = all_encoder_layers[-1]
-        logits = self.qa_outputs(sequence_output)
-        start_logits, end_logits = logits.split(1, dim=-1)
-        start_logits = start_logits.squeeze(-1)
-        end_logits = end_logits.squeeze(-1)
-
-        if start_positions is not None and end_positions is not None:
-            # If we are on multi-GPU, split add a dimension - if not this is a no-op
-            start_positions = start_positions.squeeze(-1)
-            end_positions = end_positions.squeeze(-1)
-            # sometimes the start/end positions are outside our model inputs, we ignore these terms
-            ignored_index = start_logits.size(1)
-            start_positions.clamp_(0, ignored_index)
-            end_positions.clamp_(0, ignored_index)
-
-            loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
-            start_loss = loss_fct(start_logits, start_positions)
-            end_loss = loss_fct(end_logits, end_positions)
-            total_loss = (start_loss + end_loss) / 2
-            return total_loss
-        else:
-            return start_logits, end_logits
-
-
-class BertForMultipleChoice(nn.Module):
-    """BERT model for multiple choice tasks.
-    This module is composed of the BERT model with a linear layer on top of
-    the pooled output.
-    Params:
-        `config`: a BertConfig class instance with the configuration to build a new model.
-        `num_choices`: the number of classes for the classifier. Default = 2.
-    Inputs:
-        `input_ids`: a torch.LongTensor of shape [batch_size, num_choices, sequence_length]
-            with the word token indices in the vocabulary(see the tokens preprocessing logic in the scripts
-            `extract_features.py`, `run_classifier.py` and `run_squad.py`)
-        `token_type_ids`: an optional torch.LongTensor of shape [batch_size, num_choices, sequence_length]
-            with the token types indices selected in [0, 1]. Type 0 corresponds to a `sentence A`
-            and type 1 corresponds to a `sentence B` token (see BERT paper for more details).
-        `attention_mask`: an optional torch.LongTensor of shape [batch_size, num_choices, sequence_length] with indices
-            selected in [0, 1]. It's a mask to be used if the input sequence length is smaller than the max
-            input sequence length in the current batch. It's the mask that we typically use for attention when
-            a batch has varying length sentences.
-        `labels`: labels for the classification output: torch.LongTensor of shape [batch_size]
-            with indices selected in [0, ..., num_choices].
-    Outputs:
-        if `labels` is not `None`:
-            Outputs the CrossEntropy classification loss of the output with the labels.
-        if `labels` is `None`:
-            Outputs the classification logits of shape [batch_size, num_labels].
-    Example usage:
-    ```python
-    # Already been converted into WordPiece token ids
-    input_ids = torch.LongTensor([[[31, 51, 99], [15, 5, 0]], [[12, 16, 42], [14, 28, 57]]])
-    input_mask = torch.LongTensor([[[1, 1, 1], [1, 1, 0]],[[1,1,0], [1, 0, 0]]])
-    token_type_ids = torch.LongTensor([[[0, 0, 1], [0, 1, 0]],[[0, 1, 1], [0, 0, 1]]])
-    config = BertConfig(vocab_size_or_config_json_file=32000, hidden_size=768,
-        num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072)
-    num_choices = 2
-    model = BertForMultipleChoice(config, num_choices)
-    logits = model(input_ids, token_type_ids, input_mask)
-    ```
-    """
-
-    def __init__(self, config, num_choices=2):
-        super(BertForMultipleChoice, self).__init__()
-        self.num_choices = num_choices
-        self.bert = BertModel(config)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.classifier = nn.Linear(config.hidden_size, 1)
-
-        def init_weights(module):
-            if isinstance(module, (nn.Linear, nn.Embedding)):
-                # Slightly different from the TF version which uses truncated_normal for initialization
-                # cf https://github.com/pytorch/pytorch/pull/5617
-                module.weight.data.normal_(mean=0.0, std=config.initializer_range)
-            elif isinstance(module, BERTLayerNorm):
-                module.beta.data.normal_(mean=0.0, std=config.initializer_range)
-                module.gamma.data.normal_(mean=0.0, std=config.initializer_range)
-            if isinstance(module, nn.Linear):
-                module.bias.data.zero_()
-
-        self.apply(init_weights)
-
-    def forward(self, input_ids, token_type_ids=None, attention_mask=None, labels=None):
-        flat_input_ids = input_ids.view(-1, input_ids.size(-1))
-        flat_token_type_ids = token_type_ids.view(-1, token_type_ids.size(-1))
-        flat_attention_mask = attention_mask.view(-1, attention_mask.size(-1))
-        _, pooled_output = self.bert(flat_input_ids, flat_token_type_ids, flat_attention_mask)
-        pooled_output = self.dropout(pooled_output)
-        logits = self.classifier(pooled_output)
-        reshaped_logits = logits.view(-1, self.num_choices)
-
-        if labels is not None:
-            loss_fct = CrossEntropyLoss()
-            loss = loss_fct(reshaped_logits, labels)
-            return loss
-        else:
-            return reshaped_logits
-
-
-class BertPalsEncoder(torch.nn.Module):
-    def __init__(self, config: str, task_ids: List[str], checkpoint):
-        super(BertPalsEncoder, self).__init__()
-        self.bert_config = BertPalConfig.from_json_file(config) if type(config) == str else config
-        self.bert_config.num_tasks = len(task_ids)
-        if type(checkpoint) != str:
-            self.bert_config.vocab_size = checkpoint.config.vocab_size
-        self.bert = BertModel(self.bert_config) if type(config) == str else checkpoint
-        self.task_idx = {task: i for i, task in enumerate(task_ids)}
-        print(self.task_idx)
-
-        def init_weights(module):
-            if isinstance(module, (torch.nn.Linear, torch.nn.Embedding)):
-                # Slightly different from the TF version which uses truncated_normal for initialization
-                # cf https://github.com/pytorch/pytorch/pull/5617
-                module.weight.data.normal_(mean=0.0, std=self.bert_config.initializer_range)
-            elif isinstance(module, BERTLayerNorm):
-                module.bias.data.normal_(mean=0.0, std=self.bert_config.initializer_range)
-                module.weight.data.normal_(mean=0.0, std=self.bert_config.initializer_range)
-            if isinstance(module, torch.nn.Linear):
-                if module.bias is not None:
-                    module.bias.data.zero_()
-
-        if type(config) == str:
-            if type(checkpoint) == str:
-                chk = torch.load(checkpoint, map_location='cpu')
-                update = {k.replace("bert.", ""): v for k, v in chk.items()}
-            else:
-                self.apply(init_weights)
-                partial = checkpoint.state_dict()
-                model_dict = self.bert.state_dict()
-                update = {}
-                for n, p in model_dict.items():
-                    if 'aug' in n or 'mult' in n:
-                        update[n] = p
-                        if 'pooler.mult' in n and 'bias' in n:
-                            update[n] = partial['pooler.dense.bias']
-                        if 'pooler.mult' in n and 'weight' in n:
-                            update[n] = partial['pooler.dense.weight']
-                    else:
-                        update[n] = partial[n]
-            self.bert.load_state_dict(update)
-
-    def forward(self, input_ids, attention_mask=None, task_id=None):
-        embedding = self.bert(input_ids, attention_mask=attention_mask, i=self.task_idx[task_id])
-        return embedding[0][-1]
-
-    def resize_token_embeddings(self, new_num_tokens: Optional[int] = None):
-        return self.bert.resize_token_embeddings(new_num_tokens)
-
-    def save_pretrained(self, save_path: str):
-        os.makedirs(save_path, exist_ok=True)
-        torch.save(self.bert.state_dict(), f'{save_path}/pytorch_model.bin')
-        torch.save(self.bert.config.save_pretrained(save_path))

evaluation/EVALUATION.md

@@ -1,131 +0,0 @@
-## Evaluation
-
- - SciRepEval can be used to evaluate scientific document representations on 4 task types - classification, regression, proximity based retrieval ( a document is the query) and ad-hoc search ( raw text query).
- - The evaluation process for each task consists of 2 steps - representation generation with a model and raw metadata; and evaluating these representation as features of the labelled test examples using a suitable metric.
-
-To reproduce the results in the paper for all or a collection of tasks in SciRepEval, follow the steps in [BENCHMARKING.md](https://github.com/allenai/scirepeval/blob/main/BENCHMARKING.md).
-
-
-### Custom Evaluation
-#### SciRepEval config
-The evaluation setup for the existing tasks in SciRepEval can be configured in [scirepeval_tasks.jsonl](https://github.com/allenai/scirepeval/blob/main/scirepeval_tasks.jsonl).
-These config parameters are internally parsed by the evaluators to generate the document representations and compute the relevant metric.
-
-**Example task config**:
-```json
-{
-    "name": "Biomimicry",
-    "type": "classification",
-    "data":
-    {
-        "meta":
-        {
-            "name": "allenai/scirepeval",
-            "config": "biomimicry"
-        },
-        "test":
-        {
-            "name": "allenai/scirepeval_test",
-            "config": "biomimicry"
-        }
-    },
-    "metrics":
-    [
-        "f1"
-    ],
-    "few_shot":
-    [
-        {
-            "sample_size": 64,
-            "iterations": 50
-        },
-        {
-            "sample_size": 16,
-            "iterations": 100
-        }
-    ]
-}
-```
-**Notes**
-
- 1. `"name"` - identifier for the task, can be utilized when filtering the tasks for evaluation.
- 2. `"type"`- can be one of `{"classification", "regression", "proximity", "adhoc_search"}`, for multi-label classification, provide additional `"multi_label"=true` flag.
- 3. `"data"` is required and expects at-least two entries: `"meta"` for the raw test data with title and abstracts for representation generation and `"test"` for the labelled examples. These can be local file paths or HuggingFace datasets. 
- 4. `"metrics"` is a list of the metrics to be computed for the task. These can be customized based on task type as follows:
- ```python
- if "type" == "classification":
-	 metrics can be {"f1", "accuracy", "precision", "recall", "{f1|precision|recall}_{macro|micro}"}
-elif "type" == "regression":
-	metrics can be {"mse", "r2", "pearsonr","kendalltau"}
-else:
-	metrics can be anything allowed in pytrec_eval* 
- ``` 
- *[pytrec_eval](https://github.com/cvangysel/pytrec_eval)
- 
- 5. Classification tasks can be additionally evaluated in few shot mode, provide a list of `"sample_size"` and `"iterations"`.
- 6. To avoid generating embeddings in every run, these can be cached and re-loaded in future runs by providing the `"embedding"` config as-
- ```json
- "embeddings":{"save":"<embeddings_dir>/<embeddings_file>.jsonl"}
- ``` 
- 
- OR
- 
- ```json
-  "embeddings":{"load":"<embeddings_dir>/<embeddings_file>.jsonl"}
- ```
-
-#### Custom Tasks
-For evaluating on new tasks from any of the four task types in SciRepEval, create the task config json as above and either append it to **scirepeval_tasks.jsonl** or add it to a new config file.
-
-To evaluate on all tasks: 
-Select model parameters as in [here](https://github.com/allenai/scirepeval/blob/main/BENCHMARKING.md#models). eg.
-```bash
-python scirepeval.py -m allenai/scirepeval_ctrl --ctrl-tokens --tasks-config scirepeval_tasks.jsonl --output scirepeval_results.json
-```
-OR
-
-```python
-from scirepeval import SciRepEval
-from evaluation.encoders import Model
-
-#Base/MTL CLS
-model = Model(variant="default", base_checkpoint="allenai/specter")
-
-#MTL CTRL
-model = Model(variant="default", base_checkpoint="allenai/scirepeval_ctrl", use_ctrl_codes=True)
-
-#PALs
-model = Model(variant="pals", base_checkpoint="allenai/scirepeval_pals", all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"])
-
-#Adapters
-adapters_dict = {"[CLF]": "allenai/scirepeval_adapters_clf", "[QRY]": "allenai/scirepeval_adapters_qry", "[RGN]": "allenai/scirepeval_adapters_rgn", "[PRX]": "allenai/scirepeval_prx"}
-model = Model(variant="adapters", base_checkpoint="malteos/scincl", adapters_load_from=adapters_dict, all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"])
-
-#Fusion
-model = Model(variant="fusion", base_checkpoint="malteos/scincl", adapters_load_from=adapters_dict, fusion_load_from=<fusion chkpoint directory>, all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"])
-
-#Choose the task names from scirepeval_tasks.jsonl
-evaluator = SciRepEval(tasks_config="scirepeval_tasks.jsonl", task_list:Optional=[...], task_format:Optional=[...])
-evaluator.evaluate(model, "scirepeval_results.json") 
-```
-
-#### Mean Pool Ensemble
-
-To generate and evaluate the mean of multiple models, provide a list of models to the `evaluate method`.
-```python
-from scirepeval import SciRepEval
-from evaluation.encoders import Model
-
-#MTL CTRL
-model1 = Model(variant="default", base_checkpoint="malteos/scincl", use_ctrl_codes=True)
-
-#Adapters
-adapters_dict = {"[CLF]": "allenai/scirepeval_adapters_clf", "[QRY]": "allenai/scirepeval_adapters_qry", "[RGN]": "allenai/scirepeval_adapters_rgn", "[PRX]": "allenai/scirepeval_adapters_prx"}
-model2 = Model(variant="adapters", base_checkpoint="malteos/scincl", adapters_load_from=adapters_dict, all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"])
-
-models = [model1, model2]
-evaluator = SciRepEval(tasks_config="scirepeval_tasks_adapters.jsonl", batch_size=16)
-evaluator.evaluate(models, "scirepeval_results.json") 
-
-```
-

evaluation/INFERENCE.md

@@ -1,98 +0,0 @@
-
-## Inference
-
-This guide provides the steps to generate relevant document embeddings with SciRepEval models.
- 
- ### Step 1 Create a Model instance
- ```python
-from evaluation.encoders import Model
-
-#Base/MTL CLS
-model = Model(variant="default", base_checkpoint="allenai/specter")
-
-#MTL CTRL
-model = Model(variant="default", base_checkpoint="allenai/scirepeval_ctrl", use_ctrl_codes=True)
-
-#PALs
-model = Model(variant="pals", base_checkpoint="allenai/scirepeval_pals", all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"])
-
-#Adapters
-adapters_dict = {"[CLF]": "allenai/scirepeval_adapters_clf", "[QRY]": "allenai/scirepeval_adapters_qry", "[RGN]": "allenai/scirepeval_adapters_rgn", "[PRX]": "allenai/scirepeval_prx"}
-model = Model(variant="adapters", base_checkpoint="malteos/scincl", adapters_load_from=adapters_dict, all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"])
-
-#Fusion
-model = Model(variant="fusion", base_checkpoint="malteos/scincl", adapters_load_from=adapters_dict, fusion_load_from=<fusion chkpoint directory>, all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"])
-
-```
-
-### Step 2 Determine task type
-Choose the relevant task id value from the below python dict keyed on task type
-``TASK_IDS = {"classification": "[CLF]", "regression": "[RGN]", "proximity": "[PRX]",  
-  "adhoc_search": {"query": "[QRY]", "candidates": "[PRX]"}}``
-
-```python
-model.task_id = "[CLF]" #OR "[RGN]"/"[PRX]"/{{"query": "[QRY]", "candidates": "[PRX]"}}}
-```
-
-For feeding raw text input to the model, follow step 3. If working with a specific dataset jump to Step 4.
-
-### Step 3 Generate embeddings for raw text
-Use the model object as a callable.
-```python
-embeddings = model("Attention is all you need[SEP]Attention is all you need")
-```
-
-### Step 4 Generate embeddings for a dataset
-
-- If data instances consists of records with fields: eg. 
-```json
-{
-    "corpus_id": 22715986,
-    "title": "Accuracy of MRI for treatment response assessment after taxane- and anthracycline-based neoadjuvant chemotherapy in HER2-negative breast cancer.",
-    "abstract": "BACKGROUND\nStudies suggest that MRI is an accurate means for assessing tumor size after neoadjuvant chemotherapy (NAC). However, accuracy might be dependent on the receptor status of tumors. MRI accuracy for response assessment after homogenous NAC in a relative large group of patients with stage II/III HER2-negative breast cancer has not been reported before.\n\n\nMETHODS\n250 patients from 26 hospitals received NAC (docetaxel, adriamycin and cyclophosphamide) in the context of the NEOZOTAC trial. MRI was done after 3 cycles and post-NAC. Imaging (RECIST 1.1) and pathological (Miller and Payne) responses were recorded."
-}
-```
-```python
-from evaluation.eval_datasets import SimpleDataset  
-from evaluation.evaluator import Evaluator
-
-dataset = ("allenai/scirepeval", "biomimicry") #OR path like "scirepeval/biomimicry/test.json"
-evaluator = Evaluator(name="biomimcry", dataset, SimpleDataset, model, batch_size=32, fields=["title", "abstract"], key="paper_id")
-embeddings = evaluator.generate_embeddings(save_path="embeddings.json")
-```
-- If data instances consists of query-candidate pairs: eg. 
-```json
-{
-    "dataset": "aminer",
-    "query":
-    {
-        "corpus_id": 24254880,
-        "title": "[Characteristics of heavy metal elements and their relationship with magnetic properties of river sediment from urban area in Lanzhou].",
-        "abstract": "The contents of As, Co, Cr, Cu, Ni, Pb, V and Zn in the surface sediments from 8 rivers in urban area in Lanzhou were monitored by ecological risk which was assessed by the potential ecological Håkanson index, and the index of geoaccumulation (Igeo), sediment enrichment factor (R), and environmental magnetism. The results showed that: (1) the potential ecological risk of heavy metals of As, Co, Ni, V in surface sediments from 8 rivers were low, which belonged to low ecological risk. But the risk of heave metals Cr, Pb, Zn in surface sediments from Yuer river was high, which belonged to middle ecological risk, and in downstream of Yuer river, the element of Cu belonged to high ecological risk. (2) The rivers in Lanzhou could be divided into four groups according to the heavy mental pollution degree: first type, such as Paihong river, Shier river, Yuer river and Shuimo river, called downstream concentrate type; second type, such as Qili river, called upstream concentrate type; third type, such as Luoguo river and Dasha river, called less affected type; fourth type, Lanni river, which polluted heavily in up and downstream; (3) The correlation analysis between magnetic parameters and element contents show that the parameters which mainly reflect the concentration of the magnetic minerals (X, SIRM, Ms) have close association with Cr, Ni, Pb, Zn, Cu, So we can infer that the magnetic minerals in deposits samples mainly came from electroplating effluent, motor vehicle emission, and domestic sewage. SIRM/X shows a strong correlation with Cr, Ni, Pb, Zn, indicating the distribution of anthropogenic particulates. (4) The magnetic minerals(X, SIRM, Ms) have a strong correlation with the geoaccumulation (Igeo) than potential ecological risk index and enrichment factor (R). These results suggest a possible approach for source identification of magnetic material in pollution studies and the validity of using magnetic measurements to mapping the polluted area."
-    },
-    "candidates":
-    [
-        {
-            "corpus_id": 12540419,
-            "title": "Combination of magnetic parameters and heavy metals to discriminate soil-contamination sources in Yinchuan--a typical oasis city of Northwestern China.",
-            "abstract": "Various industrial processes and vehicular traffic result in harmful emissions containing both magnetic minerals and heavy metals. In this study, we investigated the levels of magnetic and heavy metal contamination of topsoils from Yinchuan city in northwestern China. The results demonstrate that magnetic mineral assemblages in the topsoil are dominated by pseudo-single domain (PSD) and multi-domain (MD) magnetite. The concentrations of anthropogenic heavy metals (Cr, Cu, Pb and Zn) and the magnetic properties of χlf, SIRM, χARM, and 'SOFT' and 'HARD' remanence are significantly correlated, suggesting that the magnetic minerals and heavy metals have common sources. Combined use of principal components and fuzzy cluster analysis of the magnetic and chemical data set indicates that the magnetic and geochemical properties of the particulates emitted from different sources vary significantly. Samples from university campus and residential areas are mainly affected by crustal material, with low concentrations of magnetic minerals and heavy metals, while industrial pollution sources are characterized by high concentrations of coarse magnetite and Cr, Cu, Pb and Zn. Traffic pollution is characterized by Pb and Zn, and magnetite. Magnetic measurements of soils are capable of differentiating sources of magnetic minerals and heavy metals from industrial processes, vehicle fleets and soil parent material.",
-            "score": 1
-        }
-    ]...
-}
-```
-
-```python
-from evaluation.eval_datasets import IRDataset  
-from evaluation.evaluator import Evaluator
-
-dataset = ("allenai/scirepeval", "feeds_1") #OR path like "scirepeval/feeds_1/test.json"
-evaluator = Evaluator(name="biomimcry", dataset, IRDataset, model, batch_size=32, fields=["title", "abstract"], key="doc_id")
-embeddings = evaluator.generate_embeddings(save_path="embeddings.json")
-```
-
-
-
-
-
-

evaluation/embeddings_generator.py

@@ -1,53 +0,0 @@
-from typing import Dict, List, Union
-
-from evaluation.encoders import Model
-from tqdm import tqdm
-import numpy as np
-import json
-import pathlib
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class EmbeddingsGenerator:
-    def __init__(self, datasets, models: Union[Model, List[Model]]):
-        self.datasets = datasets
-        self.models = models
-
-    def generate_embeddings(self, save_path: str = None, htrans=False, document=False) -> Dict[str, np.ndarray]:
-        results = dict()
-        try:
-            for dataset, model in zip(self.datasets, self.models):
-                for batch, batch_ids in tqdm(dataset.batches(htrans, document), total=len(dataset) // dataset.batch_size):
-                    emb = model(batch, batch_ids)
-                    for paper_id, embedding in zip(batch_ids, emb.unbind()):
-                        if type(paper_id) == tuple:
-                            paper_id = paper_id[0]
-                        if paper_id not in results:
-                            results[paper_id] = embedding.detach().cpu().numpy()
-                        else:
-                            results[paper_id] += embedding.detach().cpu().numpy()
-                    del batch
-                    del emb
-            results = {k: v/len(self.models) for k, v in results.items()}
-        except Exception as e:
-            print(e)
-        finally:
-            if save_path:
-                pathlib.Path(save_path).parent.mkdir(parents=True, exist_ok=True)
-                with open(save_path, 'w') as fout:
-                    for k, v in results.items():
-                        fout.write(json.dumps({"doc_id": k, "embedding": v.tolist()}) + '\n')
-        logger.info(f"Generated {len(results)} embeddings")
-        return results
-
-    @staticmethod
-    def load_embeddings_from_jsonl(embeddings_path: str) -> Dict[str, np.ndarray]:
-        embeddings = {}
-        with open(embeddings_path, 'r') as f:
-            for line in tqdm(f, desc=f'reading embeddings from {embeddings_path}'):
-                line_json = json.loads(line)
-                embeddings[line_json['doc_id']] = np.array(line_json['embedding'], dtype=np.float16)
-        logger.info(f"Loaded {len(embeddings)} embeddings")
-        return embeddings

evaluation/encoders.py

@@ -1,320 +0,0 @@
-from typing import Dict, Union, List
-import numpy as np
-from transformers import AutoModel, AutoTokenizer
-import os
-from bert_pals import BertPalsEncoder, BertPalConfig, BertModel
-from adapter_fusion import AdapterEncoder, AdapterFusion
-from htrans.model import HTransModel, HTransConfig
-from nltk.tokenize import sent_tokenize
-import torch
-import logging
-from collections import OrderedDict,abc
-from itertools import chain
-from fvcore.nn import FlopCountAnalysis
-
-logger = logging.getLogger(__name__)
-
-
-class EncoderFactory:
-    def __init__(self, base_checkpoint: str = None, adapters_load_from: Union[str, Dict] = None,
-                 fusion_load_from: str = None, all_tasks: list = None):
-        self.base_checkpoint = f"{base_checkpoint}/model" if os.path.isdir(base_checkpoint) else base_checkpoint
-        self.all_tasks = all_tasks
-        self.adapters_load_from = f"{adapters_load_from}/model/adapters" if (type(
-            adapters_load_from) == str and os.path.isdir(
-            adapters_load_from)) else adapters_load_from
-        self.fusion_load_from = f"{fusion_load_from}/model"
-
-    def get_encoder(self, variant: str):
-        if variant == "default":
-            return AutoModel.from_pretrained(self.base_checkpoint)
-        elif variant == "pals":
-            # needs all task names and a local checkpoint path
-            if os.path.isdir(self.base_checkpoint):
-                return BertPalsEncoder(config=f"{self.base_checkpoint}/config.json", task_ids=self.all_tasks,
-                                       checkpoint=f"{self.base_checkpoint}/pytorch_model.bin")
-            else:
-                pals_config = BertPalConfig.from_pretrained(self.base_checkpoint)
-                pals_model = BertModel.from_pretrained(self.base_checkpoint)
-                return BertPalsEncoder(config=pals_config, task_ids=self.all_tasks,
-                                       checkpoint=pals_model)
-        elif variant == "adapters":
-            # needs a base model checkpoint and the adapters to be loaded from local path or dict of (task_id,
-            # adapter) from adapters hub
-            return AdapterEncoder(self.base_checkpoint, self.all_tasks, load_as=self.adapters_load_from)
-        elif variant == "fusion":
-            # needs a base model and list of adapters/local adapter checkpoint paths to be fused
-            return AdapterFusion(self.base_checkpoint, self.all_tasks, load_adapters_as=self.adapters_load_from,
-                                 fusion_dir=self.fusion_load_from, inference=True)
-        else:
-            raise ValueError("Unknown encoder type: {}".format(variant))
-
-
-class Model:
-    def __init__(self, variant: str = "default", base_checkpoint: str = None,
-                 adapters_load_from: Union[str, Dict] = None, fusion_load_from: str = None,
-                 use_ctrl_codes: bool = False, task_id: Union[str, Dict] = None,
-                 all_tasks: list = None, hidden_dim: int = 768, max_len: int = 512, use_fp16=False, document=False):
-        self.variant = variant
-        self.encoder = EncoderFactory(base_checkpoint, adapters_load_from, fusion_load_from, all_tasks).get_encoder(
-            variant)
-        if torch.cuda.is_available():
-            self.encoder.to('cuda')
-        self.encoder.eval()
-        tokenizer_checkpoint = f"{base_checkpoint}/tokenizer" if os.path.isdir(base_checkpoint) else base_checkpoint
-        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_checkpoint)
-        self.use_ctrl_codes = use_ctrl_codes
-        self.reqd_token_idx = 0 if not use_ctrl_codes else 1
-        self._task_id = task_id
-        self.document = document
-        if self._task_id:
-            if use_ctrl_codes:
-                logger.info(f"Control code used: {self._task_id}")
-            elif variant != "default":
-                logger.info(f"Task id used: {self._task_id}")
-
-        self.hidden_dim = hidden_dim
-        self.max_length = max_len
-        self.use_fp16 = use_fp16
-
-    @property
-    def task_id(self):
-        return self._task_id
-
-    @task_id.setter
-    def task_id(self, value):
-        if self.use_ctrl_codes:
-            logger.info(f"Control code used: {value}")
-        elif self.variant != "default":
-            logger.info(f"Task id used: {value}")
-        self._task_id = value
-
-    def __call__(self, batch, batch_ids=None):
-        def append_ctrl_code(batch, batch_ids):
-            if type(self._task_id) == dict:
-                batch = [f"{self.task_id['query']} {text}" if bid[1] == "q" else f"{self.task_id['candidates']} {text}"
-                         for text, bid in zip(batch, batch_ids)]
-            else:
-                batch = [f"{self.task_id} {text}" for text in batch]
-            return batch
-
-        batch = [batch] if type(batch) == str else batch
-        batch_ids = [] if not batch_ids else batch_ids
-        if self.use_ctrl_codes:
-            batch = append_ctrl_code(batch, batch_ids)
-        if self.document:
-            batch = ["".join([list(chain.from_iterable(i))[0]] + [" [SEP] "] + list(chain.from_iterable(i))[1:]) for i in batch]
-        input_ids = self.tokenizer(batch, padding=True, truncation=True,
-                                   return_tensors="pt", return_token_type_ids=False, max_length=self.max_length)
-        input_ids.to('cuda')
-        if self.variant == "default":
-            output = self.encoder(**input_ids)
-        elif type(self._task_id) != dict:
-            output = self.encoder(task_id=self._task_id, **input_ids)
-        else:
-            x = input_ids["input_ids"]
-            output = torch.zeros(x.shape[0], x.shape[1], self.hidden_dim).to("cuda")
-            q_idx = torch.tensor([i for i, b in enumerate(batch_ids) if b[1] == "q"])
-            c_idx = torch.tensor([i for i, b in enumerate(batch_ids) if b[1] == "c"])
-
-            if not q_idx.shape[0]:
-                output = self.encoder(task_id=self._task_id["candidates"], **input_ids)
-            elif not c_idx.shape[0]:
-                output = self.encoder(task_id=self._task_id["query"], **input_ids)
-            else:
-                for i, v in enumerate(sorted(self._task_id.values())):
-                    curr_input_idx = q_idx if v == "[QRY]" else c_idx
-                    curr_input = x[curr_input_idx]
-                    curr_output = self.encoder(task_id=v, input_ids=curr_input,
-                                               attention_mask=input_ids["attention_mask"][curr_input_idx])
-                    try:
-                        output[curr_input_idx] = curr_output  # adapters
-                    except:
-                        output[curr_input_idx] = curr_output.last_hidden_state  # pals
-        try:
-            embedding = output.last_hidden_state[:, self.reqd_token_idx, :]  # cls token
-        except:
-            embedding = output[:, self.reqd_token_idx, :]  # cls token
-        return embedding.half() if self.use_fp16 else embedding
-
-
-class HModel:
-    def __init__(self, variant: str = "default", base_checkpoint: str = None,
-                 adapters_load_from: Union[str, Dict] = None, fusion_load_from: str = None,
-                 use_ctrl_codes: bool = False, task_id: Union[str, Dict] = None,
-                 all_tasks: list = None, use_fp16=False):
-        self.variant = variant
-        # self.encoder = EncoderFactory(base_checkpoint, adapters_load_from, fusion_load_from, all_tasks).get_encoder(
-        #     variant)
-        self.config = HTransConfig.from_pretrained(base_checkpoint)
-        self.encoder = HTransModel.from_pretrained(base_checkpoint, config=self.config)
-        if torch.cuda.is_available():
-            self.encoder.to('cuda')
-        self.encoder.eval()
-        # tokenizer_checkpoint = f"{base_checkpoint}/tokenizer" if os.path.isdir(base_checkpoint) else base_checkpoint
-        self.tokenizer = AutoTokenizer.from_pretrained(base_checkpoint)
-        if self.config.max_doc_length > 1:
-            self.head_ids = torch.tensor([self.tokenizer.get_vocab()["<sec>"], self.tokenizer.get_vocab()["<doc>"]], dtype=torch.int)
-        self.use_ctrl_codes = use_ctrl_codes
-        self.reqd_token_idx = 0 if not use_ctrl_codes else 1
-        self._task_id = task_id
-        if self._task_id:
-            if use_ctrl_codes:
-                logger.info(f"Control code used: {self._task_id}")
-            elif variant != "default":
-                logger.info(f"Task id used: {self._task_id}")
-
-        self.use_fp16 = use_fp16
-
-    @property
-    def task_id(self):
-        return self._task_id
-
-    @task_id.setter
-    def task_id(self, value):
-        if self.use_ctrl_codes:
-            logger.info(f"Control code used: {value}")
-        elif self.variant != "default":
-            logger.info(f"Task id used: {value}")
-        self._task_id = value
-
-    def __call__(self, batch, batch_ids=None):
-        def append_ctrl_code(batch, batch_ids):
-            if type(self._task_id) == dict:
-                batch = [f"{self.task_id['query']} {text}" if bid[1] == "q" else f"{self.task_id['candidates']} {text}"
-                         for text, bid in zip(batch, batch_ids)]
-            else:
-                batch = [f"{self.task_id} {text}" for text in batch]
-            return batch
-
-        batch = [batch] if type(batch) == str else batch
-        batch_ids = [] if not batch_ids else batch_ids
-        if self.use_ctrl_codes:
-            batch = append_ctrl_code(batch, batch_ids)
-        inputs = []
-        pad_input_ids = np.ones((1, self.config.max_sent_length), dtype=np.int64) * self.tokenizer.pad_token_id
-        pad_attention_mask = np.zeros((1, self.config.max_sent_length), dtype=np.int64)
-        # pad_token_type_ids = np.zeros((1, self.config.max_sent_length), dtype=np.int64)
-        def tokenize_document(tokenizer, document, max_sent_length, max_sec_length, max_doc_length=1):
-            if max_doc_length != 1:
-                document = document[:max_doc_length]
-            document = [i[:max_sec_length] for i in document]
-            text = list(chain.from_iterable(document))
-            sec_length = [0] + [len(i) for i in document]
-            inputs = tokenizer(text, return_special_tokens_mask=False, return_tensors="np",
-                               padding="max_length", truncation=True)
-            pad_input_ids = np.ones((1, max_sent_length), dtype=np.int64) * tokenizer.pad_token_id
-            pad_attention_mask = np.zeros((1, max_sent_length), dtype=np.int64)
-            pad_token_type_ids = np.zeros((1, max_sent_length), dtype=np.int64)
-            sec_inputs = [{"input_ids": np.column_stack(
-                [np.expand_dims(
-                    np.concatenate(inputs["input_ids"][sum(sec_length[:i]): sum(sec_length[:i]) + sec_length[i + 1]],
-                                   axis=0), axis=0)] + [pad_input_ids] * (
-                        max_sec_length - sec_length[i + 1])),
-                "attention_mask": np.column_stack(
-                    [np.expand_dims(np.concatenate(
-                        inputs["attention_mask"][sum(sec_length[:i]): sum(sec_length[:i]) + sec_length[i + 1]], axis=0),
-                                    axis=0)] + [
-                        pad_attention_mask] * (max_sec_length - sec_length[i + 1]))} for i in
-                range(len(sec_length) - 1)]
-
-            if max_doc_length > 1:
-                pad_sec_input_ids = np.ones((1, max_sent_length * max_sec_length),
-                                            dtype=np.int64) * tokenizer.pad_token_id
-                pad_sec_attention_mask = np.zeros((1, max_sent_length * max_sec_length), dtype=np.int64)
-                pad_sec_token_type_ids = np.zeros((1, max_sent_length * max_sec_length), dtype=np.int64)
-                return {"input_ids": np.column_stack(
-                    [i["input_ids"] for i in sec_inputs] + [pad_sec_input_ids] * (max_doc_length - len(sec_inputs))),
-                    "attention_mask": np.column_stack(
-                        [i["attention_mask"] for i in sec_inputs] + [pad_sec_attention_mask] * (
-                                max_doc_length - len(sec_inputs))),
-                    "sec_mask": np.column_stack([np.ones((1, inputs["input_ids"].shape[0]), dtype=np.int64)] + (
-                                max_doc_length * max_sec_length - inputs["input_ids"].shape[0]) * [
-                                                    np.zeros((1, 1), dtype=np.int64)]),
-                    "doc_mask": np.column_stack(
-                        [np.ones((1, len(sec_inputs)), dtype=np.int64)] + (max_doc_length - len(sec_inputs)) * [
-                            np.zeros((1, 1), dtype=np.int64)]),
-                    "head_ids": np.array([[self.tokenizer.get_vocab()["<sec>"], self.tokenizer.get_vocab()["<doc>"]]],
-                                         dtype=np.int64)
-                }
-            return dict(zip(sec_inputs[0].keys(),
-                            [np.concatenate([d[key] for d in sec_inputs]) for key in sec_inputs[0].keys()]))
-        if self.config.max_doc_length > 1:
-            for sample in batch:
-                if type(sample) == str:
-                    sample = [[sample]]
-                inputs.append(tokenize_document(self.tokenizer,sample, self.config.max_sent_length, self.config.max_sec_length, self.config.max_doc_length))
-            input_ids = dict(zip(inputs[0].keys(), [torch.tensor(np.concatenate([d[key] for d in inputs])) for key in inputs[0].keys()]))
-
-        else:
-            for sample in batch:
-                if type(sample) == str:
-                    sample = [sample]
-                else:
-                    sample = list(chain.from_iterable(sample))
-                sentences = sample[:self.config.max_sec_length]
-                tokenized_sample = self.tokenizer(sentences, padding="max_length", truncation=True,
-                                           return_tensors="np", return_token_type_ids=False)
-                inputs.append({"input_ids": np.row_stack([tokenized_sample["input_ids"]] + [pad_input_ids] * (self.config.max_sec_length - len(sentences))).reshape((1, self.config.max_sent_length*self.config.max_sec_length)),
-                               "attention_mask": np.row_stack([tokenized_sample["attention_mask"]] + [pad_attention_mask] * (self.config.max_sec_length - len(sentences))).reshape((1, self.config.max_sent_length*self.config.max_sec_length)),
-                               "sec_mask": np.column_stack(
-                                   [np.ones((1, tokenized_sample["input_ids"].shape[0]), dtype=np.int64)] + (
-                                           self.config.max_sec_length - tokenized_sample["input_ids"].shape[0]) * [
-                                       np.zeros((1, 1), dtype=np.int64)]),
-                               "head_ids": np.array(
-                                   [[self.tokenizer.get_vocab()["<sec>"], self.tokenizer.get_vocab()["<doc>"]]],
-                                   dtype=np.int64)
-                               })
-            input_ids = dict(zip(inputs[0].keys(), [torch.tensor(np.concatenate([d[key] for d in inputs])) for key in inputs[0].keys()]))
-        input_ids = move_to_device(input_ids, "cuda")
-
-        if self.variant == "default":
-            output = self.encoder(**input_ids)
-        elif type(self._task_id) != dict:
-            output = self.encoder(task_id=self._task_id, **input_ids)
-        else:
-            x = input_ids["input_ids"]
-            output = torch.zeros(x.shape[0], x.shape[1], self.config.hidden_size).to("cuda")
-            q_idx = torch.tensor([i for i, b in enumerate(batch_ids) if b[1] == "q"])
-            c_idx = torch.tensor([i for i, b in enumerate(batch_ids) if b[1] == "c"])
-
-            if not q_idx.shape[0]:
-                output = self.encoder(task_id=self._task_id["candidates"], **input_ids)
-            elif not c_idx.shape[0]:
-                output = self.encoder(task_id=self._task_id["query"], **input_ids)
-            else:
-                for i, v in enumerate(sorted(self._task_id.values())):
-                    curr_input_idx = q_idx if v == "[QRY]" else c_idx
-                    curr_input = x[curr_input_idx]
-                    curr_output = self.encoder(task_id=v, input_ids=curr_input,
-                                               attention_mask=input_ids["attention_mask"][curr_input_idx])
-                    try:
-                        output[curr_input_idx] = curr_output  # adapters
-                    except:
-                        output[curr_input_idx] = curr_output.last_hidden_state  # pals
-        try:
-            if self.config.pool_scheme == "first-token":
-                # embedding = output.last_hidden_state[:, self.reqd_token_idx, :]  # cls token
-                embedding = output.last_hidden_state[:, [i * self.config.max_sent_length + self.reqd_token_idx for i in
-                                                         range(self.config.max_sec_length)], :].mean(dim=1)  # cls token
-            elif self.config.pool_scheme == "avg":
-                # embedding = output.last_hidden_state.mean(dim=1)
-                embedding = output.last_hidden_state[:, [i*self.config.max_sent_length+self.reqd_token_idx for i in range(self.config.max_sec_length)], :].mean(dim=1)  # cls token
-                # embedding = output.last_hidden_state[:, self.reqd_token_idx, :]  # cls token
-            elif self.config.pool_scheme == "max":
-                embedding = output.last_hidden_state.max(dim=1)[0]
-        except:
-            embedding = output[:, self.reqd_token_idx, :]  # cls token
-        return embedding.half() if self.use_fp16 else embedding
-
-
-def move_to_device(batch, device):
-    r"""Puts each data field to the device"""
-    if isinstance(batch, torch.Tensor):
-        return batch.to(device)
-    elif isinstance(batch,(list,tuple)):
-        return tuple(move_to_device(item,device) for item in batch)
-    elif isinstance(batch, abc.Mapping):
-        return {key: move_to_device(value,device) for key, value in batch.items()}
-    else:
-        return batch

evaluation/eval_datasets.py

@@ -1,96 +0,0 @@
-import logging
-import os
-from typing import Union, List
-from nltk import sent_tokenize
-import datasets
-
-logger = logging.getLogger(__name__)
-
-
-class SimpleDataset:
-
-    def __init__(self, data_path: Union[str, tuple], sep_token: str, batch_size=32,
-                 fields: List = None, key: str = None, processing_fn=None):
-        self.batch_size = batch_size
-        self.sep_token = sep_token
-        if not fields:
-            fields = ["title", "abstract"]
-        self.fields = fields
-        logger.info(f"Loading test metadata from {data_path}")
-        if not processing_fn:
-            if type(data_path) == str and os.path.isfile(data_path):
-                self.data = datasets.load_dataset("json", data_files={"test": data_path})["test"]
-            else:
-                self.data = datasets.load_dataset(data_path[0], data_path[1], split="evaluation")
-        else:
-            self.data = processing_fn(data_path)
-        logger.info(f"Loaded {len(self.data)} documents")
-        self.seen_ids = set()
-        self.key = key
-    def __len__(self):
-        return len(self.data)
-
-    def batches(self, htrans=False, document=False):
-        return self.process_batches(self.data, htrans=htrans, document=document)
-
-    def process_batches(self, data: Union[datasets.Dataset, List], htrans=False, document=False):
-        # create batches
-        batch = []
-        batch_ids = []
-        batch_size = self.batch_size
-        i = 0
-        key = "doc_id" if not self.key else self.key
-        for d in data:
-            if key in d and d[key] not in self.seen_ids:
-                bid = d[key]
-                self.seen_ids.add(bid)
-                if htrans:
-                    text = [[d["title"]] + sent_tokenize(d["abstract"])]
-                    text += [[i["title"]] + i["sentences"] for i in d["full_text"]]
-                else:
-                    text = []
-                    for field in self.fields:
-                        if d.get(field):
-                            text.append(str(d[field]))
-                    text = (f" {self.sep_token} ".join(text)).strip()
-                    if document:
-                        for sec in d.get("full_text", []):
-                            text += (sec["title"] + " ")
-                            text += "".join(sec["sentences"])
-                if (i) % batch_size != 0 or i == 0:
-                    batch_ids.append(bid)
-                    batch.append(text)
-                else:
-                    yield batch, batch_ids
-                    batch_ids = [bid]
-                    batch = [text]
-                i += 1
-        if len(batch) > 0:
-            yield batch, batch_ids
-
-
-class IRDataset(SimpleDataset):
-    def __init__(self, data_path, sep_token, batch_size=32, fields=None, key=None, processing_fn=None):
-        super().__init__(data_path, sep_token, batch_size, fields, key, processing_fn)
-        self.queries, self.candidates = [], []
-        self.search = False
-        for d in self.data:
-            if type(d["query"]) == str:
-                self.search = True
-                self.queries.append({"title": d["query"], "doc_id": d["doc_id"]})
-            else:
-                self.queries.append(d["query"])
-            self.candidates += (d["candidates"])
-
-    def __len__(self):
-        return len(self.queries) + len(self.candidates)
-
-    def batches(self, htrans=False, document=False):
-        query_gen = self.process_batches(self.queries, htrans=htrans and self.search, document=document and self.search)
-        cand_gen = self.process_batches(self.candidates, htrans=htrans, document=document)
-        for q, q_ids in query_gen:
-            q_ids = [(v, "q") for v in q_ids]
-            yield q, q_ids
-        for c, c_ids in cand_gen:
-            c_ids = [(v, "c") for v in c_ids]
-            yield c, c_ids

evaluation/evaluator.py

@@ -1,228 +0,0 @@
-from typing import Union, Dict, Tuple
-
-import numpy as np
-from lightning.classification import LinearSVC
-from lightning.regression import LinearSVR
-from sklearn.metrics import f1_score, accuracy_score, precision_score, recall_score, mean_squared_error, r2_score
-from scipy.stats import kendalltau, pearsonr
-from sklearn.model_selection import GridSearchCV
-from sklearn.multiclass import OneVsRestClassifier
-
-from evaluation.embeddings_generator import EmbeddingsGenerator
-from abc import ABC, abstractmethod
-from evaluation.encoders import Model
-from evaluation.eval_datasets import SimpleDataset, IRDataset
-import logging
-import datasets
-import os
-from enum import Enum
-from sklearn.metrics.pairwise import euclidean_distances
-import pytrec_eval
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-RANDOM_STATE = 42
-
-
-class Evaluator:
-    def __init__(self, name: str, meta_dataset: Union[str, tuple], dataset_class, model: Model, batch_size: int,
-                 fields: list, key: str = None, process_fn=None):
-        if model:
-            if type(model) != list:
-                model = [model]
-            # for m in model:
-            #     if not m.tokenizer.pad_token:
-            #         m.tokenizer.add_special_tokens({'pad_token': '[PAD]'})
-            #         m.tokenizer.padding_side = "left"
-            #         m.tokenizer.sep_token = m.tokenizer.eos_token
-            #         m.encoder.resize_token_embeddings(len(m.tokenizer))
-            datasets = [dataset_class(meta_dataset, m.tokenizer.sep_token, batch_size, fields, key,
-                                    process_fn) for m in model]
-            self.embeddings_generator = EmbeddingsGenerator(datasets, model)
-        self.name = name
-
-    def generate_embeddings(self, save_path: str = None, htrans=False, document=False):
-        logger.info("Generating embeddings... this might take a while")
-        return self.embeddings_generator.generate_embeddings(save_path, htrans, document)
-
-    @abstractmethod
-    def evaluate(self, embeddings: Union[str, Dict[str, np.ndarray]], **kwargs) -> Dict[str, float]:
-        pass
-
-    @abstractmethod
-    def calc_metrics(self, test, preds) -> Dict[str, float]:
-        pass
-
-    def print_results(self, results: Dict[str, float]):
-        if results:
-            print("*****************************************************")
-            print(f"                 {self.name}")
-            print("*****************************************************")
-            for k, v in results.items():
-                print(f"                 {k}: {v}")
-            print("*****************************************************")
-
-
-class SupervisedTask(Enum):
-    CLASSIFICATION = 1
-    MULTILABEL_CLASSIFICATION = 2
-    REGRESSION = 3
-
-
-SUPERVISED_TASK_METRICS = {
-    SupervisedTask.CLASSIFICATION: {"f1": f1_score, "accuracy": accuracy_score, "precision": precision_score,
-                                    "recall": recall_score},
-    SupervisedTask.REGRESSION: {"mse": mean_squared_error, "r2": r2_score, "pearsonr": pearsonr,
-                                "kendalltau": kendalltau}
-}
-
-
-class SupervisedEvaluator(Evaluator):
-    def __init__(self, name: str, task: SupervisedTask, meta_dataset: Union[str, tuple],
-                 test_dataset: Union[str, tuple],
-                 model: Model, metrics: tuple, batch_size: int = 16, fields: list = None):
-        super(SupervisedEvaluator, self).__init__(name, meta_dataset, SimpleDataset, model, batch_size, fields)
-        self.test_dataset = test_dataset
-        self.metrics = metrics
-        self.task = task
-
-    def evaluate(self, embeddings, **kwargs):
-        logger.info(f"Loading labelled data from {self.test_dataset}")
-        if type(self.test_dataset) == str and os.path.isdir(self.test_dataset):
-            split_dataset = datasets.load_dataset("csv", data_files={"train": f"{self.test_dataset}/train.csv",
-                                                                     "test": f"{self.test_dataset}/test.csv"})
-        else:
-            split_dataset = datasets.load_dataset(self.test_dataset[0], self.test_dataset[1])
-        logger.info(f"Loaded {len(split_dataset['train'])} training and {len(split_dataset['test'])} test documents")
-        if type(embeddings) == str and os.path.isfile(embeddings):
-            embeddings = EmbeddingsGenerator.load_embeddings_from_jsonl(embeddings)
-        x_train, x_test, y_train, y_test = self.read_dataset(split_dataset, embeddings)
-        eval_fn = self.regression if self.task == SupervisedTask.REGRESSION else self.classify
-        preds = eval_fn(x_train, x_test, y_train)
-        results = self.calc_metrics(y_test, preds)
-        self.print_results(results)
-        return results
-
-    @staticmethod
-    def read_dataset(data: datasets.DatasetDict, embeddings: Dict[str, np.ndarray]) -> Tuple[
-        np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-        train, test = data["train"], data["test"]
-        x_train, x_test = np.array(
-            [embeddings[str(paper["paper_id"])] for paper in train if str(paper["paper_id"]) in embeddings]), np.array(
-            [embeddings[str(paper["paper_id"])] for paper in test if str(paper["paper_id"]) in embeddings])
-        y_train, y_test = np.array(
-            [paper["label"] for paper in train if str(paper["paper_id"]) in embeddings]), np.array(
-            [paper["label"] for paper in test if str(paper["paper_id"]) in embeddings])
-        return x_train, x_test, y_train, y_test
-
-    def classify(self, x_train: np.ndarray, x_test: np.ndarray, y_train: np.ndarray, cv: int = 3,
-                 n_jobs: int = 5):
-
-        Cs = np.logspace(-2, 2, 5)
-        if self.task == SupervisedTask.MULTILABEL_CLASSIFICATION:
-            estimator = LinearSVC(max_iter=10000)
-            svm = GridSearchCV(estimator=estimator, cv=cv, param_grid={'C': Cs}, n_jobs=10)
-            svm = OneVsRestClassifier(svm, n_jobs=1)
-        else:
-            estimator = LinearSVC(loss="squared_hinge", random_state=RANDOM_STATE)
-            if cv:
-                svm = GridSearchCV(estimator=estimator, cv=cv, param_grid={'C': Cs}, verbose=1, n_jobs=n_jobs)
-            else:
-                svm = estimator
-        svm.fit(x_train, y_train)
-        preds = svm.predict(x_test)
-        return preds
-
-    def regression(self, x_train: np.ndarray, x_test: np.ndarray, y_train: np.ndarray, cv: int = 3,
-                   n_jobs: int = 5):
-        svm = LinearSVR(random_state=RANDOM_STATE)
-        Cs = np.logspace(-4, 2, 7)
-        svm = GridSearchCV(estimator=svm, cv=cv, param_grid={'C': Cs}, verbose=1, n_jobs=n_jobs)
-        svm.fit(x_train, y_train)
-        preds = svm.predict(x_test)
-        return preds
-
-    def calc_metrics(self, test, preds):
-        results = dict()
-        if self.task == SupervisedTask.REGRESSION:
-            for m in self.metrics:
-                if m in SUPERVISED_TASK_METRICS[self.task]:
-                    result = tuple(SUPERVISED_TASK_METRICS[self.task][m](test, preds))[0]
-                    if m != "mse":
-                        result = np.round(100 * result, 2)
-                    results[m] = result
-                else:
-                    logger.warning(
-                        f"Metric {m} not found...skipping, try one of {SUPERVISED_TASK_METRICS[self.task].keys()}")
-        else:
-            metric_task = SupervisedTask.CLASSIFICATION
-            for m in self.metrics:
-                split_m = m.split("_")
-                if split_m[0] in SUPERVISED_TASK_METRICS[metric_task]:
-                    if len(split_m) > 1:
-                        result = SUPERVISED_TASK_METRICS[metric_task][split_m[0]](test, preds, average=split_m[1])
-                    else:
-                        result = SUPERVISED_TASK_METRICS[metric_task][split_m[0]](test, preds)
-                    results[m] = np.round(100 * result, 2)
-                else:
-                    logger.warning(
-                        f"Metric {m} not found...skipping, try one of {SUPERVISED_TASK_METRICS[metric_task].keys()}")
-        return results
-
-
-class IREvaluator(Evaluator):
-    def __init__(self, name: str, meta_dataset: Union[str, tuple], test_dataset: Union[str, tuple], model: Model,
-                 metrics: tuple, dataset_class=IRDataset, batch_size: int = 16, fields: list = None, key=None):
-        super(IREvaluator, self).__init__(name, meta_dataset, dataset_class, model, batch_size, fields, key)
-        self.test_dataset = test_dataset
-        self.metrics = metrics
-
-    def get_qc_pairs(self, dataset):
-        pairs = dict()
-        for row in dataset:
-            if row["query_id"] not in pairs:
-                pairs[row["query_id"]] = dict()
-            pairs[row["query_id"]][row["cand_id"]] = row["score"]
-        return pairs
-
-    def calc_metrics(self, qrels, run):
-        evaluator = pytrec_eval.RelevanceEvaluator(qrels, set(self.metrics))
-        results = evaluator.evaluate(run)
-
-        metric_values = {}
-        for measure in sorted(self.metrics):
-            res = pytrec_eval.compute_aggregated_measure(
-                measure,
-                [query_measures[measure] for query_measures in results.values()]
-            )
-            metric_values[measure] = np.round(100 * res, 2)
-        return metric_values
-
-    def evaluate(self, embeddings, **kwargs):
-        logger.info(f"Loading labelled data from {self.test_dataset}")
-        if type(self.test_dataset) == str and os.path.isdir(self.test_dataset):
-            split_dataset = datasets.load_dataset("json", data_files={"test": f"{self.test_dataset}/test_qrel.jsonl"})
-        else:
-            split_dataset = datasets.load_dataset(self.test_dataset[0], self.test_dataset[1])
-        logger.info(f"Loaded {len(split_dataset['test'])} test query-candidate pairs")
-        if type(embeddings) == str and os.path.isfile(embeddings):
-            embeddings = EmbeddingsGenerator.load_embeddings_from_jsonl(embeddings)
-
-        qrels = self.get_qc_pairs(split_dataset["test"])
-        preds = self.retrieval(embeddings, qrels)
-        results = self.calc_metrics(qrels, preds)
-        self.print_results(results)
-        return results
-
-    def retrieval(self, embeddings, qrels: Dict[str, Dict[str, int]]) -> Dict[str, Dict[str, float]]:
-        run = dict()
-        for qid in qrels:
-            if qid in embeddings:
-                query = np.array([embeddings[qid]])
-                cids = [cid for cid in qrels[qid] if cid in embeddings]
-                cands = np.array([embeddings[cid] for cid in qrels[qid] if cid in embeddings])
-                scores = euclidean_distances(cands, query).flatten()
-                run[qid] = dict()
-                for i, cid in enumerate(cids):
-                    run[qid][cid] = float(-scores[i])
-        return run

evaluation/few_shot_evaluator.py

@@ -1,58 +0,0 @@
-import math
-from typing import Union
-
-import numpy as np
-from sklearn.model_selection import StratifiedKFold
-
-import evaluation.evaluator
-from evaluation.encoders import Model
-from evaluation.evaluator import SupervisedEvaluator, SupervisedTask
-from tqdm import tqdm
-
-
-class FewShotEvaluator(SupervisedEvaluator):
-    def __init__(self, name: str, task: SupervisedTask, meta_dataset: Union[str, tuple],
-                 test_dataset: Union[str, tuple], sample_size: int, num_iterations: int,
-                 model: Model, metrics: tuple = None, batch_size: int = 16, fields: list = None):
-        super(FewShotEvaluator, self).__init__(name, task, meta_dataset, test_dataset, model, metrics, batch_size,
-                                               fields)
-        self.sample_size = sample_size
-        self.num_iterations = num_iterations
-
-    def classify(self, x, x_test, y, cv=3, n_jobs=1):
-        stage_preds = []
-        if self.task == SupervisedTask.MULTILABEL_CLASSIFICATION:
-            for k in tqdm(range(self.num_iterations)):
-                idx_set = set()
-                np.random.seed(evaluation.evaluator.RANDOM_STATE + k)
-                for yi in range(y.shape[1]):
-                    idx_set.update(
-                        np.random.choice(np.where(y[:, yi] == 1)[0], self.sample_size, replace=False).tolist())
-                req_idx = list(idx_set)
-                x_train, y_train = x[req_idx], y[req_idx]
-                preds = super().classify(x_train, x_test, y_train)
-                stage_preds.append(preds)
-            np.random.seed(evaluation.evaluator.RANDOM_STATE)
-        else:
-            skf = StratifiedKFold(n_splits=math.ceil(x.shape[0] / self.sample_size))
-            count = 0
-            for _, train in tqdm(skf.split(x, y), total=self.num_iterations):
-                x_train, y_train = x[train], y[train]
-                res = super().classify(x_train, x_test, y_train, cv=0)
-                stage_preds.append(res)
-                count += 1
-                if count == self.num_iterations:
-                    break
-        return stage_preds
-
-    def calc_metrics(self, test, preds_list):
-        stage_results = dict()
-        for preds in preds_list:
-            res = super().calc_metrics(test, preds)
-            for k, v in res.items():
-                if k not in stage_results:
-                    stage_results[k] = []
-                stage_results[k].append(v)
-
-        results = {k: np.mean(v) for k, v in stage_results.items()}
-        return results

evaluation/gpt3_encoder.py

@@ -1,30 +0,0 @@
-import os
-import openai
-import torch
-from transformers import GPT2TokenizerFast
-
-
-class GPT3Model:
-    def __init__(self, embed_model: str):
-        openai.api_key = os.getenv("OPENAI_API_KEY")
-        self.embed_model = embed_model
-        self.tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
-
-    def __call__(self, batch, batch_ids=None):
-        batch_embed = []
-        for iptext in batch:
-            try:
-                response = openai.Embedding.create(
-                    input=iptext,
-                    model=self.embed_model
-                )
-                embeddings = response['data'][0]['embedding']
-                batch_embed.append(embeddings)
-            except:
-                response = openai.Embedding.create(
-                    input=" ".join(iptext.split(" ")[:450]),
-                    model=self.embed_model
-                )
-                embeddings = response['data'][0]['embedding']
-                batch_embed.append(embeddings)
-        return torch.tensor(batch_embed)

evaluation/instructor.py

@@ -1,25 +0,0 @@
-from InstructorEmbedding import INSTRUCTOR
-from transformers import AutoTokenizer
-
-instr_format = "Represent the Scientific documents for "
-
-
-class InstructorModel:
-    def __init__(self, embed_model: str):
-        self.encoder = INSTRUCTOR(embed_model)
-        self.task_id = None
-        self.instruction_map = {"[CLF]": f"{instr_format} classification: ", "[RGN]": f"{instr_format} regression: ",
-                                "[PRX]": f"{instr_format} retrieving similar similar documents: ",
-                                "[SRCH]": {"q": "Represent the Scientific query for retrieving relevant documents: ",
-                                           "c": f"{instr_format} for retrieval: "}}
-        self.tokenizer = AutoTokenizer.from_pretrained(embed_model)
-        self.tokenizer.sep_token = self.tokenizer.eos_token
-
-    def __call__(self, batch, batch_ids=None):
-        if type(self.task_id) != dict:
-            batch = [[self.instruction_map[self.task_id], b] for b in batch]
-        else:
-            instructions = [f"{self.instruction_map['[SRCH]'][b[1]]}{batch[i]}" for i, b in enumerate(batch_ids)]
-            batch = [[ins, b] for ins, b in zip(instructions, batch)]
-        batch_embed = self.encoder.encode(batch, convert_to_numpy=False, convert_to_tensor=True, device="cuda")
-        return batch_embed

examples/classification.py

@@ -1,24 +0,0 @@
-import sys
-
-sys.path.append('../')
-
-from evaluation.encoders import Model
-from evaluation.evaluator import SupervisedEvaluator, SupervisedTask
-from adapter_fusion import AdapterEncoder
-
-# default no control codes
-# model = Model(base_checkpoint="allenai/specter")
-
-# default control codes
-# model = Model(base_checkpoint="../lightning_logs/full_run/scincl_ctrl/checkpoints/", task_id="[CLF]", use_ctrl_codes=True)
-# single adapters
-model = Model(base_checkpoint="malteos/scincl", variant="adapters",
-              adapters_load_from="../../phantasm/phantasm_new/lightning_logs/full_run/scincl_adapters/checkpoints/model/adapters",
-              task_id="[CLF]")
-
-evaluator = SupervisedEvaluator("biomimicry", SupervisedTask.CLASSIFICATION, ("allenai/scirepeval", "biomimicry"),
-                                ("allenai/scirepeval_test", "biomimicry"), model, metrics=("f1",))
-
-embeddings = evaluator.generate_embeddings()
-
-evaluator.evaluate(embeddings)

examples/fewshot_classification.py

@@ -1,23 +0,0 @@
-import sys
-
-sys.path.append('../')
-
-from evaluation.encoders import Model
-from evaluation.few_shot_evaluator import FewShotEvaluator, SupervisedTask
-
-# default no control codes
-model = Model(base_checkpoint="allenai/specter")
-
-# default control codes
-# model = Model(base_checkpoint="../lightning_logs/full_run/scincl_ctrl/checkpoints/", task_id="[CLF]", use_ctrl_codes=True)
-
-# single adapters
-# model = Model(base_checkpoint="malteos/scincl", variant="adapters",
-#               adapters_load_from="../lightning_logs/full_run/scincl_adapters/checkpoints/", task_id="[CLF]")
-evaluator = FewShotEvaluator("drsm", SupervisedTask.CLASSIFICATION, ("allenai/scirepeval", "drsm"),
-                             ("allenai/scirepeval_test", "drsm"), model=model, metrics=("f1_macro",),
-                             sample_size=16, num_iterations=50)
-
-embeddings = evaluator.generate_embeddings()
-
-evaluator.evaluate(embeddings)

examples/regression.py

@@ -1,23 +0,0 @@
-import sys
-
-sys.path.append('../')
-
-from evaluation.encoders import Model
-from evaluation.evaluator import SupervisedEvaluator, SupervisedTask
-
-#default no control codes
-model = Model(base_checkpoint="allenai/specter")
-
-#default control codes
-# model = Model(base_checkpoint="../lightning_logs/full_run/scincl_ctrl/checkpoints/", task_id="[RGN]", use_ctrl_codes=True)
-
-#single adapters
-# model = Model(base_checkpoint="malteos/scincl", variant="adapters",
-#               adapters_load_from="../lightning_logs/full_run/scincl_adapters/checkpoints/", task_id="[RGN]")
-
-evaluator = SupervisedEvaluator("max hIndex", SupervisedTask.REGRESSION, ("allenai/scirepeval", "peer_review_score_hIndex"),
-                                ("allenai/scirepeval_test", "hIndex"), model, metrics=("pearsonr","kendalltau"))
-
-embeddings = evaluator.generate_embeddings()
-
-evaluator.evaluate(embeddings)

examples/retrieval.py

@@ -1,39 +0,0 @@
-import sys
-
-sys.path.append('../')
-from evaluation.evaluator import IREvaluator
-from evaluation.encoders import Model
-from adapter_fusion import AdapterEncoder
-from reviewer_matching import ReviewerMatchingEvaluator
-
-# default no control codes
-# model = Model(base_checkpoint="allenai/specter")
-
-# default control codes
-# model = Model(base_checkpoint="../lightning_logs/full_run/scincl_ctrl/checkpoints/", task_id="[PRX]", use_ctrl_codes=True)
-
-
-model = Model(base_checkpoint="malteos/scincl", variant="adapters",
-              adapters_load_from="../../../phantasm/phantasm_new/lightning_logs/full_run/scincl_adapters/checkpoints/",
-              task_id="[PRX]", all_tasks=["[PRX]"])
-encoder = AdapterEncoder("malteos/scincl", ["[PRX]"],
-                         "../../../phantasm/phantasm_new/lightning_logs/full_run/scincl_adapters/checkpoints/model/adapters")
-model.encoder = encoder
-model.encoder.cuda()
-model.encoder.eval()
-evaluator = IREvaluator("feeds_1", ("allenai/scirepeval", "feeds_1"), ("allenai/scirepeval_test", "feeds_1"), model,
-                        metrics=("map", "ndcg",))
-#
-# embeddings = evaluator.generate_embeddings()
-#
-# evaluator.evaluate(embeddings)
-
-# evaluator = IREvaluator("feeds_1", ("allenai/scirepeval", "feeds_title"), ("allenai/scirepeval_test", "feeds_title"),
-#                         model, metrics=("map", "ndcg",))
-# evaluator = ReviewerMatchingEvaluator("paper reviewer evaluation", ("allenai/scirepeval", "paper_reviewer_matching"),
-#                                       ("allenai/scirepeval_test", "paper_reviewer_matching"),
-#                                       ("allenai/scirepeval_test", "reviewers"), model, metrics=("map", "ndcg",))
-
-embeddings = evaluator.generate_embeddings()
-
-evaluator.evaluate(embeddings)

full_scirepeval_tasks.jsonl

@@ -1,17 +0,0 @@
-{"name":"Feeds-1","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_1"},"test":{"name":"allenai/scirepeval_test","config":"feeds_1"}},"metrics":["map"]}
-{"name":"Feeds-M","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_m"},"test":{"name":"allenai/scirepeval_test","config":"feeds_m"}},"metrics":["map"]}
-{"name":"Highly Influential Citations","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"high_influence_cite"},"test":{"name":"allenai/scirepeval_test","config":"high_influence_cite"}},"metrics":["map"]}
-{"name":"SciDocs Cite","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_cite"}},"embeddings":{"save":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"SciDocs CoCite","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_cocite"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"Fields of study","type":"classification","data":{"meta":{"name":"allenai/scirepeval","config":"fos"},"test":{"name":"allenai/scirepeval_test","config":"fos"}},"metrics":["f1_macro"],"few_shot":[{"sample_size":10,"iterations":50},{"sample_size":5,"iterations":100}],"multi_label":true}
-{"name":"Publication Year","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"pub_year"},"test":{"name":"allenai/scirepeval_test","config":"pub_year"}},"metrics":["kendalltau"]}
-{"name":"Search","type":"adhoc_search","data":{"meta":{"name":"allenai/scirepeval","config":"search"},"test":{"name":"allenai/scirepeval_test","config":"search"}},"fields":["title","abstract","venue","year"],"metrics":["ndcg"]}
-{"name":"Feeds Title","type":"adhoc_search","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_title"},"test":{"name":"allenai/scirepeval_test","config":"feeds_title"}},"metrics":["map"]}
-{"name":"Paper-Reviewer Matching","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"paper_reviewer_matching"},"test":{"name":"allenai/scirepeval_test","config":"paper_reviewer_matching"},"reviewers":{"name":"allenai/scirepeval_test","config":"reviewers"}},"metrics":["P_5", "P_10"]}
-{"name":"SciDocs CoView","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_view"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"SciDocs CoRead","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_read"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"Peer Review Score","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"peer_review_score_hIndex"},"test":{"name":"allenai/scirepeval_test","config":"peer_review_score"}},"embeddings":{"save":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
-{"name":"Max hIndex","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"peer_review_score_hIndex"},"test":{"name":"allenai/scirepeval_test","config":"hIndex"}},"embeddings":{"load":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
-{"name":"Tweet Mentions","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"tweet_mentions"},"test":{"name":"allenai/scirepeval_test","config":"tweet_mentions"}},"metrics":["kendalltau"]}
-{"name":"Citation Count","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"cite_count"},"test":{"name":"allenai/scirepeval_test","config":"cite_count"}},"metrics":["kendalltau"]}
-

htrans/act_fns.py

@@ -1,205 +0,0 @@
-# Copyright 2020 The HuggingFace Team. All rights reserved.
-#
-# 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 math
-from collections import OrderedDict
-
-import torch
-from packaging import version
-from torch import Tensor, nn
-import logging
-
-logger = logging.getLogger(__name__)
-
-class PytorchGELUTanh(nn.Module):
-    """
-    A fast C implementation of the tanh approximation of the GeLU activation function. See
-    https://arxiv.org/abs/1606.08415.
-
-    This implementation is equivalent to NewGELU and FastGELU but much faster. However, it is not an exact numerical
-    match due to rounding errors.
-    """
-
-    def __init__(self):
-        super().__init__()
-        if version.parse(torch.__version__) < version.parse("1.12.0"):
-            raise ImportError(
-                f"You are using torch=={torch.__version__}, but torch>=1.12.0 is required to use "
-                "PytorchGELUTanh. Please upgrade torch."
-            )
-
-    def forward(self, input: Tensor) -> Tensor:
-        return nn.functional.gelu(input, approximate="tanh")
-
-
-class NewGELUActivation(nn.Module):
-    """
-    Implementation of the GELU activation function currently in Google BERT repo (identical to OpenAI GPT). Also see
-    the Gaussian Error Linear Units paper: https://arxiv.org/abs/1606.08415
-    """
-
-    def forward(self, input: Tensor) -> Tensor:
-        return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (input + 0.044715 * torch.pow(input, 3.0))))
-
-
-class GELUActivation(nn.Module):
-    """
-    Original Implementation of the GELU activation function in Google BERT repo when initially created. For
-    information: OpenAI GPT's GELU is slightly different (and gives slightly different results): 0.5 * x * (1 +
-    torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3)))) This is now written in C in nn.functional
-    Also see the Gaussian Error Linear Units paper: https://arxiv.org/abs/1606.08415
-    """
-
-    def __init__(self, use_gelu_python: bool = False):
-        super().__init__()
-        if use_gelu_python:
-            self.act = self._gelu_python
-        else:
-            self.act = nn.functional.gelu
-
-    def _gelu_python(self, input: Tensor) -> Tensor:
-        return input * 0.5 * (1.0 + torch.erf(input / math.sqrt(2.0)))
-
-    def forward(self, input: Tensor) -> Tensor:
-        return self.act(input)
-
-
-class FastGELUActivation(nn.Module):
-    """
-    Applies GELU approximation that is slower than QuickGELU but more accurate. See: https://github.com/hendrycks/GELUs
-    """
-
-    def forward(self, input: Tensor) -> Tensor:
-        return 0.5 * input * (1.0 + torch.tanh(input * 0.7978845608 * (1.0 + 0.044715 * input * input)))
-
-
-class QuickGELUActivation(nn.Module):
-    """
-    Applies GELU approximation that is fast but somewhat inaccurate. See: https://github.com/hendrycks/GELUs
-    """
-
-    def forward(self, input: Tensor) -> Tensor:
-        return input * torch.sigmoid(1.702 * input)
-
-
-class ClippedGELUActivation(nn.Module):
-    """
-    Clip the range of possible GeLU outputs between [min, max]. This is especially useful for quantization purpose, as
-    it allows mapping negatives values in the GeLU spectrum. For more information on this trick, please refer to
-    https://arxiv.org/abs/2004.09602.
-
-    Gaussian Error Linear Unit. Original Implementation of the gelu activation function in Google Bert repo when
-    initially created.
-
-    For information: OpenAI GPT's gelu is slightly different (and gives slightly different results): 0.5 * x * (1 +
-    torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3)))). See https://arxiv.org/abs/1606.08415
-    """
-
-    def __init__(self, min: float, max: float):
-        if min > max:
-            raise ValueError(f"min should be < max (got min: {min}, max: {max})")
-
-        super().__init__()
-        self.min = min
-        self.max = max
-
-    def forward(self, x: Tensor) -> Tensor:
-        return torch.clip(gelu(x), self.min, self.max)
-
-
-class SiLUActivation(nn.Module):
-    """
-    See Gaussian Error Linear Units (Hendrycks et al., https://arxiv.org/abs/1606.08415) where the SiLU (Sigmoid Linear
-    Unit) was originally introduced and coined, and see Sigmoid-Weighted Linear Units for Neural Network Function
-    Approximation in Reinforcement Learning (Elfwing et al., https://arxiv.org/abs/1702.03118) and Swish: a Self-Gated
-    Activation Function (Ramachandran et al., https://arxiv.org/abs/1710.05941v1) where the SiLU was experimented with
-    later.
-    """
-
-    def forward(self, input: Tensor) -> Tensor:
-        return nn.functional.silu(input)
-
-
-class MishActivation(nn.Module):
-    """
-    See Mish: A Self-Regularized Non-Monotonic Activation Function (Misra., https://arxiv.org/abs/1908.08681). Also
-    visit the official repository for the paper: https://github.com/digantamisra98/Mish
-    """
-
-    def __init__(self):
-        super().__init__()
-        if version.parse(torch.__version__) < version.parse("1.9.0"):
-            self.act = self._mish_python
-        else:
-            self.act = nn.functional.mish
-
-    def _mish_python(self, input: Tensor) -> Tensor:
-        return input * torch.tanh(nn.functional.softplus(input))
-
-    def forward(self, input: Tensor) -> Tensor:
-        return self.act(input)
-
-
-class LinearActivation(nn.Module):
-    """
-    Applies the linear activation function, i.e. forwarding input directly to output.
-    """
-
-    def forward(self, input: Tensor) -> Tensor:
-        return input
-
-
-class ClassInstantier(OrderedDict):
-    def __getitem__(self, key):
-        content = super().__getitem__(key)
-        cls, kwargs = content if isinstance(content, tuple) else (content, {})
-        return cls(**kwargs)
-
-
-ACT2CLS = {
-    "gelu": GELUActivation,
-    "gelu_10": (ClippedGELUActivation, {"min": -10, "max": 10}),
-    "gelu_fast": FastGELUActivation,
-    "gelu_new": NewGELUActivation,
-    "gelu_python": (GELUActivation, {"use_gelu_python": True}),
-    "gelu_pytorch_tanh": PytorchGELUTanh,
-    "linear": LinearActivation,
-    "mish": MishActivation,
-    "quick_gelu": QuickGELUActivation,
-    "relu": nn.ReLU,
-    "relu6": nn.ReLU6,
-    "sigmoid": nn.Sigmoid,
-    "silu": SiLUActivation,
-    "swish": SiLUActivation,
-    "tanh": nn.Tanh,
-}
-ACT2FN = ClassInstantier(ACT2CLS)
-
-
-def get_activation(activation_string):
-    if activation_string in ACT2FN:
-        return ACT2FN[activation_string]
-    else:
-        raise KeyError(f"function {activation_string} not found in ACT2FN mapping {list(ACT2FN.keys())}")
-
-
-# For backwards compatibility with: from activations import gelu_python
-gelu_python = get_activation("gelu_python")
-gelu_new = get_activation("gelu_new")
-gelu = get_activation("gelu")
-gelu_fast = get_activation("gelu_fast")
-quick_gelu = get_activation("quick_gelu")
-silu = get_activation("silu")
-mish = get_activation("mish")
-linear_act = get_activation("linear")

htrans/embedding.py

@@ -1,272 +0,0 @@
-import math
-import torch
-import torch.nn as nn
-from htrans.norms import get_norm_fn
-from typing import Tuple
-from einops import repeat
-
-class EmbeddingComponent(nn.Module):
-    """Component embedding including token embedding, positional embedding and (token type embedding)"""
-    def __init__(self, config):
-        # where is token type embds?
-        super(EmbeddingComponent, self).__init__()
-        self.token_embedding = nn.Embedding(config.vocab_size, config.emb_dim, padding_idx=config.pad_token_id)
-        if config.pos_emb == "learned":
-            self.positional_embedding = LearnedPositional(config.emb_dim, config.max_seq_length)
-        elif config.pos_emb == "sinusoidal":
-            self.positional_embedding = SinusoidalPositional(config.emb_dim, config.max_seq_length)
-        elif config.pos_emb == "scaled-sinusoidal":
-            self.positional_embedding = ScaledSinosoidal(config.emb_dim, config.max_seq_length)
-        else:
-            self.positional_embedding = None
-
-        self.dropout = torch.nn.Dropout(p=config.dropout_prob)
-        if config.normalization:
-            self.norm = get_norm_fn(config.norm)(config.emb_dim, eps=config.norm_eps)
-        else:
-            self.norm = torch.nn.Identity()
-
-    def forward(self, input_ids):
-        embeds = self.token_embedding(input_ids)
-        if self.positional_embedding is not None:
-            embeds += self.positional_embedding(input_ids)
-        return self.dropout(self.norm(embeds))
-
-
-class SinusoidalPositional(nn.Module):
-    """
-    The original positional embedding used in 'Attention is all you need'
-    """
-    def __init__(self, emb_dim, max_seq_length=512):
-        super(SinusoidalPositional, self).__init__()
-        pe = torch.zeros(max_seq_length, emb_dim)
-        position = torch.arange(0, max_seq_length, dtype=torch.float).unsqueeze(1)
-        div_term = torch.exp(torch.arange(0, emb_dim, 2) * (-math.log(10000) / emb_dim))
-        pe[:, 0::2] = torch.sin(position * div_term)
-        pe[:, 1::2] = torch.cos(position * div_term)
-        # return a 3D pe so it can be broadcasting on the batch_size dimension
-        self.register_buffer("pe", pe.unsqueeze(0), persistent=False)
-
-    def forward(self, input_ids):
-        r"""Inputs of forward function
-        Args:
-            input_ids: the sequence fed to the positional encoder model (required).
-        Shape:
-            input_ids: [batch size, sequence length]
-            output: [batch size, sequence length, embed dim]
-        Examples:
-            >>> output = pos_encoder(x)
-        """
-        return self.pe[:, : input_ids.shape[1], :]
-
-
-class ScaledSinosoidal(SinusoidalPositional):
-    """Sinusoidal with scaling (see FLASH paper)."""
-
-    def __init__(self, embedding_dim, max_seq_length):
-        super().__init__(embedding_dim, max_seq_length)
-        self.scale_factor = torch.nn.Parameter(torch.tensor([1.0 / embedding_dim**0.5]))
-
-    def forward(self, input_ids):
-        r"""Inputs of forward function
-        Args:
-            x: the sequence fed to the positional encoder model (required).
-        Shape:
-            x: [batch size, sequence length, embed dim]
-            output: [batch size, sequence length, embed dim]
-        Examples:
-            >>> output = pos_encoder(x)
-        """
-        return self.scale_factor * self.pe[:, : input_ids.shape[1], :]
-
-class LearnedPositional(nn.Module):
-    """Shorthand for a learnable embedding."""
-    def __init__(self, emb_dim, max_seq_length):
-        super(LearnedPositional, self).__init__()
-        self.emb = nn.Embedding(max_seq_length, emb_dim)
-        self.register_buffer("position_ids", torch.arange(0, max_seq_length).expand(1, -1))
-
-    def forward(self, input_ids):
-        position_ids = self.position_ids[:, : input_ids.shape[1]]
-        return self.emb(position_ids)
-
-
-# Code stolen from GPT-X:
-class Rotary(torch.nn.Module):
-    def __init__(self, dim, base=10000, def_seq_length=128, seq_dim: int = 0):
-        super().__init__()
-        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
-        self.register_buffer("inv_freq", inv_freq, persistent=True)
-        self.seq_len_cached = def_seq_length
-        self.seq_dim = seq_dim
-        cos_cache, sin_cache = self._get_cos_sin()
-        self.register_buffer("cos_cached", cos_cache, persistent=False)
-        self.register_buffer("sin_cached", sin_cache, persistent=False)
-
-        # Force fusions on batched version
-        def rotate_half(x: torch.Tensor):
-            x1, x2 = x[..., : x.shape[-1] // 2], x[..., x.shape[-1] // 2 :]  # torch.split(x, x.shape[-1] // 2, dim=-1)  # not faster
-            return torch.cat((-x2, x1), dim=-1)
-
-        def rope_fn(cos: torch.Tensor, sin: torch.Tensor, query_layer: torch.Tensor, key_layer: torch.Tensor):
-            QK = torch.cat([query_layer, key_layer], dim=1)
-            rotated = QK * cos + rotate_half(QK) * sin
-            return torch.split(QK, query_layer.shape[1], dim=1)
-
-        self.rope_fn = rope_fn  # handle fusion on module level
-
-    @torch.no_grad()
-    def get_cos_sin_cache(self, x: torch.Tensor):
-        seq_len = x.shape[self.seq_dim]
-        if seq_len != self.seq_len_cached:
-            self.seq_len_cached = x.shape[self.seq_dim]
-            cos_cache, sin_cache = self._get_cos_sin()
-            self.cos_cached = cos_cache.to(x.device)
-            self.sin_cached = sin_cache.to(x.device)
-        return self.cos_cached, self.sin_cached
-
-    def _get_cos_sin(self):
-        t = torch.arange(self.seq_len_cached).type_as(self.inv_freq)
-        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
-        emb = torch.cat((freqs, freqs), dim=-1)
-        if self.seq_dim == 0:
-            return emb.cos()[:, None, None, :].detach(), emb.sin()[:, None, None, :].detach()
-        else:
-            return emb.cos()[None, :, None, :].detach(), emb.sin()[None, :, None, :].detach()
-
-    def forward(self, query_layer: torch.Tensor, key_layer: torch.Tensor):
-        return self.rope_fn(self.cos_cached, self.sin_cached, query_layer, key_layer)
-
-    @torch.jit.export
-    def single_forward(self, inputs: torch.Tensor):
-        """For cases where shapes of Q and K do not match."""
-        cos, sin = self.cos_cached[: inputs.shape[0]], self.sin_cached[: inputs.shape[0]]
-        return inputs * cos + self.rotate_half(inputs) * sin
-
-    def rotate_half(self, x: torch.Tensor):
-        x1, x2 = x[..., : x.shape[-1] // 2], x[..., x.shape[-1] // 2 :]
-        return torch.cat((-x2, x1), dim=-1)  # torch.split(x, x.shape[-1] // 2, dim=-1)  # not faster
-
-
-class RotarySanityCheck(torch.nn.Module):
-    """not again..."""
-
-    def __init__(self, dim, base=10000, def_seq_length=128, seq_dim: int = 0):
-        super().__init__()
-        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
-        self.register_buffer("inv_freq", inv_freq, persistent=True)
-        self.seq_len_cached = def_seq_length
-        self.seq_dim = seq_dim
-        cos_cache, sin_cache = self._get_cos_sin()
-        self.register_buffer("cos_cached", cos_cache, persistent=False)
-        self.register_buffer("sin_cached", sin_cache, persistent=False)
-
-    @torch.no_grad()
-    def get_cos_sin_cache(self, x: torch.Tensor):
-        seq_len = x.shape[self.seq_dim]
-        if seq_len != self.seq_len_cached:
-            self.seq_len_cached = x.shape[self.seq_dim]
-            cos_cache, sin_cache = self._get_cos_sin()
-            self.cos_cached = cos_cache.to(x.device)
-            self.sin_cached = sin_cache.to(x.device)
-        return self.cos_cached, self.sin_cached
-
-    def _get_cos_sin(self):
-        t = torch.arange(self.seq_len_cached).type_as(self.inv_freq)
-        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
-        emb = torch.cat((freqs, freqs), dim=-1)
-        if self.seq_dim == 0:
-            return emb.cos()[:, None, None, :].detach(), emb.sin()[:, None, None, :].detach()
-        else:
-            return emb.cos()[None, :, None, :].detach(), emb.sin()[None, :, None, :].detach()
-
-    def forward(self, query_layer: torch.Tensor, key_layer: torch.Tensor):
-        # cos, sin = self.get_cos_sin_cache(key_layer)
-        # cos, sin = (cos[offset : query_layer.shape[0] + offset, ...], sin[offset : query_layer.shape[0] + offset, ...])
-        cos, sin = self.cos_cached, self.sin_cached
-        return (query_layer * cos) + (self.rotate_half(query_layer) * sin), (key_layer * cos) + (self.rotate_half(key_layer) * sin)
-
-    def rotate_half(self, x: torch.Tensor):
-        x1, x2 = x[..., : x.shape[-1] // 2], x[..., x.shape[-1] // 2 :]
-        return torch.cat((-x2, x1), dim=-1)  # torch.split(x, x.shape[-1] // 2, dim=-1)  # not faster
-
-    @torch.jit.export
-    def single_forward(self, inputs: torch.Tensor):
-        """For cases where shapes of Q and K do not match."""
-        cos, sin = self.cos_cached[: inputs.shape[0]], self.sin_cached[: inputs.shape[0]]
-        return inputs * cos + self.rotate_half(inputs) * sin
-
-
-# Adapted from https://github.com/HazyResearch/flash-attention/blob/main/flash_attn/rotary.py who adapted from
-# Adapted from https://github.com/facebookresearch/xformers/blob/main/xformers/components/positional_embedding/rotary.py
-class RotaryEleutherAI(torch.nn.Module):
-    """
-    The rotary position embeddings from RoFormer_ (Su et. al).
-    A crucial insight from the method is that the query and keys are
-    transformed by rotation matrices which depend on the relative positions.
-    Other implementations are available in the Rotary Transformer repo_ and in
-    GPT-NeoX_, GPT-NeoX was an inspiration
-    .. _RoFormer: https://arxiv.org/abs/2104.09864
-    .. _repo: https://github.com/ZhuiyiTechnology/roformer
-    .. _GPT-NeoX: https://github.com/EleutherAI/gpt-neox
-    """
-
-    _seq_len_cached: int
-    # _cos_cached: Optional[torch.Tensor]
-    # _sin_cached: Optional[torch.Tensor]
-
-    def __init__(self, dim_model: int, *_, **__):
-        super().__init__()
-        # Generate and save the inverse frequency buffer (non trainable)
-        inv_freq = 1.0 / (10000 ** (torch.arange(0, dim_model, 2).float() / dim_model))
-        self.register_buffer("inv_freq", inv_freq)
-
-        _cos_cached, _sin_cached = self._update_cos_sin_tables(torch.randn(1, 128, 1), seq_dimension=-2)
-        self.register_buffer("_cos_cached", _cos_cached, persistent=False)
-        self.register_buffer("_sin_cached", _sin_cached, persistent=False)
-
-    @torch.jit.ignore
-    def _update_cos_sin_tables(self, x: torch.Tensor, seq_dimension: int = -2) -> Tuple[torch.Tensor, torch.Tensor]:
-        seq_len = x.shape[seq_dimension]
-
-        # Reset the tables if the sequence length has changed,
-        # or if we're on a new device (possibly due to tracing for instance)
-        # if seq_len != self._seq_len_cached:  # or self._cos_cached.device != x.device or self._cos_cached.dtype != x.dtype:
-        self._seq_len_cached = seq_len
-        t = torch.arange(x.shape[seq_dimension], device=x.device, dtype=self.inv_freq.dtype)
-        # Don't do einsum, it converts fp32 to fp16
-        # freqs = torch.einsum("i,j->ij", t, self.inv_freq)
-        freqs = torch.outer(t, self.inv_freq)
-        cos_cached = repeat(torch.cos(freqs).to(x.dtype), "... d -> ... (d 2)")
-        sin_cached = repeat(torch.sin(freqs).to(x.dtype), "... d -> ... (d 2)")
-
-        return cos_cached, sin_cached
-
-    def forward(self, q: torch.Tensor, k: torch.Tensor, seq_dimension: int = -2) -> Tuple[torch.Tensor, torch.Tensor]:
-        # assert seq_dimension in [-2, -3]  # Either (bs, h, s, d) or (bs, s, h, d)
-        # self._cos_cached, self._sin_cached = self._update_cos_sin_tables(k, seq_dimension=seq_dimension)
-
-        return (
-            apply_rotary_pos_emb(q, self._cos_cached, self._sin_cached, seq_dimension),
-            apply_rotary_pos_emb(k, self._cos_cached, self._sin_cached, seq_dimension),
-        )
-
-
-def rotate_half(x: torch.Tensor):
-    x = x.unflatten(dim=-1, sizes=(-1, 2))
-    x1, x2 = x.unbind(dim=-1)
-    rotated_x = torch.stack((-x2, x1), dim=-1)
-    return rotated_x.flatten(start_dim=-2)
-
-
-@torch.jit.script
-def apply_rotary_pos_emb(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor, seq_dimension: int = -2):
-    # NOTE: This could probably be moved to Triton
-
-    # Handle a possible sequence length mismatch in between q and k
-    cos = cos[: x.shape[seq_dimension], :]
-    sin = sin[: x.shape[seq_dimension], :]
-    if seq_dimension == -3:
-        cos = cos[:, None, :]
-        sin = sin[:, None, :]
-    return (x * cos) + (rotate_half(x) * sin)

htrans/model/__init__.py

@@ -1,2 +0,0 @@
-from .modeling_htrans import HTransForPreTraining, HTransModel, HTransForSequenceClassification
-from .configuration_htrans import HTransConfig

htrans/model/configuration_htrans.py

@@ -1,130 +0,0 @@
-from transformers import PretrainedConfig
-
-
-class HTransConfig(PretrainedConfig):
-    r"""
-    This is the configuration class to store the configuration of a [`BertModel`] or a [`TFBertModel`]. It is used to
-    instantiate a BERT model according to the specified arguments, defining the model architecture. Instantiating a
-    configuration with the defaults will yield a similar configuration to that of the BERT
-    [bert-base-uncased](https://huggingface.co/bert-base-uncased) architecture.
-
-    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
-    documentation from [`PretrainedConfig`] for more information.
-
-
-    Args:
-        vocab_size (`int`, *optional*, defaults to 30522):
-            Vocabulary size of the BERT model. Defines the number of different tokens that can be represented by the
-            `inputs_ids` passed when calling [`BertModel`] or [`TFBertModel`].
-        hidden_size (`int`, *optional*, defaults to 768):
-            Dimensionality of the encoder layers and the pooler layer.
-        num_hidden_layers (`int`, *optional*, defaults to 12):
-            Number of hidden layers in the Transformer encoder.
-        num_attention_heads (`int`, *optional*, defaults to 12):
-            Number of attention heads for each attention layer in the Transformer encoder.
-        intermediate_size (`int`, *optional*, defaults to 3072):
-            Dimensionality of the "intermediate" (often named feed-forward) layer in the Transformer encoder.
-        hidden_act (`str` or `Callable`, *optional*, defaults to `"gelu"`):
-            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
-            `"relu"`, `"silu"` and `"gelu_new"` are supported.
-        hidden_dropout_prob (`float`, *optional*, defaults to 0.1):
-            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
-        attention_probs_dropout_prob (`float`, *optional*, defaults to 0.1):
-            The dropout ratio for the attention probabilities.
-        max_position_embeddings (`int`, *optional*, defaults to 512):
-            The maximum sequence length that this model might ever be used with. Typically set this to something large
-            just in case (e.g., 512 or 1024 or 2048).
-        type_vocab_size (`int`, *optional*, defaults to 2):
-            The vocabulary size of the `token_type_ids` passed when calling [`BertModel`] or [`TFBertModel`].
-        initializer_range (`float`, *optional*, defaults to 0.02):
-            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
-        layer_norm_eps (`float`, *optional*, defaults to 1e-12):
-            The epsilon used by the layer normalization layers.
-        position_embedding_type (`str`, *optional*, defaults to `"absolute"`):
-            Type of position embedding. Choose one of `"absolute"`, `"relative_key"`, `"relative_key_query"`. For
-            positional embeddings use `"absolute"`. For more information on `"relative_key"`, please refer to
-            [Self-Attention with Relative Position Representations (Shaw et al.)](https://arxiv.org/abs/1803.02155).
-            For more information on `"relative_key_query"`, please refer to *Method 4* in [Improve Transformer Models
-            with Better Relative Position Embeddings (Huang et al.)](https://arxiv.org/abs/2009.13658).
-        is_decoder (`bool`, *optional*, defaults to `False`):
-            Whether the model is used as a decoder or not. If `False`, the model is used as an encoder.
-        use_cache (`bool`, *optional*, defaults to `True`):
-            Whether or not the model should return the last key/values attentions (not used by all models). Only
-            relevant if `config.is_decoder=True`.
-        classifier_dropout (`float`, *optional*):
-            The dropout ratio for the classification head.
-
-    Examples:
-
-    ```python
-    >>> from transformers import BertConfig, BertModel
-
-    >>> # Initializing a BERT bert-base-uncased style configuration
-    >>> configuration = BertConfig()
-
-    >>> # Initializing a model (with random weights) from the bert-base-uncased style configuration
-    >>> model = BertModel(configuration)
-
-    >>> # Accessing the model configuration
-    >>> configuration = model.config
-    ```"""
-    model_type = "bert"
-
-    def __init__(
-        self,
-        vocab_size=32768,
-        hidden_size=768,
-        num_hidden_layers=12,
-        num_attention_heads=12,
-        intermediate_size=3072,
-        hidden_act="gelu",
-        hidden_dropout_prob=0.1,
-        attention_probs_dropout_prob=0.1,
-        max_position_embeddings=512,
-        type_vocab_size=2,
-        initializer_range=0.02,
-        layer_norm_eps=1e-12,
-        position_embedding_type="absolute",
-        use_cache=True,
-        classifier_dropout=0.1,
-        use_bias=True,
-        norm_scheme="post",
-        pool_scheme="first-token",
-        pos_emb="sinusoidal",
-        prediction_head=True,
-        max_sent_length=64,
-        max_sec_length=8,
-        max_doc_length=1,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-
-        self.vocab_size = vocab_size
-        self.hidden_size = hidden_size
-        self.num_hidden_layers = num_hidden_layers
-        self.num_attention_heads = num_attention_heads
-        self.hidden_act = hidden_act
-        self.intermediate_size = intermediate_size
-        self.hidden_dropout_prob = hidden_dropout_prob
-        self.attention_probs_dropout_prob = attention_probs_dropout_prob
-        self.type_vocab_size = type_vocab_size
-        self.initializer_range = initializer_range
-        self.layer_norm_eps = layer_norm_eps
-        self.position_embedding_type = position_embedding_type
-        self.use_cache = use_cache
-        self.classifier_dropout = classifier_dropout
-        self.use_bias = use_bias
-        self.norm_scheme = norm_scheme
-        self.pool_scheme = pool_scheme
-        self.pos_emb = pos_emb
-        self.prediction_head = prediction_head
-        self.max_sec_length = max_sec_length
-        self.max_sent_length = max_sent_length
-        self.max_doc_length = max_doc_length
-        self.max_position_embeddings = max_sec_length * max_sent_length * max_doc_length
-        self.bos_token_id = kwargs.pop("bos_token_id", None)
-        self.pad_token_id = kwargs.pop("pad_token_id", None)
-        self.eos_token_id = kwargs.pop("eos_token_id", None)
-        self.sep_token_id = kwargs.pop("sep_token_id", None)
-
-

htrans/model/modeling_htrans.py

@@ -1,1283 +0,0 @@
-"""This is a script for modeling bert under our (huggingface) scheme. Most of the code is directly copied from huggingface transformers for reference"""
-import os
-import math
-import torch
-import logging
-import torch.nn as nn
-from ..act_fns import ACT2FN
-from transformers import PreTrainedModel
-from ..pytorch_utils import find_pruneable_heads_and_indices, prune_linear_layer, apply_chunking_to_forward
-from ..embedding import SinusoidalPositional, ScaledSinosoidal, LearnedPositional
-from transformers.modeling_outputs import BaseModelOutputWithPastAndCrossAttentions, ModelOutput, BaseModelOutputWithPoolingAndCrossAttentions, SequenceClassifierOutput
-from .configuration_htrans import HTransConfig
-from typing import Optional, Tuple, Union, List
-from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
-
-logger = logging.getLogger(__name__)
-
-
-def load_tf_weights_in_bert(model, config, tf_checkpoint_path):
-    """Load tf checkpoints in a pytorch model."""
-    try:
-        import re
-
-        import numpy as np
-        import tensorflow as tf
-    except ImportError:
-        logger.error(
-            "Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see "
-            "https://www.tensorflow.org/install/ for installation instructions."
-        )
-        raise
-    tf_path = os.path.abspath(tf_checkpoint_path)
-    logger.info(f"Converting TensorFlow checkpoint from {tf_path}")
-    # Load weights from TF model
-    init_vars = tf.train.list_variables(tf_path)
-    names = []
-    arrays = []
-    for name, shape in init_vars:
-        logger.info(f"Loading TF weight {name} with shape {shape}")
-        array = tf.train.load_variable(tf_path, name)
-        names.append(name)
-        arrays.append(array)
-
-    for name, array in zip(names, arrays):
-        name = name.split("/")
-        # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v
-        # which are not required for using pretrained model
-        if any(
-            n in ["adam_v", "adam_m", "AdamWeightDecayOptimizer", "AdamWeightDecayOptimizer_1", "global_step"]
-            for n in name
-        ):
-            logger.info(f"Skipping {'/'.join(name)}")
-            continue
-        pointer = model
-        for m_name in name:
-            if re.fullmatch(r"[A-Za-z]+_\d+", m_name):
-                scope_names = re.split(r"_(\d+)", m_name)
-            else:
-                scope_names = [m_name]
-            if scope_names[0] == "kernel" or scope_names[0] == "gamma":
-                pointer = getattr(pointer, "weight")
-            elif scope_names[0] == "output_bias" or scope_names[0] == "beta":
-                pointer = getattr(pointer, "bias")
-            elif scope_names[0] == "output_weights":
-                pointer = getattr(pointer, "weight")
-            elif scope_names[0] == "squad":
-                pointer = getattr(pointer, "classifier")
-            else:
-                try:
-                    pointer = getattr(pointer, scope_names[0])
-                except AttributeError:
-                    logger.info(f"Skipping {'/'.join(name)}")
-                    continue
-            if len(scope_names) >= 2:
-                num = int(scope_names[1])
-                pointer = pointer[num]
-        if m_name[-11:] == "_embeddings":
-            pointer = getattr(pointer, "weight")
-        elif m_name == "kernel":
-            array = np.transpose(array)
-        try:
-            if pointer.shape != array.shape:
-                raise ValueError(f"Pointer shape {pointer.shape} and array shape {array.shape} mismatched")
-        except AssertionError as e:
-            e.args += (pointer.shape, array.shape)
-            raise
-        logger.info(f"Initialize PyTorch weight {name}")
-        pointer.data = torch.from_numpy(array)
-    return model
-
-class PositionEmbeddings(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        if config.pos_emb == "learned":
-            self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
-        elif config.pos_emb == "sinusoidal":
-            self.position_embeddings = SinusoidalPositional(config.hidden_size, config.max_position_embeddings)
-        elif config.pos_emb == "scaled-sinusoidal":
-            self.position_embeddings = ScaledSinosoidal(config.hidden_size, config.max_position_embeddings)
-        else:
-            raise NotImplementedError(f"Positional embedding {config.pos_emb} is not a valid choice")
-        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.register_buffer("sec_position_ids", torch.arange(config.max_sec_length*config.max_doc_length+config.max_doc_length).expand((1, -1)))
-        self.register_buffer("doc_position_ids", torch.arange(config.max_doc_length).expand((1, -1)))
-
-    def forward(self, embeddings, hierarchy="sec"):
-        if self.position_embedding_type == "absolute":
-            position_embeddings = self.position_embeddings(self.sec_position_ids if hierarchy=="sec" else self.doc_position_ids)
-            embeddings += position_embeddings
-        embeddings = self.LayerNorm(embeddings)
-        embeddings = self.dropout(embeddings)
-        return embeddings
-
-class HTransEmbeddings(nn.Module):
-    """Construct the embeddings from word, position and token_type embeddings."""
-
-    def __init__(self, config):
-        super().__init__()
-        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
-        if config.pos_emb == "learned":
-            self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
-        elif config.pos_emb == "sinusoidal":
-            self.position_embeddings = SinusoidalPositional(config.hidden_size, config.max_position_embeddings)
-        elif config.pos_emb == "scaled-sinusoidal":
-            self.position_embeddings = ScaledSinosoidal(config.hidden_size, config.max_position_embeddings)
-        else:
-            raise NotImplementedError(f"Positional embedding {config.pos_emb} is not a valid choice")
-        # self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
-        # For now we don't use token type embeddings but might need it back in the future
-        # self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
-
-        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
-        # any TensorFlow checkpoint file
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
-        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
-        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
-        self.register_buffer(
-            "token_type_ids", torch.zeros(self.position_ids.size(), dtype=torch.long), persistent=False
-        )
-
-    def forward(
-        self,
-        input_ids: Optional[torch.LongTensor] = None,
-        token_type_ids: Optional[torch.LongTensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        past_key_values_length: int = 0,
-    ) -> torch.Tensor:
-        if input_ids is not None:
-            input_shape = input_ids.size()
-        else:
-            input_shape = inputs_embeds.size()[:-1]
-
-        seq_length = input_shape[1]
-
-        if position_ids is None:
-            position_ids = self.position_ids[:, past_key_values_length : seq_length + past_key_values_length]
-
-        # Setting the token_type_ids to the registered buffer in constructor where it is all zeros, which usually occurs
-        # when its auto-generated, registered buffer helps users when tracing the model without passing token_type_ids, solves
-        # issue #5664
-        # if token_type_ids is None:
-        #     if hasattr(self, "token_type_ids"):
-        #         buffered_token_type_ids = self.token_type_ids[:, :seq_length]
-        #         buffered_token_type_ids_expanded = buffered_token_type_ids.expand(input_shape[0], seq_length)
-        #         token_type_ids = buffered_token_type_ids_expanded
-        #     else:
-        #         token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=self.position_ids.device)
-
-        if inputs_embeds is None:
-            inputs_embeds = self.word_embeddings(input_ids)
-        # token_type_embeddings = self.token_type_embeddings(token_type_ids)
-
-        # embeddings = inputs_embeds + token_type_embeddings
-        embeddings = inputs_embeds
-        if self.position_embedding_type == "absolute":
-            position_embeddings = self.position_embeddings(position_ids)
-            embeddings += position_embeddings
-        embeddings = self.LayerNorm(embeddings)
-        embeddings = self.dropout(embeddings)
-        return embeddings
-
-
-class HTransSelfAttention(nn.Module):
-    def __init__(self, config, position_embedding_type=None,  sent_length=512, sec_length=1, doc_length=1):
-        super().__init__()
-        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
-            raise ValueError(
-                f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention "
-                f"heads ({config.num_attention_heads})"
-            )
-
-        self.num_attention_heads = config.num_attention_heads
-        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
-        self.all_head_size = self.num_attention_heads * self.attention_head_size
-
-        self.query = nn.Linear(config.hidden_size, self.all_head_size, bias=config.use_bias)
-        self.key = nn.Linear(config.hidden_size, self.all_head_size, bias=config.use_bias)
-        self.value = nn.Linear(config.hidden_size, self.all_head_size, bias=config.use_bias)
-
-        self.sent_length = sent_length
-        self.sec_length = sec_length
-        self.doc_length = doc_length
-
-        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
-        self.position_embedding_type = position_embedding_type or getattr(
-            config, "position_embedding_type", "absolute"
-        )
-        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
-            self.max_position_embeddings = config.max_position_embeddings
-            self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size)
-
-        self.is_decoder = config.is_decoder
-
-    def transpose_for_scores(self, x: torch.Tensor) -> torch.Tensor:
-        if self.sec_length == 1:
-            new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
-            x = x.view(new_x_shape)
-            return x.permute(0, 2, 1, 3)
-        elif self.doc_length == 1:
-            new_x_shape = x.size()[:-2] + (self.sec_length, self.sent_length, self.num_attention_heads, self.attention_head_size)
-            x = x.view(new_x_shape)
-            return x.permute(0, 1, 3, 2, 4)
-        else:
-            new_x_shape = x.size()[:-2] + (self.doc_length, self.sec_length, self.sent_length, self.num_attention_heads, self.attention_head_size)
-            x = x.view(new_x_shape)
-            return x.permute(0, 1, 2, 4, 3, 5)
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.FloatTensor] = None,
-        head_mask: Optional[torch.FloatTensor] = None,
-        encoder_hidden_states: Optional[torch.FloatTensor] = None,
-        encoder_attention_mask: Optional[torch.FloatTensor] = None,
-        past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
-        output_attentions: Optional[bool] = False,
-    ) -> Tuple[torch.Tensor]:
-        mixed_query_layer = self.query(hidden_states)
-
-        # If this is instantiated as a cross-attention module, the keys
-        # and values come from an encoder; the attention mask needs to be
-        # such that the encoder's padding tokens are not attended to.
-        is_cross_attention = encoder_hidden_states is not None
-
-        if is_cross_attention and past_key_value is not None:
-            # reuse k,v, cross_attentions
-            key_layer = past_key_value[0]
-            value_layer = past_key_value[1]
-            attention_mask = encoder_attention_mask
-        elif is_cross_attention:
-            key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
-            value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
-            attention_mask = encoder_attention_mask
-        elif past_key_value is not None:
-            key_layer = self.transpose_for_scores(self.key(hidden_states))
-            value_layer = self.transpose_for_scores(self.value(hidden_states))
-            key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
-            value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
-        else:
-            key_layer = self.transpose_for_scores(self.key(hidden_states))
-            value_layer = self.transpose_for_scores(self.value(hidden_states))
-
-        query_layer = self.transpose_for_scores(mixed_query_layer)
-
-        use_cache = past_key_value is not None
-        if self.is_decoder:
-            # if cross_attention save Tuple(torch.Tensor, torch.Tensor) of all cross attention key/value_states.
-            # Further calls to cross_attention layer can then reuse all cross-attention
-            # key/value_states (first "if" case)
-            # if uni-directional self-attention (decoder) save Tuple(torch.Tensor, torch.Tensor) of
-            # all previous decoder key/value_states. Further calls to uni-directional self-attention
-            # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
-            # if encoder bi-directional self-attention `past_key_value` is always `None`
-            past_key_value = (key_layer, value_layer)
-
-        # Take the dot product between "query" and "key" to get the raw attention scores.
-        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
-        # if self.seg_num == 1:
-        #     attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
-        # else:
-        #     attention_scores = torch.concatenate([torch.matmul(query_layer[:, :, j * self.seg_length: (j + 1) * self.seg_length, :], key_layer[:, :, j * self.seg_length: (j + 1) * self.seg_length, :].transpose(-1, -2)) for j in range(self.seg_num)], dim=-1)
-        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
-            # TODO: relative positional embedding for hierarchical attention
-            query_length, key_length = query_layer.shape[2], key_layer.shape[2]
-            if use_cache:
-                position_ids_l = torch.tensor(key_length - 1, dtype=torch.long, device=hidden_states.device).view(
-                    -1, 1
-                )
-            else:
-                position_ids_l = torch.arange(query_length, dtype=torch.long, device=hidden_states.device).view(-1, 1)
-            position_ids_r = torch.arange(key_length, dtype=torch.long, device=hidden_states.device).view(1, -1)
-            distance = position_ids_l - position_ids_r
-
-            positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
-            positional_embedding = positional_embedding.to(dtype=query_layer.dtype)  # fp16 compatibility
-
-            if self.position_embedding_type == "relative_key":
-                relative_position_scores = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
-                attention_scores = attention_scores + relative_position_scores
-            elif self.position_embedding_type == "relative_key_query":
-                relative_position_scores_query = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
-                relative_position_scores_key = torch.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
-                attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key
-        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
-        if attention_mask is not None:
-            if self.sec_length > 1:
-                if self.doc_length > 1:
-                    new_mask_shape = (attention_mask.shape[0], self.doc_length, self.sec_length, 1, 1, self.sent_length)
-                else:
-                    new_mask_shape = (attention_mask.shape[0], self.sec_length, 1, 1, self.sent_length)
-                attention_mask = attention_mask.view(new_mask_shape)
-            # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
-            attention_scores = attention_scores + attention_mask
-
-        # Normalize the attention scores to probabilities.
-        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
-
-        # This is actually dropping out entire tokens to attend to, which might
-        # seem a bit unusual, but is taken from the original Transformer paper.
-        attention_probs = self.dropout(attention_probs)
-
-        # Mask heads if we want to
-        if head_mask is not None:
-            if self.sec_length > 1:
-                if self.doc_length > 1:
-                    new_mask_shape = (head_mask.shape[0], self.doc_length, self.sec_length, 1, 1, self.sent_length)
-                else:
-                    new_mask_shape = (head_mask.shape[0], self.sec_length, 1, 1, self.sent_length)
-                head_mask = head_mask.view(new_mask_shape)
-            attention_probs = attention_probs * head_mask
-
-        context_layer = torch.matmul(attention_probs, value_layer)
-        if self.doc_length > 1:
-            context_layer = context_layer.permute(0, 1, 2, 4, 3, 5).contiguous()
-            new_context_layer_shape = context_layer.size()[:-5] + (self.doc_length * self.sec_length * self.sent_length, self.all_head_size,)
-        elif self.sec_length > 1:
-            context_layer = context_layer.permute(0, 1, 3, 2, 4).contiguous()
-            new_context_layer_shape = context_layer.size()[:-4] + (self.sec_length * self.sent_length, self.all_head_size,)
-        else:
-            context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
-            new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
-
-        context_layer = context_layer.view(new_context_layer_shape)
-
-        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
-
-        if self.is_decoder:
-            outputs = outputs + (past_key_value,)
-        return outputs
-
-
-class HTransSelfOutput(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size, bias=config.use_bias)
-        if config.norm_scheme == "post":
-            self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.norm_scheme = config.norm_scheme
-
-    def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        hidden_states = hidden_states + input_tensor
-        if self.norm_scheme == "post":
-            hidden_states = self.LayerNorm(hidden_states)
-
-        return hidden_states
-
-
-class HTransAttention(nn.Module):
-    def __init__(self, config, position_embedding_type=None, sent_length=512, sec_length=1, doc_length=1):
-        super().__init__()
-        self.self = HTransSelfAttention(config, position_embedding_type=position_embedding_type, sent_length=sent_length, sec_length=sec_length, doc_length=doc_length)
-        self.output = HTransSelfOutput(config)
-        self.pruned_heads = set()
-        self.norm_scheme = config.norm_scheme
-        if self.norm_scheme == "pre":
-            self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-
-    def prune_heads(self, heads):
-        if len(heads) == 0:
-            return
-        heads, index = find_pruneable_heads_and_indices(
-            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
-        )
-
-        # Prune linear layers
-        self.self.query = prune_linear_layer(self.self.query, index)
-        self.self.key = prune_linear_layer(self.self.key, index)
-        self.self.value = prune_linear_layer(self.self.value, index)
-        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
-
-        # Update hyper params and store pruned heads
-        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
-        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
-        self.pruned_heads = self.pruned_heads.union(heads)
-
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.FloatTensor] = None,
-        head_mask: Optional[torch.FloatTensor] = None,
-        encoder_hidden_states: Optional[torch.FloatTensor] = None,
-        encoder_attention_mask: Optional[torch.FloatTensor] = None,
-        past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
-        output_attentions: Optional[bool] = False,
-    ) -> Tuple[torch.Tensor]:
-        if self.norm_scheme == "pre":
-            input_tensors = hidden_states
-            hidden_states = self.LayerNorm(hidden_states)
-        else:
-            input_tensors = hidden_states
-        self_outputs = self.self(
-            hidden_states,
-            attention_mask,
-            head_mask,
-            encoder_hidden_states,
-            encoder_attention_mask,
-            past_key_value,
-            output_attentions,
-        )
-        attention_output = self.output(self_outputs[0], input_tensors)
-        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
-        return outputs
-
-
-class HTransIntermediate(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.intermediate_size, bias=config.use_bias)
-        self.norm_scheme = config.norm_scheme
-        if self.norm_scheme == "pre":
-            self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        if isinstance(config.hidden_act, str):
-            self.intermediate_act_fn = ACT2FN[config.hidden_act]
-        else:
-            self.intermediate_act_fn = config.hidden_act
-
-    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
-        if self.norm_scheme == "pre":
-            hidden_states = self.LayerNorm(hidden_states)
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.intermediate_act_fn(hidden_states)
-        return hidden_states
-
-
-class HTransOutput(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.intermediate_size, config.hidden_size, bias=config.use_bias)
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-        self.norm_scheme = config.norm_scheme
-
-    def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        hidden_states = hidden_states + input_tensor
-        if self.norm_scheme == "post":
-            hidden_states = self.LayerNorm(hidden_states)
-        return hidden_states
-
-
-class HTransLayer(nn.Module):
-    def __init__(self, config, sent_length=512, sec_length=1, doc_length=1):
-        super().__init__()
-        self.chunk_size_feed_forward = config.chunk_size_feed_forward
-        self.seq_len_dim = 1
-        self.attention = HTransAttention(config, sent_length=sent_length, sec_length=sec_length, doc_length=doc_length)
-        self.is_decoder = config.is_decoder
-        self.add_cross_attention = config.add_cross_attention
-        if self.add_cross_attention:
-            if not self.is_decoder:
-                raise ValueError(f"{self} should be used as a decoder model if cross attention is added")
-            self.crossattention = HTransAttention(config, position_embedding_type="absolute", sent_length=sent_length, sec_length=sec_length, doc_length=doc_length)
-        self.intermediate = HTransIntermediate(config)
-        self.output = HTransOutput(config)
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.FloatTensor] = None,
-        head_mask: Optional[torch.FloatTensor] = None,
-        encoder_hidden_states: Optional[torch.FloatTensor] = None,
-        encoder_attention_mask: Optional[torch.FloatTensor] = None,
-        past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
-        output_attentions: Optional[bool] = False,
-    ) -> Tuple[torch.Tensor]:
-        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
-        self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
-        self_attention_outputs = self.attention(
-            hidden_states,
-            attention_mask,
-            head_mask,
-            output_attentions=output_attentions,
-            past_key_value=self_attn_past_key_value,
-        )
-        attention_output = self_attention_outputs[0]
-
-        # if decoder, the last output is tuple of self-attn cache
-        if self.is_decoder:
-            outputs = self_attention_outputs[1:-1]
-            present_key_value = self_attention_outputs[-1]
-        else:
-            outputs = self_attention_outputs[1:]  # add self attentions if we output attention weights
-
-        cross_attn_present_key_value = None
-        if self.is_decoder and encoder_hidden_states is not None:
-            if not hasattr(self, "crossattention"):
-                raise ValueError(
-                    f"If `encoder_hidden_states` are passed, {self} has to be instantiated with cross-attention layers"
-                    " by setting `config.add_cross_attention=True`"
-                )
-
-            # cross_attn cached key/values tuple is at positions 3,4 of past_key_value tuple
-            cross_attn_past_key_value = past_key_value[-2:] if past_key_value is not None else None
-            cross_attention_outputs = self.crossattention(
-                attention_output,
-                attention_mask,
-                head_mask,
-                encoder_hidden_states,
-                encoder_attention_mask,
-                cross_attn_past_key_value,
-                output_attentions,
-            )
-            attention_output = cross_attention_outputs[0]
-            outputs = outputs + cross_attention_outputs[1:-1]  # add cross attentions if we output attention weights
-
-            # add cross-attn cache to positions 3,4 of present_key_value tuple
-            cross_attn_present_key_value = cross_attention_outputs[-1]
-            present_key_value = present_key_value + cross_attn_present_key_value
-
-        layer_output = apply_chunking_to_forward(
-            self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
-        )
-        outputs = (layer_output,) + outputs
-
-        # if decoder, return the attn key/values as the last output
-        if self.is_decoder:
-            outputs = outputs + (present_key_value,)
-
-        return outputs
-
-    def feed_forward_chunk(self, attention_output):
-        intermediate_output = self.intermediate(attention_output)
-        layer_output = self.output(intermediate_output, attention_output)
-        return layer_output
-
-
-# class HTransLayer(nn.Module):
-#     def __init__(self, config):
-#         super().__init__()
-#         self.sent_trans_layer_1 = TransformerLayer(config)
-#         self.sent_trans_layer_2 = TransformerLayer(config)
-#         self.sec_trans_layer = TransformerLayer(config)
-#         self.max_sent_length = config.max_sent_length
-#         self.max_sec_length = config.max_sec_length
-#
-#     def forward(
-#         self,
-#         hidden_states: torch.Tensor,
-#         attention_mask: Optional[torch.FloatTensor] = None,
-#         head_mask: Optional[torch.FloatTensor] = None,
-#         encoder_hidden_states: Optional[torch.FloatTensor] = None,
-#         encoder_attention_mask: Optional[torch.FloatTensor] = None,
-#         past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
-#         output_attentions: Optional[bool] = False,
-#     ) -> Tuple[torch.Tensor]:
-#         # TODO: adapt head_mask, encoder_hidden_states, encoder_attention_mask, past_key_value
-#         sent_outputs = [self.sent_trans_layer_1(
-#             hidden_states[:, i*self.max_sent_length: (i+1)*self.max_sent_length, :],
-#             attention_mask[:, :, :, i*self.max_sent_length: (i+1)*self.max_sent_length] if attention_mask is not None else None,
-#             output_attentions=output_attentions
-#         )[0] for i in range(self.max_sec_length)]
-#         sec_outputs = self.sec_trans_layer(torch.concatenate([i[:, 0:1, :] for i in sent_outputs], axis=1))[0]
-#         hidden_sec_states = hidden_states.clone()
-#         hidden_sec_states[:, [i*self.max_sent_length for i in range(self.max_sec_length)]] = sec_outputs
-#         layer_outputs = [self.sent_trans_layer_2(
-#             hidden_sec_states[:, i * self.max_sent_length: (i + 1) * self.max_sent_length, :],
-#             attention_mask[:, :, :,
-#             i * self.max_sent_length: (i + 1) * self.max_sent_length] if attention_mask is not None else None,
-#             output_attentions=output_attentions
-#         )[0] for i in range(self.max_sec_length)]
-#         return (torch.concatenate(layer_outputs, axis=1), )
-
-class HTransEncoder(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.config = config
-        self.hi_position_embeddings = PositionEmbeddings(config)
-        self.sent_layer = nn.ModuleList([HTransLayer(config, sent_length=config.max_sent_length, sec_length=config.max_sec_length, doc_length=config.max_doc_length) for _ in range(config.num_hidden_layers)])
-        if config.max_doc_length > 1:
-            self.doc_layer = nn.ModuleList(
-                [HTransLayer(config, sent_length=config.max_doc_length) for _ in range(config.num_hidden_layers)])
-        self.sec_layer = nn.ModuleList([HTransLayer(config, sent_length=self.config.max_sec_length + 1, sec_length=config.max_doc_length) for _ in range(config.num_hidden_layers)])
-        self.gradient_checkpointing = False
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.FloatTensor] = None,
-        head_mask: Optional[torch.FloatTensor] = None,
-        sec_mask: Optional[torch.FloatTensor] = None,
-        doc_mask: Optional[torch.FloatTensor] = None,
-        encoder_hidden_states: Optional[torch.FloatTensor] = None,
-        encoder_attention_mask: Optional[torch.FloatTensor] = None,
-        past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
-        use_cache: Optional[bool] = None,
-        output_attentions: Optional[bool] = False,
-        output_hidden_states: Optional[bool] = False,
-        return_dict: Optional[bool] = True,
-        sec_head_emb: Optional[torch.Tensor] = None,
-        doc_head_emb: Optional[torch.Tensor] = None,
-    ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPastAndCrossAttentions]:
-        all_hidden_states = () if output_hidden_states else None
-        all_self_attentions = () if output_attentions else None
-        all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None
-
-        next_decoder_cache = () if use_cache else None
-        if self.config.max_doc_length > 1:
-            sec_head_emb = sec_head_emb.unsqueeze(1).expand(-1, self.config.max_doc_length, -1, -1)
-        sec_new_shape = (hidden_states.shape[0], self.config.max_doc_length, self.config.max_sec_length, hidden_states.shape[-1])
-
-        for i, layer_module in enumerate(self.sent_layer):
-            if output_hidden_states:
-                all_hidden_states = all_hidden_states + (hidden_states,)
-
-            layer_head_mask = head_mask[i] if head_mask is not None else None
-            past_key_value = past_key_values[i] if past_key_values is not None else None
-
-            if self.gradient_checkpointing and self.training:
-                # TODO: add gradient checkpointing support for hierarchical attention
-                if use_cache:
-                    logger.warning(
-                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
-                    )
-                    use_cache = False
-
-                def create_custom_forward(module):
-                    def custom_forward(*inputs):
-                        return module(*inputs, past_key_value, output_attentions)
-
-                    return custom_forward
-
-                layer_outputs = torch.utils.checkpoint.checkpoint(
-                    create_custom_forward(layer_module),
-                    hidden_states,
-                    attention_mask,
-                    layer_head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                )
-            else:
-                layer_outputs = layer_module(
-                    hidden_states,
-                    attention_mask,
-                    layer_head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                    past_key_value,
-                    output_attentions,
-                )
-
-                hidden_states = layer_outputs[0]
-                if self.config.pool_scheme == "first-token":
-                    # sec_inputs = torch.select(hidden_states, -2, 0)
-                    sec_inputs = hidden_states[:, range(0, self.config.max_doc_length*self.config.max_sec_length*self.config.max_sent_length, self.config.max_sent_length) ,:]
-                elif self.config.pool_scheme == "avg":
-                    sec_inputs = torch.mean(hidden_states.view((hidden_states.shape[0], self.config.max_sec_length, self.config.max_sent_length, hidden_states.shape[-1])), dim=-2)
-                elif self.config.pool_scheme == "max":
-                    sec_inputs = torch.max(hidden_states.view((hidden_states.shape[0], self.config.max_sec_length, self.config.max_sent_length, hidden_states.shape[-1])), dim=-2)[0]
-                else:
-                    raise NotImplementedError(f"Pooling method {self.config.pool_scheme} is not implemented")
-
-                if self.config.max_doc_length > 1:
-                    sec_inputs = torch.concat(
-                        [sec_head_emb,
-                         sec_inputs.view(sec_new_shape)],
-                        dim=-2)
-                else:
-                    sec_inputs = torch.concat([sec_head_emb, sec_inputs], dim=-2)
-                sec_outputs = self.sec_layer[i](self.hi_position_embeddings(sec_inputs.view(hidden_states.shape[0], -1, hidden_states.shape[-1]), "sec"), attention_mask=sec_mask)[0]
-                if self.config.max_doc_length > 1:
-                    doc_inputs, token_head_embedding = torch.split(sec_outputs.view(hidden_states.shape[0], self.config.max_doc_length, self.config.max_sec_length+1, hidden_states.shape[-1]), (1, self.config.max_sec_length), -2)
-                    doc_inputs = doc_inputs.squeeze(-2).clone()
-                else:
-                    token_head_embedding = sec_outputs[:, 1:, :]
-                hidden_sec_states = hidden_states.clone()
-                hidden_sec_states[:, range(0, self.config.max_sec_length * self.config.max_sent_length * self.config.max_doc_length, self.config.max_sent_length),
-                :] = token_head_embedding.contiguous().view(hidden_states.shape[0], self.config.max_sec_length * self.config.max_doc_length, hidden_states.shape[-1])
-                hidden_states = hidden_sec_states
-
-
-                if self.config.max_doc_length > 1:
-                    doc_outputs = self.doc_layer[i](self.hi_position_embeddings(doc_inputs, "doc"), attention_mask=doc_mask)[0]
-                    sec_head_emb = doc_outputs.unsqueeze(-2)
-
-            if use_cache:
-                next_decoder_cache += (layer_outputs[-1],)
-            if output_attentions:
-                all_self_attentions = all_self_attentions + (layer_outputs[1],)
-                if self.config.add_cross_attention:
-                    all_cross_attentions = all_cross_attentions + (layer_outputs[2],)
-
-        if output_hidden_states:
-            all_hidden_states = all_hidden_states + (hidden_states,)
-
-        if not return_dict:
-            return tuple(
-                v
-                for v in [
-                    hidden_states,
-                    next_decoder_cache,
-                    all_hidden_states,
-                    all_self_attentions,
-                    all_cross_attentions,
-                ]
-                if v is not None
-            )
-        return BaseModelOutputWithPastAndCrossAttentions(
-            last_hidden_state=hidden_states,
-            past_key_values=next_decoder_cache,
-            hidden_states=all_hidden_states,
-            attentions=all_self_attentions,
-            cross_attentions=all_cross_attentions,
-        )
-
-
-class HTransPooler(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        self.activation = nn.Tanh()
-        self.pool_scheme = config.pool_scheme
-
-    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
-        # We "pool" the model by simply taking the hidden state corresponding
-        # to the first token.
-        if self.pool_scheme == "first-token":
-            first_token_tensor = hidden_states[:, 0]
-        elif self.pool_scheme == "avg":
-            first_token_tensor = hidden_states.mean(dim=1)
-        elif self.pool_scheme == "max":
-            first_token_tensor = hidden_states.max(dim=1)[0]
-        else:
-            raise NotImplemented(f"{self.pool_scheme} is not a valid pooling scheme")
-        pooled_output = self.dense(first_token_tensor)
-        pooled_output = self.activation(pooled_output)
-        return pooled_output
-
-
-class HTransPredictionHeadTransform(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        if isinstance(config.hidden_act, str):
-            self.transform_act_fn = ACT2FN[config.hidden_act]
-        else:
-            self.transform_act_fn = config.hidden_act
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-
-    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.transform_act_fn(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states)
-        return hidden_states
-
-
-class HTransLMPredictionHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.prediction_head = config.prediction_head
-        if self.prediction_head:
-            self.transform = HTransPredictionHeadTransform(config)
-
-        # The output weights are the same as the input embeddings, but there is
-        # an output-only bias for each token.
-        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
-
-        self.bias = nn.Parameter(torch.zeros(config.vocab_size))
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
-        self.decoder.bias = self.bias
-
-    def forward(self, hidden_states):
-        hidden_states = self.LayerNorm(hidden_states)
-        if self.prediction_head:
-            hidden_states = self.transform(hidden_states)
-        hidden_states = self.decoder(hidden_states)
-        return hidden_states
-
-
-class HTransOnlyMLMHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.predictions = HTransLMPredictionHead(config)
-
-    def forward(self, sequence_output: torch.Tensor) -> torch.Tensor:
-        prediction_scores = self.predictions(sequence_output)
-        return prediction_scores
-
-
-class HTransOnlyNSPHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.seq_relationship = nn.Linear(config.hidden_size, 2)
-
-    def forward(self, pooled_output):
-        seq_relationship_score = self.seq_relationship(pooled_output)
-        return seq_relationship_score
-
-
-class HTransPreTrainingHeads(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.predictions = HTransLMPredictionHead(config)
-        self.seq_relationship = nn.Linear(config.hidden_size, 2)
-
-    def forward(self, sequence_output, pooled_output):
-        prediction_scores = self.predictions(sequence_output)
-        seq_relationship_score = self.seq_relationship(pooled_output)
-        return prediction_scores, seq_relationship_score
-
-
-class HTransPreTrainedModel(PreTrainedModel):
-    """
-    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
-    models.
-    """
-
-    config_class = HTransConfig
-    load_tf_weights = load_tf_weights_in_bert
-    base_model_prefix = "bert"
-    supports_gradient_checkpointing = True
-    _keys_to_ignore_on_load_missing = [r"position_ids"]
-
-    def _init_weights(self, module):
-        """Initialize the weights"""
-        if isinstance(module, nn.Linear):
-            # Slightly different from the TF version which uses truncated_normal for initialization
-            # cf https://github.com/pytorch/pytorch/pull/5617
-            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
-            if module.bias is not None:
-                module.bias.data.zero_()
-        elif isinstance(module, nn.Embedding):
-            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
-            if module.padding_idx is not None:
-                module.weight.data[module.padding_idx].zero_()
-        elif isinstance(module, nn.LayerNorm):
-            module.bias.data.zero_()
-            module.weight.data.fill_(1.0)
-
-    def _set_gradient_checkpointing(self, module, value=False):
-        if isinstance(module, HTransEncoder):
-            module.gradient_checkpointing = value
-
-
-class HTransForPreTrainingOutput(ModelOutput):
-    """
-    Output type of [`BertForPreTraining`].
-
-    Args:
-        loss (*optional*, returned when `labels` is provided, `torch.FloatTensor` of shape `(1,)`):
-            Total loss as the sum of the masked language modeling loss and the next sequence prediction
-            (classification) loss.
-        prediction_logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
-            Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
-        seq_relationship_logits (`torch.FloatTensor` of shape `(batch_size, 2)`):
-            Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
-            before SoftMax).
-        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
-            Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer) of
-            shape `(batch_size, sequence_length, hidden_size)`.
-
-            Hidden-states of the model at the output of each layer plus the initial embedding outputs.
-        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
-            Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
-            sequence_length)`.
-
-            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
-            heads.
-    """
-
-    loss: Optional[torch.FloatTensor] = None
-    prediction_logits: torch.FloatTensor = None
-    seq_relationship_logits: torch.FloatTensor = None
-    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
-    attentions: Optional[Tuple[torch.FloatTensor]] = None
-
-
-class HTransModel(HTransPreTrainedModel):
-    """
-
-    The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
-    cross-attention is added between the self-attention layers, following the architecture described in [Attention is
-    all you need](https://arxiv.org/abs/1706.03762) by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
-    Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
-
-    To behave as an decoder the model needs to be initialized with the `is_decoder` argument of the configuration set
-    to `True`. To be used in a Seq2Seq model, the model needs to initialized with both `is_decoder` argument and
-    `add_cross_attention` set to `True`; an `encoder_hidden_states` is then expected as an input to the forward pass.
-    """
-
-    def __init__(self, config, add_pooling_layer=True):
-        super().__init__(config)
-        self.config = config
-
-        self.embeddings = HTransEmbeddings(config)
-        self.encoder = HTransEncoder(config)
-
-        self.pooler = HTransPooler(config) if add_pooling_layer else None
-
-        # Initialize weights and apply final processing
-        self.post_init()
-
-    def get_input_embeddings(self):
-        return self.embeddings.word_embeddings
-
-    def set_input_embeddings(self, value):
-        self.embeddings.word_embeddings = value
-
-    def _prune_heads(self, heads_to_prune):
-        """
-        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
-        class PreTrainedModel
-        """
-        for layer, heads in heads_to_prune.items():
-            self.encoder.layer[layer].attention.prune_heads(heads)
-
-    def forward(
-        self,
-        input_ids: Optional[torch.Tensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        token_type_ids: Optional[torch.Tensor] = None,
-        sec_mask: Optional[torch.FloatTensor] = None,
-        doc_mask: Optional[torch.FloatTensor] = None,
-        position_ids: Optional[torch.Tensor] = None,
-        head_mask: Optional[torch.Tensor] = None,
-        inputs_embeds: Optional[torch.Tensor] = None,
-        encoder_hidden_states: Optional[torch.Tensor] = None,
-        encoder_attention_mask: Optional[torch.Tensor] = None,
-        past_key_values: Optional[List[torch.FloatTensor]] = None,
-        use_cache: Optional[bool] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-        head_ids: Optional[torch.Tensor] = None
-    ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPoolingAndCrossAttentions]:
-        r"""
-        encoder_hidden_states  (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
-            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
-            the model is configured as a decoder.
-        encoder_attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, *optional*):
-            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
-            the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`:
-
-            - 1 for tokens that are **not masked**,
-            - 0 for tokens that are **masked**.
-        past_key_values (`tuple(tuple(torch.FloatTensor))` of length `config.n_layers` with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
-            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
-
-            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
-            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
-            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
-        use_cache (`bool`, *optional*):
-            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
-            `past_key_values`).
-        """
-        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
-        )
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        if self.config.is_decoder:
-            use_cache = use_cache if use_cache is not None else self.config.use_cache
-        else:
-            use_cache = False
-
-        if input_ids is not None and inputs_embeds is not None:
-            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
-        elif input_ids is not None:
-            input_shape = input_ids.size()
-        elif inputs_embeds is not None:
-            input_shape = inputs_embeds.size()[:-1]
-        else:
-            raise ValueError("You have to specify either input_ids or inputs_embeds")
-
-        batch_size, seq_length = input_shape
-        device = input_ids.device if input_ids is not None else inputs_embeds.device
-
-        # past_key_values_length
-        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
-
-        if attention_mask is None:
-            attention_mask = torch.ones(((batch_size, seq_length + past_key_values_length)), device=device)
-
-        if token_type_ids is None:
-            if hasattr(self.embeddings, "token_type_ids"):
-                buffered_token_type_ids = self.embeddings.token_type_ids[:, :seq_length]
-                buffered_token_type_ids_expanded = buffered_token_type_ids.expand(batch_size, seq_length)
-                token_type_ids = buffered_token_type_ids_expanded
-            else:
-                token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
-
-        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
-        # ourselves in which case we just need to make it broadcastable to all heads.
-        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape)
-        if sec_mask is None:
-            sec_mask = torch.ones(((batch_size, self.config.max_sec_length * self.config.max_doc_length)), device=device)
-        if doc_mask is None:
-            doc_mask = torch.ones(((batch_size, self.config.max_doc_length)), device=device)
-        if self.config.max_doc_length > 1:
-            sec_mask = torch.concat([doc_mask.unsqueeze(-1), sec_mask.view((batch_size, self.config.max_doc_length, self.config.max_sec_length))], dim=-1).view((batch_size,-1))
-        else:
-            sec_mask = torch.column_stack([torch.ones((batch_size, 1)), sec_mask])
-        extended_sec_attention_mask: torch.Tensor = self.get_extended_attention_mask(sec_mask, (batch_size, self.config.max_sec_length * self.config.max_doc_length + self.config.max_doc_length))
-        extended_doc_attention_mask: torch.Tensor = self.get_extended_attention_mask(doc_mask, (batch_size, self.config.max_doc_length))
-        # If a 2D or 3D attention mask is provided for the cross-attention
-        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
-        if self.config.is_decoder and encoder_hidden_states is not None:
-            encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
-            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
-            if encoder_attention_mask is None:
-                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
-            encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
-        else:
-            encoder_extended_attention_mask = None
-
-        # Prepare head mask if needed
-        # 1.0 in head_mask indicate we keep the head
-        # attention_probs has shape bsz x n_heads x N x N
-        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
-        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
-        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
-
-        embedding_output = self.embeddings(
-            input_ids=input_ids,
-            position_ids=position_ids,
-            token_type_ids=token_type_ids,
-            inputs_embeds=inputs_embeds,
-            past_key_values_length=past_key_values_length,
-        )
-        head_embeddings = self.embeddings.word_embeddings(head_ids)
-        encoder_outputs = self.encoder(
-            embedding_output,
-            attention_mask=extended_attention_mask,
-            head_mask=head_mask,
-            encoder_hidden_states=encoder_hidden_states,
-            encoder_attention_mask=encoder_extended_attention_mask,
-            past_key_values=past_key_values,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            sec_head_emb=head_embeddings[:, 0:1, :],
-            doc_head_emb=head_embeddings[:, 1:2, :],
-            sec_mask=extended_sec_attention_mask,
-            doc_mask=extended_doc_attention_mask
-        )
-        sequence_output = encoder_outputs[0]
-        pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
-
-        if not return_dict:
-            return (sequence_output, pooled_output) + encoder_outputs[1:]
-
-        return BaseModelOutputWithPoolingAndCrossAttentions(
-            last_hidden_state=sequence_output,
-            pooler_output=pooled_output,
-            past_key_values=encoder_outputs.past_key_values,
-            hidden_states=encoder_outputs.hidden_states,
-            attentions=encoder_outputs.attentions,
-            cross_attentions=encoder_outputs.cross_attentions,
-        )
-
-
-class HTransForPreTraining(HTransPreTrainedModel):
-    _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias",
-                                       r"cls.predictions.decoder.weight"]
-
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bert = HTransModel(config)
-        self.cls = HTransPreTrainingHeads(config)
-
-        # Initialize weights and apply final processing
-        self.post_init()
-
-    def get_output_embeddings(self):
-        return self.cls.predictions.decoder
-
-    def set_output_embeddings(self, new_embeddings):
-        self.cls.predictions.decoder = new_embeddings
-
-    def forward(
-            self,
-            input_ids: Optional[torch.Tensor] = None,
-            attention_mask: Optional[torch.Tensor] = None,
-            sec_mask: Optional[torch.FloatTensor] = None,
-            doc_mask: Optional[torch.FloatTensor] = None,
-            token_type_ids: Optional[torch.Tensor] = None,
-            position_ids: Optional[torch.Tensor] = None,
-            head_mask: Optional[torch.Tensor] = None,
-            inputs_embeds: Optional[torch.Tensor] = None,
-            labels: Optional[torch.Tensor] = None,
-            next_sentence_label: Optional[torch.Tensor] = None,
-            output_attentions: Optional[bool] = None,
-            output_hidden_states: Optional[bool] = None,
-            return_dict: Optional[bool] = None,
-            head_ids: Optional[torch.Tensor] = None
-    ) -> Union[Tuple[torch.Tensor], HTransForPreTrainingOutput]:
-        r"""
-            labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
-                Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
-                config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked),
-                the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
-            next_sentence_label (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
-                Labels for computing the next sequence prediction (classification) loss. Input should be a sequence
-                pair (see `input_ids` docstring) Indices should be in `[0, 1]`:
-
-                - 0 indicates sequence B is a continuation of sequence A,
-                - 1 indicates sequence B is a random sequence.
-            kwargs (`Dict[str, any]`, optional, defaults to *{}*):
-                Used to hide legacy arguments that have been deprecated.
-
-        Returns:
-
-        Example:
-
-        ```python
-        >>> from transformers import AutoTokenizer, BertForPreTraining
-        >>> import torch
-
-        >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
-        >>> model = BertForPreTraining.from_pretrained("bert-base-uncased")
-
-        >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
-        >>> outputs = model(**inputs)
-
-        >>> prediction_logits = outputs.prediction_logits
-        >>> seq_relationship_logits = outputs.seq_relationship_logits
-        ```
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            sec_mask=sec_mask,
-            doc_mask=doc_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            head_ids=head_ids
-        )
-
-        sequence_output, pooled_output = outputs[:2]
-        prediction_scores, seq_relationship_score = self.cls(sequence_output, pooled_output)
-
-        total_loss = None
-        if labels is not None:
-            loss_fct = CrossEntropyLoss()
-            masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
-            total_loss = masked_lm_loss
-
-        if next_sentence_label is not None:
-            loss_fct = CrossEntropyLoss()
-            next_sentence_loss = loss_fct(seq_relationship_score.view(-1, 2), next_sentence_label.view(-1))
-            if total_loss is not None:
-                total_loss += next_sentence_loss
-            else:
-                total_loss = next_sentence_loss
-
-        if not return_dict:
-            output = (prediction_scores, seq_relationship_score) + outputs[2:]
-            return ((total_loss,) + output) if total_loss is not None else output
-
-        return HTransForPreTrainingOutput(
-            loss=total_loss,
-            prediction_logits=prediction_scores,
-            seq_relationship_logits=seq_relationship_score,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
-
-
-class HTransForSequenceClassification(HTransPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-        self.num_labels = config.num_labels
-        self.config = config
-
-        self.bert = HTransModel(config)
-        classifier_dropout = (
-            config.classifier_dropout if config.classifier_dropout is not None else config.hidden_dropout_prob
-        )
-        self.dropout = nn.Dropout(classifier_dropout)
-        self.classifier = nn.Linear(config.hidden_size, config.num_labels)
-
-        # Initialize weights and apply final processing
-        self.post_init()
-
-    def forward(
-        self,
-        input_ids: Optional[torch.Tensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        token_type_ids: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.Tensor] = None,
-        head_mask: Optional[torch.Tensor] = None,
-        inputs_embeds: Optional[torch.Tensor] = None,
-        labels: Optional[torch.Tensor] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-    ) -> Union[Tuple[torch.Tensor], SequenceClassifierOutput]:
-        r"""
-        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
-            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
-            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
-            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
-        """
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        pooled_output = outputs[1]
-
-        pooled_output = self.dropout(pooled_output)
-        logits = self.classifier(pooled_output)
-
-        loss = None
-        if labels is not None:
-            if self.config.problem_type is None:
-                if self.num_labels == 1:
-                    self.config.problem_type = "regression"
-                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
-                    self.config.problem_type = "single_label_classification"
-                else:
-                    self.config.problem_type = "multi_label_classification"
-
-            if self.config.problem_type == "regression":
-                loss_fct = MSELoss()
-                if self.num_labels == 1:
-                    loss = loss_fct(logits.squeeze(), labels.squeeze())
-                else:
-                    loss = loss_fct(logits, labels)
-            elif self.config.problem_type == "single_label_classification":
-                loss_fct = CrossEntropyLoss()
-                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
-            elif self.config.problem_type == "multi_label_classification":
-                loss_fct = BCEWithLogitsLoss()
-                loss = loss_fct(logits, labels)
-        if not return_dict:
-            output = (logits,) + outputs[2:]
-            return ((loss,) + output) if loss is not None else output
-
-        return SequenceClassifierOutput(
-            loss=loss,
-            logits=logits,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )

htrans/norms.py

@@ -1,52 +0,0 @@
-import torch
-
-def ScriptedScaleNorm(hidden_size: int, eps: float = 1e-5):
-    return torch.jit.script(ScaleNorm(hidden_size, eps))
-
-
-def ScriptedRMSNorm(hidden_size: int, eps: float = 1e-8):
-    return torch.jit.script(RMSNorm(hidden_size, eps))
-
-
-class ScaleNorm(torch.nn.Module):
-    """Quick and simple scale norm implementation.
-
-    Do we also need FixNorm (cosine in the last layer)? It's a maybe here:
-    https://github.com/lucidrains/performer-pytorch/issues/55#issuecomment-762544686
-    """
-
-    def __init__(self, hidden_size: int, eps: float = 1e-5):
-        super().__init__()
-        self.eps = eps
-        self.learnable_scale = torch.nn.Parameter(torch.tensor(float(hidden_size) ** -0.5))
-
-    def forward(self, inputs):
-        """This is the same eps clipping as in the original ScaleNorm implementation."""
-        return inputs * self.learnable_scale / torch.norm(inputs, dim=-1, keepdim=True).clamp(min=self.eps)
-
-
-class RMSNorm(torch.nn.Module):
-    """The RMS variant of scaling norms."""
-
-    def __init__(self, hidden_size: int, eps: float = 1e-8):
-        super().__init__()
-        self.eps = eps
-        self.learnable_scale = torch.nn.Parameter(torch.ones(hidden_size) ** -0.5)
-
-    def forward(self, inputs):
-        """This is the same eps clipping as in the original ScaleNorm implementation."""
-        return inputs * self.learnable_scale / torch.norm(inputs, dim=-1, keepdim=True).clamp(min=self.eps)
-
-
-def get_norm_fn(norm_name):
-    if norm_name == "ScaleNorm":
-        norm_fn = ScriptedScaleNorm
-    elif norm_name == "RMSNorm":
-        norm_fn = ScriptedRMSNorm
-    elif norm_name == "ApexLayerNorm":
-        from apex.normalization import FusedLayerNorm
-
-        norm_fn = FusedLayerNorm
-    else:
-        norm_fn = getattr(torch.nn, norm_name)
-    return norm_fn

htrans/pytorch_utils.py

@@ -1,276 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# 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 inspect
-from typing import Callable, List, Optional, Set, Tuple, Union
-
-import torch
-from packaging import version
-from torch import nn
-import logging
-
-
-ALL_LAYERNORM_LAYERS = [nn.LayerNorm]
-
-logger = logging.getLogger(__name__)
-
-parsed_torch_version_base = version.parse(version.parse(torch.__version__).base_version)
-
-is_torch_less_than_1_8 = parsed_torch_version_base < version.parse("1.8.0")
-is_torch_less_than_1_9 = parsed_torch_version_base < version.parse("1.9.0")
-is_torch_greater_or_equal_than_1_10 = parsed_torch_version_base >= version.parse("1.10")
-is_torch_less_than_1_11 = parsed_torch_version_base < version.parse("1.11")
-
-
-def torch_int_div(tensor1, tensor2):
-    """
-    A function that performs integer division across different versions of PyTorch.
-    """
-    if is_torch_less_than_1_8:
-        return tensor1 // tensor2
-    else:
-        return torch.div(tensor1, tensor2, rounding_mode="floor")
-
-
-def prune_linear_layer(layer: nn.Linear, index: torch.LongTensor, dim: int = 0) -> nn.Linear:
-    """
-    Prune a linear layer to keep only entries in index.
-
-    Used to remove heads.
-
-    Args:
-        layer (`torch.nn.Linear`): The layer to prune.
-        index (`torch.LongTensor`): The indices to keep in the layer.
-        dim (`int`, *optional*, defaults to 0): The dimension on which to keep the indices.
-
-    Returns:
-        `torch.nn.Linear`: The pruned layer as a new layer with `requires_grad=True`.
-    """
-    index = index.to(layer.weight.device)
-    W = layer.weight.index_select(dim, index).clone().detach()
-    if layer.bias is not None:
-        if dim == 1:
-            b = layer.bias.clone().detach()
-        else:
-            b = layer.bias[index].clone().detach()
-    new_size = list(layer.weight.size())
-    new_size[dim] = len(index)
-    new_layer = nn.Linear(new_size[1], new_size[0], bias=layer.bias is not None).to(layer.weight.device)
-    new_layer.weight.requires_grad = False
-    new_layer.weight.copy_(W.contiguous())
-    new_layer.weight.requires_grad = True
-    if layer.bias is not None:
-        new_layer.bias.requires_grad = False
-        new_layer.bias.copy_(b.contiguous())
-        new_layer.bias.requires_grad = True
-    return new_layer
-
-
-class Conv1D(nn.Module):
-    """
-    1D-convolutional layer as defined by Radford et al. for OpenAI GPT (and also used in GPT-2).
-
-    Basically works like a linear layer but the weights are transposed.
-
-    Args:
-        nf (`int`): The number of output features.
-        nx (`int`): The number of input features.
-    """
-
-    def __init__(self, nf, nx):
-        super().__init__()
-        self.nf = nf
-        w = torch.empty(nx, nf)
-        nn.init.normal_(w, std=0.02)
-        self.weight = nn.Parameter(w)
-        self.bias = nn.Parameter(torch.zeros(nf))
-
-    def forward(self, x):
-        size_out = x.size()[:-1] + (self.nf,)
-        x = torch.addmm(self.bias, x.view(-1, x.size(-1)), self.weight)
-        x = x.view(size_out)
-        return x
-
-
-def prune_conv1d_layer(layer: Conv1D, index: torch.LongTensor, dim: int = 1) -> Conv1D:
-    """
-    Prune a Conv1D layer to keep only entries in index. A Conv1D work as a Linear layer (see e.g. BERT) but the weights
-    are transposed.
-
-    Used to remove heads.
-
-    Args:
-        layer ([`~pytorch_utils.Conv1D`]): The layer to prune.
-        index (`torch.LongTensor`): The indices to keep in the layer.
-        dim (`int`, *optional*, defaults to 1): The dimension on which to keep the indices.
-
-    Returns:
-        [`~pytorch_utils.Conv1D`]: The pruned layer as a new layer with `requires_grad=True`.
-    """
-    index = index.to(layer.weight.device)
-    W = layer.weight.index_select(dim, index).clone().detach()
-    if dim == 0:
-        b = layer.bias.clone().detach()
-    else:
-        b = layer.bias[index].clone().detach()
-    new_size = list(layer.weight.size())
-    new_size[dim] = len(index)
-    new_layer = Conv1D(new_size[1], new_size[0]).to(layer.weight.device)
-    new_layer.weight.requires_grad = False
-    new_layer.weight.copy_(W.contiguous())
-    new_layer.weight.requires_grad = True
-    new_layer.bias.requires_grad = False
-    new_layer.bias.copy_(b.contiguous())
-    new_layer.bias.requires_grad = True
-    return new_layer
-
-
-def prune_layer(
-    layer: Union[nn.Linear, Conv1D], index: torch.LongTensor, dim: Optional[int] = None
-) -> Union[nn.Linear, Conv1D]:
-    """
-    Prune a Conv1D or linear layer to keep only entries in index.
-
-    Used to remove heads.
-
-    Args:
-        layer (`Union[torch.nn.Linear, Conv1D]`): The layer to prune.
-        index (`torch.LongTensor`): The indices to keep in the layer.
-        dim (`int`, *optional*): The dimension on which to keep the indices.
-
-    Returns:
-        `torch.nn.Linear` or [`~pytorch_utils.Conv1D`]: The pruned layer as a new layer with `requires_grad=True`.
-    """
-    if isinstance(layer, nn.Linear):
-        return prune_linear_layer(layer, index, dim=0 if dim is None else dim)
-    elif isinstance(layer, Conv1D):
-        return prune_conv1d_layer(layer, index, dim=1 if dim is None else dim)
-    else:
-        raise ValueError(f"Can't prune layer of class {layer.__class__}")
-
-
-def apply_chunking_to_forward(
-    forward_fn: Callable[..., torch.Tensor], chunk_size: int, chunk_dim: int, *input_tensors
-) -> torch.Tensor:
-    """
-    This function chunks the `input_tensors` into smaller input tensor parts of size `chunk_size` over the dimension
-    `chunk_dim`. It then applies a layer `forward_fn` to each chunk independently to save memory.
-
-    If the `forward_fn` is independent across the `chunk_dim` this function will yield the same result as directly
-    applying `forward_fn` to `input_tensors`.
-
-    Args:
-        forward_fn (`Callable[..., torch.Tensor]`):
-            The forward function of the model.
-        chunk_size (`int`):
-            The chunk size of a chunked tensor: `num_chunks = len(input_tensors[0]) / chunk_size`.
-        chunk_dim (`int`):
-            The dimension over which the `input_tensors` should be chunked.
-        input_tensors (`Tuple[torch.Tensor]`):
-            The input tensors of `forward_fn` which will be chunked
-
-    Returns:
-        `torch.Tensor`: A tensor with the same shape as the `forward_fn` would have given if applied`.
-
-
-    Examples:
-
-    ```python
-    # rename the usual forward() fn to forward_chunk()
-    def forward_chunk(self, hidden_states):
-        hidden_states = self.decoder(hidden_states)
-        return hidden_states
-
-
-    # implement a chunked forward function
-    def forward(self, hidden_states):
-        return apply_chunking_to_forward(self.forward_chunk, self.chunk_size_lm_head, self.seq_len_dim, hidden_states)
-    ```"""
-
-    assert len(input_tensors) > 0, f"{input_tensors} has to be a tuple/list of tensors"
-
-    # inspect.signature exist since python 3.5 and is a python method -> no problem with backward compatibility
-    num_args_in_forward_chunk_fn = len(inspect.signature(forward_fn).parameters)
-    if num_args_in_forward_chunk_fn != len(input_tensors):
-        raise ValueError(
-            f"forward_chunk_fn expects {num_args_in_forward_chunk_fn} arguments, but only {len(input_tensors)} input "
-            "tensors are given"
-        )
-
-    if chunk_size > 0:
-        tensor_shape = input_tensors[0].shape[chunk_dim]
-        for input_tensor in input_tensors:
-            if input_tensor.shape[chunk_dim] != tensor_shape:
-                raise ValueError(
-                    f"All input tenors have to be of the same shape: {tensor_shape}, "
-                    f"found shape {input_tensor.shape[chunk_dim]}"
-                )
-
-        if input_tensors[0].shape[chunk_dim] % chunk_size != 0:
-            raise ValueError(
-                f"The dimension to be chunked {input_tensors[0].shape[chunk_dim]} has to be a multiple of the chunk "
-                f"size {chunk_size}"
-            )
-
-        num_chunks = input_tensors[0].shape[chunk_dim] // chunk_size
-
-        # chunk input tensor into tuples
-        input_tensors_chunks = tuple(input_tensor.chunk(num_chunks, dim=chunk_dim) for input_tensor in input_tensors)
-        # apply forward fn to every tuple
-        output_chunks = tuple(forward_fn(*input_tensors_chunk) for input_tensors_chunk in zip(*input_tensors_chunks))
-        # concatenate output at same dimension
-        return torch.cat(output_chunks, dim=chunk_dim)
-
-    return forward_fn(*input_tensors)
-
-
-def find_pruneable_heads_and_indices(
-    heads: List[int], n_heads: int, head_size: int, already_pruned_heads: Set[int]
-) -> Tuple[Set[int], torch.LongTensor]:
-    """
-    Finds the heads and their indices taking `already_pruned_heads` into account.
-
-    Args:
-        heads (`List[int]`): List of the indices of heads to prune.
-        n_heads (`int`): The number of heads in the model.
-        head_size (`int`): The size of each head.
-        already_pruned_heads (`Set[int]`): A set of already pruned heads.
-
-    Returns:
-        `Tuple[Set[int], torch.LongTensor]`: A tuple with the remaining heads and their corresponding indices.
-    """
-    mask = torch.ones(n_heads, head_size)
-    heads = set(heads) - already_pruned_heads  # Convert to set and remove already pruned heads
-    for head in heads:
-        # Compute how many pruned heads are before the head and move the index accordingly
-        head = head - sum(1 if h < head else 0 for h in already_pruned_heads)
-        mask[head] = 0
-    mask = mask.view(-1).contiguous().eq(1)
-    index: torch.LongTensor = torch.arange(len(mask))[mask].long()
-    return heads, index
-
-
-def meshgrid(
-    *tensors: Union[torch.Tensor, List[torch.Tensor]], indexing: Optional[str] = None
-) -> Tuple[torch.Tensor, ...]:
-    """
-    Wrapper around torch.meshgrid to avoid warning messages about the introduced `indexing` argument.
-
-    Reference: https://pytorch.org/docs/1.13/generated/torch.meshgrid.html
-    """
-    if is_torch_greater_or_equal_than_1_10:
-        return torch.meshgrid(*tensors, indexing=indexing)
-    else:
-        if indexing != "ij":
-            raise ValueError('torch.meshgrid only supports `indexing="ij"` for torch<1.10.')
-        return torch.meshgrid(*tensors)

mdcr.py

@@ -1,58 +0,0 @@
-import json
-from typing import Union, Dict
-
-import logging
-import os
-import datasets
-import numpy as np
-from tqdm import tqdm
-
-from evaluation.embeddings_generator import EmbeddingsGenerator
-from evaluation.encoders import Model
-from evaluation.eval_datasets import SimpleDataset
-from evaluation.evaluator import IREvaluator
-
-logger = logging.getLogger(__name__)
-
-
-class MDCREvaluator(IREvaluator):
-    def __init__(self, name: str, meta_dataset: Union[str, tuple], test_dataset: Union[str, tuple], model: Model,
-                 metrics: tuple = None, batch_size: int = 16, fields: list = None, key="paper_id"):
-        super(MDCREvaluator, self).__init__(name, meta_dataset, test_dataset, model, metrics, SimpleDataset,
-                                            batch_size, fields, key)
-
-    def get_qc_pairs(self, dataset):
-        qrpairs = dict()
-        for fos_dict in dataset:
-            for fos in fos_dict:
-                for query in fos_dict[fos]:
-                    qrpairs[query] = dict()
-                    for model in fos_dict[fos][query]:
-                        cands = fos_dict[fos][query][model]
-                        qrpairs[query].update({v: 1 if model == "true" else 0 for v in cands})
-        return qrpairs
-
-    def evaluate(self, embeddings, **kwargs):
-        logger.info(f"Loading test dataset from {self.test_dataset}")
-        split_dataset = datasets.load_dataset("json",
-                                              data_files={"test": self.test_dataset})
-        logger.info(f"Loaded {len(split_dataset['test'])} test query-candidate pairs")
-        if type(embeddings) == str and os.path.isfile(embeddings):
-            embeddings = EmbeddingsGenerator.load_embeddings_from_jsonl(embeddings)
-
-        qrels_hard = self.get_qc_pairs(split_dataset["test"])
-        preds = self.retrieval(embeddings, qrels_hard)
-        results = dict()
-        for q, cscores in tqdm(preds.items()):
-            for c in cscores:
-                results[f"{q}_{c}"] = cscores[c]
-        json.dump(results, open("scirepeval_mdcr.json", "w"))
-        return dict()
-
-import sys
-if __name__ == "__main__":
-    mname = sys.argv[1]
-    model = Model(variant="default", base_checkpoint=mname)
-    evaluator = MDCREvaluator("mcdr", "../mdcr/mdcr_test_data.jsonl", "../mdcr/mdcr_test.json", model, batch_size=32)
-    embeddings = evaluator.generate_embeddings(save_path="mdcr_embeddings.json")
-    evaluator.evaluate(embeddings)

requirements.txt

@@ -1,100 +0,0 @@
-absl-py==1.2.0
-adapter-transformers==3.0.1
-aiohttp==3.8.1
-aiosignal==1.2.0
-antlr4-python3-runtime==4.8
-async-timeout==4.0.2
-attrs==22.1.0
-bitarray==2.6.0
-boto==2.49.0
-boto3==1.24.90
-botocore==1.27.90
-cachetools==5.2.0
-certifi==2022.6.15
-cffi==1.15.1
-charset-normalizer==2.1.1
-click==8.1.3
-colorama==0.4.5
-Cython==0.29.32
-datasets==2.5.2
-dill==0.3.5.1
-fairseq==0.12.2
-filelock==3.8.0
-frozenlist==1.3.1
-fsspec==2022.7.1
-google-auth==2.11.0
-google-auth-oauthlib==0.4.6
-grpcio==1.47.0
-huggingface-hub==0.9.0
-hydra-core==1.0.7
-idna==3.3
-ijson==3.1.4
-importlib-metadata==4.12.0
-importlib-resources==5.9.0
-install==1.3.5
-jmespath==1.0.1
-joblib==1.1.0
-lxml==4.9.1
-Markdown==3.4.1
-MarkupSafe==2.1.1
-multidict==6.0.2
-multiprocess==0.70.13
-numpy==1.23.2
-oauthlib==3.2.0
-omegaconf==2.0.6
-packaging==21.3
-pandas==1.5.0
-Pillow==9.2.0
-pip==22.1.2
-portalocker==2.5.1
-protobuf==3.19.4
-psycopg2-binary==2.9.4
-pyarrow==9.0.0
-pyasn1==0.4.8
-pyasn1-modules==0.2.8
-pycparser==2.21
-pyDeprecate==0.3.2
-pyparsing==3.0.9
-python-dateutil==2.8.2
-pytorch-lightning==1.7.2
-pytrec-eval==0.5
-pytz==2022.4
-PyYAML==6.0
-regex==2022.8.17
-requests==2.28.1
-requests-oauthlib==1.3.1
-responses==0.18.0
-rsa==4.9
-s3transfer==0.6.0
-sacrebleu==2.2.0
-sacremoses==0.0.53
-scikit-learn==1.1.2
-scikit-multilearn==0.2.0
-scipy==1.9.0
-setuptools==63.4.1
-six==1.16.0
-sklearn==0.0
-sklearn-contrib-lightning==0.6.2.post0
-tabulate==0.8.10
-tensorboard==2.10.0
-tensorboard-data-server==0.6.1
-tensorboard-plugin-wit==1.8.1
-tensorboardX==2.5.1
-threadpoolctl==3.1.0
-tokenizers==0.12.1
-torch==1.12.1
-torchaudio==0.12.1
-torchmetrics==0.9.3
-torchvision==0.13.1
-tqdm==4.64.0
-transformers==4.21.1
-typing_extensions==4.3.0
-urllib3==1.26.12
-Werkzeug==2.2.2
-wheel==0.37.1
-xxhash==3.0.0
-yarl==1.8.1
-zipp==3.8.1
-openai==0.26.1
-InstructorEmbedding==1.0.0
-sentence_transformers==2.2.2

reviewer_matching.py

@@ -1,65 +0,0 @@
-from typing import Union, Dict
-
-import logging
-import os
-import datasets
-import numpy as np
-from tqdm import tqdm
-
-from evaluation.embeddings_generator import EmbeddingsGenerator
-from evaluation.encoders import Model
-from evaluation.eval_datasets import SimpleDataset
-from evaluation.evaluator import IREvaluator
-from sklearn.metrics.pairwise import cosine_similarity
-
-logger = logging.getLogger(__name__)
-
-
-class ReviewerMatchingEvaluator(IREvaluator):
-    def __init__(self, name: str, meta_dataset: Union[str, tuple], test_dataset: Union[str, tuple],
-                 reviewer_metadata: Union[str, tuple], model: Model,
-                 metrics: tuple = ("P_5", "P_10"), batch_size: int = 16, fields: list = None):
-        super(ReviewerMatchingEvaluator, self).__init__(name, meta_dataset, test_dataset, model, metrics, SimpleDataset,
-                                                        batch_size, fields, )
-        self.reviewer_metadata = reviewer_metadata
-
-    def evaluate(self, embeddings, **kwargs):
-        logger.info(f"Loading test dataset from {self.test_dataset}")
-        if type(self.test_dataset) == str and os.path.isdir(self.test_dataset):
-            split_dataset = datasets.load_dataset("json",
-                                                  data_files={"test_hard": f"{self.test_dataset}/test_hard_qrel.jsonl",
-                                                              "test_soft": f"{self.test_dataset}/test_soft_qrel.jsonl"})
-        else:
-            split_dataset = datasets.load_dataset(self.test_dataset[0], self.test_dataset[1])
-        logger.info(f"Loaded {len(split_dataset['test_hard'])} test query-candidate pairs for hard and soft tests")
-        if type(embeddings) == str and os.path.isfile(embeddings):
-            embeddings = EmbeddingsGenerator.load_embeddings_from_jsonl(embeddings)
-
-        qrels_hard = self.get_qc_pairs(split_dataset["test_hard"])
-        qrels_soft = self.get_qc_pairs(split_dataset["test_soft"])
-        preds = self.retrieval(embeddings, qrels_hard)
-        results = {f"hard_{k}": v for k, v in self.calc_metrics(qrels_hard, preds).items()}
-        results.update({f"soft_{k}": v for k, v in self.calc_metrics(qrels_soft, preds).items()})
-        self.print_results(results)
-        return results
-
-    def retrieval(self, embeddings, qrels: Dict[str, Dict[str, int]]) -> Dict[str, Dict[str, float]]:
-        logger.info("Loading reviewer metadata...")
-        if type(self.reviewer_metadata) == str and os.path.isdir(self.reviewer_metadata):
-            reviewer_dataset = datasets.load_dataset("json", data_files={
-                "metadata": f"{self.reviewer_metadata}/reviewer_metadata.jsonl"})["metadata"]
-        else:
-            reviewer_dataset = datasets.load_dataset(self.reviewer_metadata[0], self.reviewer_metadata[1],
-                                                     split="metadata")
-        logger.info(f"Loaded {len(reviewer_dataset)} reviewer metadata")
-        reviewer_papers = {d["r_id"]: d["papers"] for d in reviewer_dataset}
-
-        run = dict()
-        for qid in tqdm(qrels):
-            query = np.array([embeddings[qid]])
-            cand_papers = {cid: np.array([embeddings[pid] for pid in reviewer_papers[cid]]) for cid in qrels[qid] if
-                           cid in reviewer_papers}
-            scores = {cid: cosine_similarity(cand_papers[cid], query).flatten() for cid in cand_papers}
-            sorted_scores = {cid: sorted(scores[cid], reverse=True) for cid in scores}
-            run[qid] = {cid: float(np.mean(sorted_scores[cid][:3])) for cid in sorted_scores}
-        return run

s2and_embeddings.py

@@ -1,56 +0,0 @@
-import pickle
-
-import numpy as np
-
-from evaluation.encoders import Model
-from evaluation.eval_datasets import SimpleDataset
-from evaluation.evaluator import Evaluator
-import argparse
-from tqdm import tqdm
-
-import json
-
-
-def read_data(file_path):
-    task_data = json.load(open(file_path, "r"))
-    task_data = list(task_data.values())
-    return task_data
-
-
-class S2ANDEvaluator:
-
-    def __init__(self, data_dir: str, model: Model, batch_size: int = 16):
-        blocks = ["arnetminer", "inspire", "kisti", "pubmed", "qian", "zbmath"]
-        self.data_dir = data_dir
-        self.evaluators = [
-            Evaluator(block, f"{data_dir}/{block}/{block}_papers.json", SimpleDataset, model, batch_size, [],
-                      "paper_id", process_fn=read_data) for block in blocks]
-
-    def generate_embeddings(self, suffix: str):
-        for evaluator in tqdm(self.evaluators):
-            print(evaluator.name)
-            results = evaluator.generate_embeddings()
-            paper_ids, embs = np.array([str(k) for k in results]), np.array(
-                [results[k] for k in results])
-            pickle.dump((embs, paper_ids),
-                        open(f"{self.data_dir}/{evaluator.name}/{evaluator.name}_{suffix}.pkl", "wb"))
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--mtype', help='Model variant to be used (default, pals, adapters, fusion)', default="default")
-    parser.add_argument('--model', '-m', help='HuggingFace model to be used')
-    parser.add_argument('--ctrl-tokens', action='store_true', default=False, help='use control codes for tasks')
-    parser.add_argument('--adapters-dir', help='path to the adapter checkpoints', default=None)
-    parser.add_argument('--adapters-chkpt', help='hf adapter names keyed on tasks', default=None, type=json.loads)
-    parser.add_argument('--fusion-dir', help='path to the fusion checkpoints', default=None)
-    parser.add_argument("--data-dir", help="path to the data directory")
-    parser.add_argument("--suffix", help="suffix for output embedding files")
-
-    args = parser.parse_args()
-    adapters_load_from = args.adapters_dir if args.adapters_dir else args.adapters_chkpt
-    model = Model(variant=args.mtype, base_checkpoint=args.model, adapters_load_from=adapters_load_from,
-                  fusion_load_from=args.fusion_dir, use_ctrl_codes=args.ctrl_tokens,
-                  task_id="[PRX]", all_tasks=["[CLF]", "[PRX]", "[RGN]", "[QRY]"])
-    evaluator = S2ANDEvaluator(args.data_dir, model)
-    evaluator.generate_embeddings(args.suffix)

scirepeval.py

@@ -1,159 +0,0 @@
-import os
-import argparse
-import json
-from typing import List, Union
-from tqdm import tqdm
-from evaluation.encoders import Model, HModel
-from evaluation.evaluator import IREvaluator, SupervisedEvaluator, SupervisedTask
-from evaluation.few_shot_evaluator import FewShotEvaluator
-from evaluation.gpt3_encoder import GPT3Model
-from evaluation.instructor import InstructorModel
-from reviewer_matching import ReviewerMatchingEvaluator
-from evaluation.eval_datasets import SimpleDataset, IRDataset
-
-TASK_IDS = {"classification": "[CLF]", "regression": "[RGN]", "proximity": "[PRX]",
-            "adhoc_search": {"query": "[QRY]", "candidates": "[PRX]"}}
-import pytorch_lightning as pl
-
-pl.seed_everything(42, workers=True)
-
-
-class SciRepEval:
-
-    def __init__(self, tasks_config: str = "super_scirep.jsonl", task_list: List[str] = None,
-                 task_formats: List[str] = None, batch_size: int = 32, document=False):
-        tasks_dict = dict()
-        task_by_formats = dict()
-        with open(tasks_config, encoding="utf-8") as f:
-            for line in f:
-                d = json.loads(line)
-                tasks_dict[d["name"]] = d
-                if d["type"] not in task_by_formats:
-                    task_by_formats[d["type"]] = []
-                task_by_formats[d["type"]].append(d["name"])
-        if not task_list and not task_formats:
-            self.tasks = tasks_dict
-        elif task_list:
-            self.tasks = {k: tasks_dict[k] for k in task_list}
-        elif task_formats:
-            self.tasks = dict()
-            for task_format in task_formats:
-                self.tasks.update({k: tasks_dict[k] for k in task_by_formats[task_format]})
-        self.batch_size = batch_size
-        self.document=document
-
-    def evaluate(self, model: Union[Model, List[Model]], output: str):
-        final_results = dict()
-        if type(model) != list:
-            model = [model]
-        for task_name, task in tqdm(self.tasks.items(), total=len(self.tasks)):
-            for m in model:
-                m.task_id = TASK_IDS[task["type"]]
-            kwargs = dict()
-            task_data = task["data"]
-            if not task_data.get("meta"):
-                raise ValueError(f"Task {task_name} has no test metadata")
-            if task_data.get("meta"):
-                metadata = task_data["meta"]
-                kwargs["meta_dataset"] = metadata if type(metadata) != dict else (metadata["name"], metadata["config"])
-
-            if not task_data.get("test"):
-                if type(metadata) == dict:
-                    kwargs["test_dataset"] = (metadata["name"], metadata["config"])
-                else:
-                    raise ValueError(f"Task {task_name} has no test data")
-            if task_data.get("test"):
-                testdata = task_data["test"]
-                kwargs["test_dataset"] = testdata if type(testdata) != dict else (testdata["name"], testdata["config"])
-
-            kwargs["metrics"] = tuple(task["metrics"])
-
-            kwargs["batch_size"] = task["batch_size"] if "batch_size" in task else self.batch_size
-
-            if "fields" in task:
-                kwargs["fields"] = task["fields"]
-            save_path, load_path = None, None
-            if "embeddings" in task:
-                save_path = task["embeddings"].get("save")
-                load_path = task["embeddings"].get("load")
-            few_shot_evaluators = []
-            if task["type"] in {"classification", "regression"}:
-                subtype = SupervisedTask.CLASSIFICATION if task[
-                                                               "type"] == "classification" else SupervisedTask.REGRESSION
-                if task.get("multi_label"):
-                    subtype = SupervisedTask.MULTILABEL_CLASSIFICATION
-                evaluator = SupervisedEvaluator(task_name, subtype, model=model,
-                                                **kwargs)
-                if task.get("few_shot"):
-                    for run in task["few_shot"]:
-                        few_shot_evaluators.append(
-                            FewShotEvaluator(f"{task_name} {run['sample_size']} shot", subtype, model=model,
-                                             sample_size=run["sample_size"], num_iterations=run["iterations"],
-                                             **kwargs))
-            else:
-                if task_name == "Paper-Reviewer Matching":
-                    if not task_data.get("reviewers") and not task_data.get("hf_reviewers"):
-                        raise ValueError(f"Task {task_name} has no reviewer metadata locally or hf_metadata")
-                    if task_data.get("reviewers"):
-                        reviewers = task_data["reviewers"]
-                        kwargs["reviewer_metadata"] = reviewers if type(reviewers) != dict else (
-                            reviewers["name"], reviewers["config"])
-                    evaluator = ReviewerMatchingEvaluator(task_name, model=model, **kwargs)
-                else:
-                    data_class = SimpleDataset if task_data.get("simple_format") else IRDataset
-                    evaluator = IREvaluator(task_name, model=model, dataset_class=data_class, **kwargs)
-            embeddings = evaluator.generate_embeddings(save_path, htrans=args.htrans, document=args.document) if not load_path else load_path
-            results = evaluator.evaluate(embeddings)
-            if not few_shot_evaluators:
-                final_results[task_name] = results
-            else:
-                final_results[task_name] = dict()
-                final_results[task_name]["complete"] = results
-                final_results[task_name]["few_shot"] = []
-
-            for few_shot in few_shot_evaluators:
-                final_results[task_name]["few_shot"].append(
-                    {"sample_size": few_shot.sample_size, "results": few_shot.evaluate(embeddings)})
-            final_results[task_name]["task_name"] = task_name
-            with open(output, "a") as f:
-                json.dump(final_results[task_name], f, indent=4)
-                f.write("\n")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--tasks-config', help='path to the task config file', default="super_scirep.jsonl")
-    parser.add_argument('--mtype', help='Model variant to be used (default, pals, adapters, fusion)', default="default")
-    parser.add_argument('--gpt3-model', help='Name of embedding model in case of using openai api', default=None)
-    parser.add_argument('--model', '-m', help='HuggingFace model to be used')
-    parser.add_argument('--max_len', default=512, type=int)
-    parser.add_argument('--batch-size', type=int, default=32, help='batch size')
-    parser.add_argument('--ctrl-tokens', action='store_true', default=False, help='use control codes for tasks')
-    parser.add_argument('--adapters-dir', help='path to the adapter checkpoints', default=None)
-    parser.add_argument('--fusion-dir', help='path to the fusion checkpoints', default=None)
-    parser.add_argument('--adapters-chkpt', help='hf adapter names keyed on tasks', default=None, type=json.loads)
-    parser.add_argument('--output', help="path to the output file", default="scirepeval_results.json")
-    parser.add_argument('--fp16', action='store_true', default=False, help='use floating point 16 precision')
-    parser.add_argument('--htrans', action='store_true', default=False, help='use hierarchical model')
-    parser.add_argument('--instructor', action='store_true', default=False, help='use an instructor model for eval')
-    parser.add_argument('--document', action='store_true', default=False)
-
-    args = parser.parse_args()
-    adapters_load_from = args.adapters_dir if args.adapters_dir else args.adapters_chkpt
-    os.environ["TOKENIZERS_PARALLELISM"] = "false"
-    if args.gpt3_model:
-        model = GPT3Model(embed_model=args.gpt3_model)
-    elif args.instructor:
-        model = InstructorModel(args.model)
-    elif args.htrans:
-        model = HModel(variant=args.mtype, base_checkpoint=args.model, adapters_load_from=adapters_load_from,
-                      fusion_load_from=args.fusion_dir,
-                      use_ctrl_codes=args.ctrl_tokens,
-                      task_id="", all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"], use_fp16=args.fp16)
-    else:
-        model = Model(variant=args.mtype, base_checkpoint=args.model, adapters_load_from=adapters_load_from,
-                      fusion_load_from=args.fusion_dir,
-                      use_ctrl_codes=args.ctrl_tokens,
-                      task_id="", all_tasks=["[CLF]", "[QRY]", "[RGN]", "[PRX]"], use_fp16=args.fp16, document=args.document)
-    evaluator = SciRepEval(tasks_config=args.tasks_config, batch_size=args.batch_size, document=args.document)
-    evaluator.evaluate(model, args.output)

scirepeval_tasks.jsonl

@@ -1,22 +0,0 @@
-{"name":"Biomimicry","type":"classification","data":{"meta":{"name":"allenai/scirepeval","config":"biomimicry"},"test":{"name":"allenai/scirepeval_test","config":"biomimicry"}},"metrics":["f1"],"few_shot":[{"sample_size":64,"iterations":50},{"sample_size":16,"iterations":100}]}
-{"name":"DRSM","type":"classification","data":{"meta":{"name":"allenai/scirepeval","config":"drsm"},"test":{"name":"allenai/scirepeval_test","config":"drsm"}},"metrics":["f1_macro"],"few_shot":[{"sample_size":64,"iterations":50},{"sample_size":24,"iterations":100}]}
-{"name":"Feeds-1","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_1"},"test":{"name":"allenai/scirepeval_test","config":"feeds_1"}},"metrics":["map"]}
-{"name":"Feeds-M","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_m"},"test":{"name":"allenai/scirepeval_test","config":"feeds_m"}},"metrics":["map"]}
-{"name":"Feeds Title","type":"adhoc_search","data":{"meta":{"name":"allenai/scirepeval","config":"feeds_title"},"test":{"name":"allenai/scirepeval_test","config":"feeds_title"}},"metrics":["map"]}
-{"name":"TREC-CoVID","type":"adhoc_search","data":{"meta":{"name":"allenai/scirepeval","config":"trec_covid"},"test":{"name":"allenai/scirepeval_test","config":"trec_covid"}},"metrics":["ndcg"]}
-{"name":"Peer Review Score","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"peer_review_score_hIndex"},"test":{"name":"allenai/scirepeval_test","config":"peer_review_score"}},"embeddings":{"save":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
-{"name":"Max hIndex","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"peer_review_score_hIndex"},"test":{"name":"allenai/scirepeval_test","config":"hIndex"}},"embeddings":{"load":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
-{"name":"Tweet Mentions","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"tweet_mentions"},"test":{"name":"allenai/scirepeval_test","config":"tweet_mentions"}},"metrics":["kendalltau"]}
-{"name":"SciDocs MAG","type":"classification","data":{"meta":{"name":"allenai/scirepeval","config":"scidocs_mag_mesh"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_mag"}},"embeddings":{"save":"embeddings/scidocs_mag_mesh.jsonl"},"metrics":["f1_macro"]}
-{"name":"SciDocs MeSH","type":"classification","data":{"meta":{"name":"allenai/scirepeval","config":"scidocs_mag_mesh"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_mesh"}},"embeddings":{"load":"embeddings/scidocs_mag_mesh.jsonl"},"metrics":["f1_macro"]}
-{"name":"SciDocs Cite","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_cite"}},"embeddings":{"save":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"SciDocs CoView","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_view"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"SciDocs CoCite","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_cocite"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"SciDocs CoRead","type":"proximity","data":{"simple_format":true, "meta":{"name":"allenai/scirepeval","config":"scidocs_view_cite_read"},"test":{"name":"allenai/scirepeval_test","config":"scidocs_read"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"Same Author Detection","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"same_author"},"test":{"name":"allenai/scirepeval_test","config":"same_author"}},"metrics":["map"]}
-{"name":"Highly Influential Citations","type":"proximity","data":{"meta":{"name":"allenai/scirepeval","config":"high_influence_cite"},"test":{"name":"allenai/scirepeval_test","config":"high_influence_cite"}},"metrics":["map"]}
-{"name":"Search","type":"adhoc_search","data":{"meta":{"name":"allenai/scirepeval","config":"search"},"test":{"name":"allenai/scirepeval_test","config":"search"}},"fields":["title","abstract","venue","year"],"metrics":["ndcg"]}
-{"name":"Citation Count","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"cite_count"},"test":{"name":"allenai/scirepeval_test","config":"cite_count"}},"metrics":["kendalltau"]}
-{"name":"Publication Year","type":"regression","data":{"meta":{"name":"allenai/scirepeval","config":"pub_year"},"test":{"name":"allenai/scirepeval_test","config":"pub_year"}},"metrics":["kendalltau"]}
-{"name":"Fields of study","type":"classification","data":{"meta":{"name":"allenai/scirepeval","config":"fos"},"test":{"name":"allenai/scirepeval_test","config":"fos"}},"metrics":["f1_macro"],"few_shot":[{"sample_size":10,"iterations":50},{"sample_size":5,"iterations":100}],"multi_label":true}
-{"name":"MeSH","type":"classification","data":{"meta":{"name":"allenai/scirepeval","config":"mesh_descriptors"},"test":{"name":"allenai/scirepeval_test","config":"mesh_descriptors"}},"metrics":["f1_macro"]}

super_scirep.jsonl

@@ -1,16 +0,0 @@
-{"name":"Feeds-1","type":"proximity","data":{"meta":{"name":"howey/super_scirep","config":"feeds_1"},"test":{"name":"howey/super_scirep_test","config":"feeds_1"}},"metrics":["map"]}
-{"name":"Feeds-M","type":"proximity","data":{"meta":{"name":"howey/super_scirep","config":"feeds_m"},"test":{"name":"howey/super_scirep_test","config":"feeds_m"}},"metrics":["map"]}
-{"name":"Highly Influential Citations","type":"proximity","data":{"meta":{"name":"howey/super_scirep","config":"high_influence_cite"},"test":{"name":"howey/super_scirep_test","config":"high_influence_cite"}},"metrics":["map"]}
-{"name":"SciDocs Cite","type":"proximity","data":{"simple_format":true, "meta":{"name":"howey/super_scirep","config":"scidocs_view_cite_read"},"test":{"name":"howey/super_scirep_test","config":"scidocs_cite"}},"embeddings":{"save":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"SciDocs CoCite","type":"proximity","data":{"simple_format":true, "meta":{"name":"howey/super_scirep","config":"scidocs_view_cite_read"},"test":{"name":"howey/super_scirep_test","config":"scidocs_cocite"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"Fields of study","type":"classification","data":{"meta":{"name":"howey/super_scirep","config":"fos"},"test":{"name":"howey/super_scirep_test","config":"fos"}},"metrics":["f1_macro"],"few_shot":[{"sample_size":10,"iterations":50},{"sample_size":5,"iterations":100}],"multi_label":true}
-{"name":"Publication Year","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"pub_year"},"test":{"name":"howey/super_scirep_test","config":"pub_year"}},"metrics":["kendalltau"]}
-{"name":"Search","type":"adhoc_search","data":{"meta":{"name":"howey/super_scirep","config":"search"},"test":{"name":"howey/super_scirep_test","config":"search"}},"fields":["title","abstract","venue","year"],"metrics":["ndcg"]}
-{"name":"Feeds Title","type":"adhoc_search","data":{"meta":{"name":"howey/super_scirep","config":"feeds_title"},"test":{"name":"howey/super_scirep_test","config":"feeds_title"}},"metrics":["map"]}
-{"name":"Paper-Reviewer Matching","type":"proximity","data":{"meta":{"name":"howey/super_scirep","config":"paper_reviewer_matching"},"test":{"name":"howey/super_scirep_test","config":"paper_reviewer_matching"},"reviewers":{"name":"howey/super_scirep_test","config":"reviewers"}},"metrics":["P_5", "P_10"]}
-{"name":"SciDocs CoView","type":"proximity","data":{"simple_format":true, "meta":{"name":"howey/super_scirep","config":"scidocs_view_cite_read"},"test":{"name":"howey/super_scirep_test","config":"scidocs_view"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"SciDocs CoRead","type":"proximity","data":{"simple_format":true, "meta":{"name":"howey/super_scirep","config":"scidocs_view_cite_read"},"test":{"name":"howey/super_scirep_test","config":"scidocs_read"}},"embeddings":{"load":"embeddings/scidocs_view_cite_read.jsonl"},"metrics":["map","ndcg"]}
-{"name":"Peer Review Score","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"peer_review_score_hIndex"},"test":{"name":"howey/super_scirep_test","config":"peer_review_score"}},"embeddings":{"save":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
-{"name":"Max hIndex","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"peer_review_score_hIndex"},"test":{"name":"howey/super_scirep_test","config":"hIndex"}},"embeddings":{"load":"embeddings/peer_review_score_hIndex.jsonl"},"metrics":["kendalltau"]}
-{"name":"Tweet Mentions","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"tweet_mentions"},"test":{"name":"howey/super_scirep_test","config":"tweet_mentions"}},"metrics":["kendalltau"]}
-{"name":"Citation Count","type":"regression","data":{"meta":{"name":"howey/super_scirep","config":"cite_count"},"test":{"name":"howey/super_scirep_test","config":"cite_count"}},"metrics":["kendalltau"]}

training/TRAINING.md

@@ -1,138 +0,0 @@
-## Training
-The code available as part of this sub-directory can be used to train a general purpose multi-task model or the multi-format based models introduced in [SciRepEval]([https://openreview.net/pdf?id=zfiYcbeQkH](https://arxiv.org/abs/2211.13308)).
-
-Post the quick setup step in ReadMe, you can choose to train the following base models:
-(Parenthesis denote how they are referred in the paper)
- 1. General multi task model (MTL CLS) - \[CLS\] token embedding is considered document representation
- 2. Multi-task training w. Control Codes (MTL CTRL) - Control codes prepended to input and their embedding is considered document representation
- 3. [BERT PALs](https://github.com/AsaCooperStickland/Bert-n-Pals) (PALs) - Task specific modules
- 4. [Adapters and Fusion](https://github.com/adapter-hub/adapter-transformers) - Task specific adapters
-
-#### Step 1
-```bash
-cd ${ROOT}/training
-```
-
-Define the tasks and associated metadata as a list in a json config file. Refer to [sample_data/tasks_config.json](https://github.com/allenai/scirepeval/blob/main/training/sample_data/tasks_config.json) for SciRepEval training config**.
-
-** The example config below assumes the training data has been downloaded locally and uses the `"data_files"` property. For using HuggingFace datasets please follow the notes following the example config and use the `"dataset"` property.
-
-*Example config:*
-```json
-[
- {
-     "name": "fos",
-     "type": "classification",
-     "multi_label": true,
-     "data_files":
-     {
-         "train": "<scirepeval_data_dir>/train/fos/train.jsonl",
-         "dev": "<scirepeval_data_dir>/train/fos/val.jsonl"
-     },
-     "labels": "sample_data/fos_labels.txt",
-     "labels_field": "labels_text",
-     "ctrl_token": "[CLF]",
-     "sample_size":
-     {
-         "train": 600000,
-         "dev": 40000
-     }
- }
-]
-
-```
-**Note**
-
- - `"type"` can be one of `["classification", "regression", "ir", "triplet"]`.
- - `"classification"` is suitable for tasks with categorical (discrete) labels,;`"regression"` for tasks with continuous labels; `"ir"` for retrieval tasks formatted as `{"query": X, "candidates": [{}]}` and `"triplet"` for contrastive learning tasks formatted as `{"query": q, "pos": p, "neg": n}`.
- - For multi label classification, add  `"multi_label": true` as in the above example.
- - By default the pre-processing code expects "title" and "abstract" in every example. To process specific fields, provide  additional property as `"input_fields": ["title", "abstract", "venue", "year"]`.
- - For models apart from MTL CLS, provide the `"ctrl_token"` associated with each task, for MTL CTRL it works as the special control code and for PALs and Adapters it acts as the task id to determine the module to be used in the forward pass.
- - Some "ir" tasks like ad-hoc search \[SRCH\] might require different control codes forthe query and candidates which can be provided as `"ctrl_token": {"query": "[QRY]", "candidates": "[PRX]"}`. For PALs and Adapters, this task id is internally resolved to feed the queries and candidates to their relevant modules.
- - `"sample_size"` is not required if all the samples are to be processed for the splits.
- - If loading data from Huggingface datsets, instead of `"data_files"`, you can provide parameters for `load_dataset` method as - `"dataset": {"path": <hf dataset name>, "name": <optional config name for dataset with multiple configs>}`.
- - ``if "type"=="regresion": <provide the "labels_field"> elif "type" =="classification": <provide the "labels" and "labels_field"> ``
- - Losses associated with each task type:
- 
-|Type|Loss |
-|--|--|
-| Classification |Cross Entropy |
-|Multi-label Classification|Binary Cross Entropy|
-|Regression|Mean Squared Error|
-|IR/Triplet|Triplet or Contrastive Loss|
-
-
-#### Step 2
-To run the training script with default params, based upon the type of models you want to train run one of the following commands:
-**MTL CLS**
-```bash
-python pl_training.py --gpu 2 --tasks-config sample_data/tasks_config.json <base model name/chkpoint path> <expt name>
-```
-
-**MTL CTRL**
-```bash
-python pl_training.py --gpu 2 --ctrl-tokens --tasks-config sample_data/tasks_config.json <base model name/chkpoint path> <expt name>
-```
-
-**PALs**
-
-Requires pals config file for additional model configuration. Files present under `bert_pals_config` directory.
-```bash
-python pl_training.py --gpu 2 --pals-config pals.config.json --tasks-config sample_data/tasks_config.json <base model name/chkpoint path> <expt name>
-```
-**Adapters**
-```bash
-python pl_training.py --gpu 2 --adapter-type single --tasks-config sample_data/tasks_config.json <base model name/chkpoint path> <expt name>
-```
-**Fusion**
-
-    python pl_training.py --gpu 2 --adapter-type fusion --tasks-config sample_data/tasks_config.json <base model name/chkpoint path> <expt name>
-
-### Additional Parameters
-
-```positional arguments:
-
-model HuggingFace model to be used
-
-version experiment version
-
-  
-
-optional arguments:
-
--h, --help  show this help message and exit
-
---tasks-config TASKS_CONFG path to the task config file
-
---tokenizer TOKENIZER HuggingFace tokenizer to be used (same as model name if not supplied)
-
---output OUTPUT dir to save checkpoints and finetuned model
-
---pals-config PALS_CONFIG name of config file for PALS architecture
-
---adapter-type ADAPTER_TYPE type of adapter architecture (single/fusion)
-
---batch-size BATCH_SIZE batch size
-
---lr LR initial learning rate
-
---peak-lr PEAK_LR initial learning rate
-
---warmup WARMUP number of warmup steps
-
---epochs EPOCHS number of epochs
-
---grad-accum GRAD_ACCUM grad accumulation steps
-
---ctrl-tokens use control codes for tasks
-
---gpu GPU number of gpus
-
---max-len MAX_LEN max sequence length
-
---val-check-interval VAL_CHECK_INTERVAL validation loop interval
-
---checkpoint CHECKPOINT resume from checkpoint path
-```
-
-TensorBoard logs and checkpoints are written to `<output>/full_run/<version>` directory, by default `./lightning_logs/full_run/<expt name>`.

training/bert_pals_config/low_rank_config.json

@@ -1,15 +0,0 @@
-{
-  "hidden_size_aug": 100,
-  "mult": true,
-  "attention_probs_dropout_prob": 0.1,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
-  "hidden_size": 768,
-  "initializer_range": 0.02,
-  "intermediate_size": 3072,
-  "max_position_embeddings": 512,
-  "num_attention_heads": 12,
-  "num_hidden_layers": 12,
-  "type_vocab_size": 2,
-  "vocab_size": 30522
-}

training/bert_pals_config/pals.config.json

@@ -1,16 +0,0 @@
-{
-  "hidden_size_aug": 204,
-  "mult": true,
-  "pals": true,
-  "attention_probs_dropout_prob": 0.1,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
-  "hidden_size": 768,
-  "initializer_range": 0.02,
-  "intermediate_size": 3072,
-  "max_position_embeddings": 512,
-  "num_attention_heads": 12,
-  "num_hidden_layers": 12,
-  "type_vocab_size": 2,
-  "vocab_size": 31116
-}

training/mtl_datasets.py

@@ -1,311 +0,0 @@
-import decimal
-from typing import Iterator, Tuple, List, Dict, Union, Any, Iterable
-import torch
-from torch.utils.data import IterableDataset, DataLoader, ChainDataset, get_worker_info
-from torch.utils.data.dataset import T_co, Dataset
-from transformers import PreTrainedTokenizer, BatchEncoding, AutoTokenizer
-import datasets
-import numpy as np
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import MultiLabelBinarizer
-from skmultilearn.model_selection import IterativeStratification
-from abc import ABC, abstractmethod
-import itertools
-from torch.utils.data._utils.collate import default_collate
-from collections import defaultdict
-from strategies import BatchingStrategy
-import random
-
-datasets.logging.set_verbosity_error()
-
-
-class AbstractMultiTaskDataset(ABC, IterableDataset):
-    def __init__(self, task_name: str, data: datasets.Dataset, tokenizer: PreTrainedTokenizer,
-                 fields: List[str],
-                 sample_size, ctrl_token: str, max_len: int):
-        self.task_name = task_name
-        self.data = data
-        self.tokenizer = tokenizer
-        self.fields = fields
-        self.sample_size = sample_size
-        self.ctrl_token = ctrl_token
-        self.max_len = max_len
-        self._effective_sample_size = sample_size
-
-    def sub_sample(self, json_parse: Iterator[Dict]) -> Iterator:
-        curr_len = 0
-        try:
-            for _ in range(self.effective_sample_size):
-                curr_len += 1
-                yield next(json_parse)
-        except StopIteration:
-            print(
-                f"Reqd sample size {self.effective_sample_size} greater than {self.task_name} dataset size {curr_len}, using complete dataset")
-
-    @abstractmethod
-    def preprocess(self, line: Dict[str, str]) -> Union[
-        Tuple[str, BatchEncoding, torch.Tensor], List[Tuple[str, List[BatchEncoding]]]]:
-        pass
-
-    def postprocess_iter(self, curr_iter):
-        return curr_iter
-
-    @property
-    def effective_sample_size(self):
-        return self._effective_sample_size
-
-    @effective_sample_size.setter
-    def effective_sample_size(self, val):
-        self._effective_sample_size = val
-
-    def __iter__(self) -> Iterator[T_co]:
-        json_parse = iter(self.data)
-        if self.sample_size == -1:
-            map_itr = map(self.preprocess, json_parse)
-        else:
-            map_itr = map(self.preprocess, self.sub_sample(json_parse))
-        return self.postprocess_iter(map_itr)
-
-    def tokenized_input(self, input_data: Union[Dict[str, str], str], ctrl_token_key: str = None) -> BatchEncoding:
-        text = []
-        if type(input_data) == dict:
-            for field in self.fields:
-                if input_data[field]:
-                    if type(input_data[field]) in set([decimal.Decimal, float]):
-                        input_data[field] = str(int(input_data[field]))
-                    text.append(input_data[field])
-            text = (f" {self.tokenizer.sep_token} ".join(text)).strip()
-        else:
-            text = input_data
-        if self.ctrl_token:
-            ctrl_token = self.ctrl_token if not ctrl_token_key else self.ctrl_token[ctrl_token_key]
-            text = ctrl_token + " " + text
-        input_ids = self.tokenizer(text, padding="max_length", truncation=True, return_tensors="pt",
-                                   max_length=self.max_len)
-        # if self.ctrl_token:
-        #     input_ids["input_ids"] = input_ids["input_ids"][:,1:]
-        #     input_ids["attention_mask"] = input_ids["attention_mask"][:,1:]
-        return {"input_ids": input_ids["input_ids"].flatten(), "attention_mask": input_ids["attention_mask"].flatten()}
-
-
-class ClassificationDataset(AbstractMultiTaskDataset):
-    def __init__(self, task_name: str, data: datasets.Dataset, tokenizer: PreTrainedTokenizer,
-                 fields: List[str],
-                 label_field: str, labels: Dict[str, int], sample_size=-1, ctrl_token: str = None, max_len: int = 512):
-        super().__init__(task_name, data, tokenizer, fields, sample_size, ctrl_token, max_len)
-        self.labels = labels
-        self.label_field = label_field
-
-    def label_transform(self, label_raw: str) -> Union[int, np.ndarray]:
-        return self.labels[label_raw]
-
-    def preprocess(self, line: Dict[str, str]) -> Tuple[str, BatchEncoding, int]:
-        # Splits the line into text and label and applies preprocessing to the text
-        label = line[self.label_field]
-        input_ids = self.tokenized_input(line)
-        return self.task_name, input_ids, self.label_transform(label)
-
-    def sub_sample(self, json_parse: Iterator[Dict]) -> Iterator:
-        # json_itr_list = itertools.tee(json_parse, 2)
-        # json_parse = json_itr_list[0]
-        X, y = zip(*[(d, self.labels[d[self.label_field]]) for d in json_parse])
-        X, y = np.array(X), np.array(y)
-        if X.shape[0] < self.effective_sample_size:
-            print(
-                f"Reqd sample size {self.effective_sample_size} greater than {self.task_name} dataset size {X.shape[0]}, using complete dataset")
-            X_sub = X
-        else:
-            X_sub, _, _, _ = train_test_split(X, y, train_size=self.effective_sample_size, random_state=42, stratify=y)
-        for d in X_sub:
-            yield d
-
-
-class MultiLabelClassificationDataset(ClassificationDataset):
-    def __init__(self, task_name: str, data: datasets.Dataset, tokenizer: PreTrainedTokenizer,
-                 fields: List[str],
-                 label_field: str, labels: Dict[str, int], sample_size=-1, ctrl_token: str = None, max_len: int = 512):
-        super().__init__(task_name, data, tokenizer, fields, label_field, labels, sample_size, ctrl_token, max_len)
-        self.labels = dict(sorted(labels.items()))
-        self.mlb = MultiLabelBinarizer()
-        self.mlb.fit([list(self.labels.keys())])
-
-    def label_transform(self, label_raw: List[str]) -> Union[int, np.ndarray]:
-        return self.mlb.transform([label_raw]).flatten().astype(float)
-
-    def sub_sample(self, json_parse: Iterator[Dict]) -> Iterator:
-        X, y = zip(*[(d, tuple(d[self.label_field])) for d in json_parse])
-        X, y = np.array(X), self.mlb.transform(y)
-        if X.shape[0] < self.effective_sample_size:
-            print(
-                f"Reqd sample size {self.effective_sample_size} greater than {self.task_name} dataset size {X.shape[0]}, using complete dataset")
-            X_sub = X
-        else:
-            sub_sample_ratio = self.effective_sample_size / X.shape[0]
-            stratifier = IterativeStratification(n_splits=2, order=1,
-                                                 sample_distribution_per_fold=[sub_sample_ratio,
-                                                                               1 - sub_sample_ratio, ])
-            _, indices = next(stratifier.split(X, y))
-            X_sub = X[indices]
-        for d in X_sub:
-            yield d
-
-
-class IRDataset(AbstractMultiTaskDataset):
-    def __init__(self, task_name: str, data: datasets.Dataset, tokenizer: PreTrainedTokenizer,
-                 fields: List[str],
-                 sample_size=-1, ctrl_token: str = None, max_len: int = 512):
-        super().__init__(task_name, data, tokenizer, fields, sample_size, ctrl_token, max_len)
-        self.effective_sample_size //= 5
-
-    def preprocess(self, line: Dict[str, str]) -> List[Tuple[str, List[BatchEncoding]]]:
-        # Splits the line into text and label and applies preprocessing to the text
-        query, candidates = line["query"], line["candidates"]
-        pos_candidates, neg_candidates = [c for c in candidates if c["score"]], [c for c in candidates if
-                                                                                 not c["score"]]
-        num_trips = min(5, len(neg_candidates))
-        new_pos_candidates = pos_candidates.copy()
-        if pos_candidates:
-            pos_candidates = itertools.cycle(pos_candidates)
-            while len(new_pos_candidates) < num_trips:
-                new_pos_candidates.append(next(pos_candidates))
-        query_ctrl_key, cand_ctrl_key = None, None
-        if type(self.ctrl_token) == dict:
-            query_ctrl_key = "query"
-            cand_ctrl_key = "candidates"
-        tokenized_query = self.tokenized_input(query, query_ctrl_key)
-
-        for pos in new_pos_candidates[:num_trips]:
-            neg = neg_candidates.pop()
-            tokenized_pos = self.tokenized_input(pos, cand_ctrl_key)
-            tokenized_neg = self.tokenized_input(neg, cand_ctrl_key)
-            yield (self.task_name, [tokenized_query, tokenized_pos, tokenized_neg])
-
-    def postprocess_iter(self, curr_iter):
-        # chained_iter = itertools.chain(*curr_iter)
-        batched_list = []
-        try:
-            while True:
-                while len(batched_list) < 1000:
-                    batched_list += next(curr_iter)
-                random.shuffle(batched_list)
-                for x in batched_list:
-                    yield x
-                batched_list.clear()
-        except StopIteration:
-            random.shuffle(batched_list)
-            for x in batched_list:
-                yield x
-
-
-class TripletDataset(AbstractMultiTaskDataset):
-    def __init__(self, task_name: str, data: datasets.Dataset, tokenizer: PreTrainedTokenizer,
-                 fields: List[str],
-                 sample_size=-1, ctrl_token: str = None, max_len: int = 512):
-        super().__init__(task_name, data, tokenizer, fields, sample_size, ctrl_token, max_len)
-
-    def preprocess(self, line: Dict[str, str]) -> Union[
-        Tuple[str, BatchEncoding, torch.Tensor], List[Tuple[str, List[BatchEncoding]]]]:
-        triplet = []
-        for key in ("query", "pos", "neg"):
-            triplet.append(self.tokenized_input(line[key]))
-        return self.task_name, triplet
-
-
-class CustomChainDataset(ChainDataset):
-    def __init__(self, datasets: Iterable[Dataset], batch_size, device_rank=0, num_devices=1,
-                 batching_strategy=BatchingStrategy.SEQUENTIAL):
-        super().__init__(datasets)
-        self.batch_size = batch_size
-        self.batching = batching_strategy
-        self.device_rank = device_rank
-        self.num_devices = num_devices
-        self.effective_batch_size = batch_size * num_devices
-
-    def iter_slice(self, curr_iter, worker_info):
-        curr_batch, idx = dict(), 0
-        try:
-            while True:
-                for _ in range(self.effective_batch_size):
-                    curr_batch[idx] = next(curr_iter)
-                    idx += 1
-                for i, x in curr_batch.items():
-                    if (i // self.batch_size) % self.num_devices == self.device_rank:
-                        if (i // self.effective_batch_size) % worker_info.num_workers == worker_info.id:
-                            yield x
-                curr_batch.clear()
-        except StopIteration:
-            curr_batch.clear()
-
-    def __iter__(self):
-        batch_itr = self.batching.value.get_batch_iter(self.datasets, self.effective_batch_size)
-        worker_info = get_worker_info()
-        if worker_info:
-            batch_itr = self.iter_slice(batch_itr, worker_info)
-
-        return batch_itr
-
-
-class RegressionDataset(AbstractMultiTaskDataset):
-    def __init__(self, task_name: str, data: datasets.Dataset, tokenizer: PreTrainedTokenizer,
-                 fields: List[str],
-                 label_field: str, sample_size=-1, ctrl_token: str = None, max_len: int = 512):
-        super().__init__(task_name, data, tokenizer, fields, sample_size, ctrl_token, max_len)
-        self.label_field = label_field
-
-    def preprocess(self, line: Dict[str, str]) -> Tuple[str, Dict[str, BatchEncoding], Union[int, float]]:
-        # Splits the line into text and label and applies preprocessing to the text
-        label = np.float32(line[self.label_field])
-        input_ids = self.tokenized_input(line)
-        return self.task_name, input_ids, label
-
-
-def multi_collate(batch: List[Any]) -> Dict[str, List[Any]]:
-    task_sub_batch = defaultdict(list)
-    for b in batch:
-        task_sub_batch[b[0]].append(b[1:])
-    return {task: default_collate(sub_batch) for task, sub_batch in task_sub_batch.items()}
-
-
-if __name__ == '__main__':
-    tokenizer = AutoTokenizer.from_pretrained("allenai/specter")
-    tokenizer.add_special_tokens({'additional_special_tokens': ["[CLF]"]})
-    with open("sample_data/mesh_descriptors.txt", "r") as f:
-        labels = f.readlines()
-    labels = {l.strip(): i for i, l in enumerate(labels)}
-    cls_dataset = ClassificationDataset(task_name="mesh", data=
-    datasets.load_dataset("json", data_files="../../scidocs/data/mesh_plus/train.json", streaming=True)["train"],
-                                        tokenizer=tokenizer,
-                                        fields=["title", "abstract"],
-                                        label_field="descriptor", labels=labels, sample_size=400000)
-    trip_dataset = IRDataset(task_name="s2and", data=
-    datasets.load_dataset("json", data_files="sample_data/s2and_small.json", streaming=True)["train"],
-                             tokenizer=tokenizer,
-                             fields=["title", "abstract"], sample_size=400000)
-    specter_dataset = TripletDataset(task_name="specter", data=
-    datasets.load_dataset("json", data_files="../../scidocs/data/specter_triplets/train.json", streaming=True)["train"],
-                                     tokenizer=tokenizer,
-                                     fields=["title", "abstract"], sample_size=400000)
-    search_dataset = IRDataset(task_name="search", data=
-    datasets.load_dataset("json", data_files="sample_data/search_small.jsonl", streaming=True)["train"],
-                               tokenizer=tokenizer,
-                               fields=["title", "abstract", "venue", "year"], sample_size=100)
-    with open("sample_data/fos_labels.txt", "r") as f:
-        mlc_labels = f.readlines()
-    mlc_labels = {l.strip(): i for i, l in enumerate(mlc_labels)}
-
-    ml_cls_dataset = MultiLabelClassificationDataset(task_name="fos", data_src="sample_data/fos_small.json",
-                                                     tokenizer=tokenizer,
-                                                     fields=["title", "abstract"],
-                                                     label_field="labels_text", labels=mlc_labels, sample_size=100,
-                                                     ctrl_token="[CLF]")
-
-    batch_size = 16
-    multi_dataset = CustomChainDataset([ml_cls_dataset], batch_size=batch_size,
-                                       batching_strategy=BatchingStrategy.MIXED_PROPORTIONAL)
-    dataloader = DataLoader(multi_dataset, batch_size=batch_size, collate_fn=multi_collate, num_workers=8)
-    for i, data in enumerate(dataloader):
-        print(i)
-        for task, batch in data.items():
-            d = batch[-1][-1] if task in ("s2and", "specter", "search") else batch[-1]
-            print(task, d.shape[0])
-            print(batch)

training/pl_training.py

@@ -1,325 +0,0 @@
-import json
-import sys
-
-# setting path
-sys.path.append('../')
-
-import argparse
-from typing import Dict, Optional, Any
-import datasets
-import pytorch_lightning as pl
-import torch
-import torch.nn
-from pytorch_lightning.callbacks import ModelCheckpoint
-from pytorch_lightning.loggers import TensorBoardLogger
-from pytorch_lightning.utilities.distributed import rank_zero_only
-from pytorch_lightning.utilities.distributed import sync_ddp_if_available
-from pytorch_lightning.utilities.types import TRAIN_DATALOADERS, EVAL_DATALOADERS, STEP_OUTPUT
-from torch.distributed import ReduceOp
-from torch.utils.data import DataLoader
-from transformers import AdamW, get_linear_schedule_with_warmup
-from transformers import AutoTokenizer, AutoModel, AutoConfig
-
-from adapter_fusion import AdapterFactory
-from bert_pals import BertPalsEncoder
-from mtl_datasets import ClassificationDataset, multi_collate, MultiLabelClassificationDataset, IRDataset, \
-    CustomChainDataset, TripletDataset, RegressionDataset
-from schedulers import InverseSquareRootSchedule, InverseSquareRootScheduleConfig
-from strategies import BatchingStrategy
-from tasks import TaskFamily, load_tasks
-
-pl.seed_everything(42, workers=True)
-
-
-def init_weights(modules):
-    for module in modules:
-        module.linear.weight.data.normal_(mean=0.0, std=0.02)
-        if module.linear.bias is not None:
-            module.linear.bias.data.zero_()
-
-
-pl_to_split_map = {"fit": "train", "validate": "dev", "test": "test", "predict": "test"}
-
-
-class SciRepTrain(pl.LightningModule):
-    def __init__(self, batch_size: int, init_lr: float, peak_lr: float, tokenizer: str, model: str, warmup_steps: int,
-                 log_dir: str,
-                 use_ctrl_tokens=False,
-                 task_dict: Dict[str, TaskFamily] = None,
-                 pals_cfg: str = None, adapter_type: str = None, max_len: int = 512, load_adapters_as=None):
-        super().__init__()
-        self.task_dict = load_tasks() if not task_dict else task_dict
-        print(self.task_dict.keys())
-        self.heads = torch.nn.ModuleDict(
-            {t.name: t.head for t in self.task_dict.values() if t.head}
-        )
-        self.init_loss = None
-        self.task_idx = {t: i for i, t in enumerate(self.task_dict)}
-        self.loss_wt = torch.ones(len(self.task_dict)).float()
-        init_weights(self.heads.values())
-        self.warmup_steps = warmup_steps
-        self.multi_train = None
-        self.multi_test = None
-        self.multi_val = None
-        self.pals = pals_cfg is not None
-        self.adapters = adapter_type is not None
-        self.use_ctrl_tokens = use_ctrl_tokens
-        spl_ctrl_tokens = set()
-        for t in self.task_dict.values():
-            if type(t.ctrl_token) == str:
-                spl_ctrl_tokens.add(t.ctrl_token)
-            else:
-                spl_ctrl_tokens.update(t.ctrl_token.values())
-        spl_ctrl_tokens = sorted(list(spl_ctrl_tokens))
-        task_ids = spl_ctrl_tokens
-        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer)
-
-        if self.adapters:
-            adapters_dir = f'{log_dir}/model/adapters/' if not load_adapters_as else load_adapters_as
-            try:
-                adapters_dir = json.loads(adapters_dir)
-            except:
-                pass
-            self.encoder = AdapterFactory.get_adapter(model, task_ids,
-                                                      adapter_type == "fusion", adapters_dir)
-        else:
-            self.encoder = AutoModel.from_pretrained(model)
-            if self.pals:
-                self.encoder = BertPalsEncoder(f"bert_pals_config/{pals_cfg}", task_ids, self.encoder)
-        if self.use_ctrl_tokens:
-            print("Using Control Tokens", spl_ctrl_tokens)
-            special_tokens_dict = {'additional_special_tokens': spl_ctrl_tokens}
-            num_added_toks = self.tokenizer.add_special_tokens(special_tokens_dict)
-            self.encoder.resize_token_embeddings(len(self.tokenizer))
-        self.batch_size = batch_size
-        self.init_lr = init_lr
-        self.peak_lr = peak_lr
-        self.max_len = max_len
-        self.save_hyperparameters(ignore=["task_dict"])
-
-    def forward(self, input_ids, attention_mask=None, token_idx=0, task_id=None):
-        if not self.pals:
-            embedding = self.encoder(input_ids, attention_mask=attention_mask) if not self.adapters else self.encoder(
-                input_ids,
-                attention_mask=attention_mask,
-                task_id=task_id)
-            return embedding.last_hidden_state[:, token_idx, :]
-        else:
-            embedding = self.encoder(input_ids, attention_mask=attention_mask, task_id=task_id)
-            return embedding[:, token_idx, :]
-
-    def configure_optimizers(self):
-        """Prepare optimizer and schedule (linear warmup and decay)"""
-        no_decay = ["bias", "LayerNorm.weight"]
-        optimizer_grouped_parameters = [
-            {
-                "params": [p for n, p in self.named_parameters() if
-                           p.requires_grad and not any(nd in n for nd in no_decay)],
-                "weight_decay": 0.0,
-            },
-            {
-                "params": [p for n, p in self.named_parameters() if
-                           p.requires_grad and any(nd in n for nd in no_decay)],
-                "weight_decay": 0.0,
-            }
-        ]
-        optimizer = AdamW(
-            optimizer_grouped_parameters, lr=self.init_lr, eps=1e-8
-        )
-
-        self.opt = optimizer
-        if self.pals or self.adapters:
-            scheduler = get_linear_schedule_with_warmup(optimizer, self.warmup_steps, 77500)
-        else:
-            scheduler_config = InverseSquareRootScheduleConfig(warmup_updates=self.warmup_steps,
-                                                               warmup_init_lr=self.init_lr,
-                                                               lr=self.peak_lr)
-            scheduler = InverseSquareRootSchedule(scheduler_config, optimizer)
-
-        return {
-            "optimizer": optimizer,
-            "lr_scheduler": {
-                "scheduler": scheduler,
-                "interval": "step",
-                "frequency": 1}
-        }
-
-    def calc_loss(self, train_batch, batch_idx):
-        losses, loss_per_task = [], torch.zeros(len(self.task_dict)).cuda()
-        scl = torch.tensor(0.0)
-        for name, batch in train_batch.items():
-            task = self.task_dict[name]
-            idx = 0 if not self.use_ctrl_tokens else 1
-            task_id = task.ctrl_token
-            if task.type not in set(["classification", "regression"]):
-                query, pos, neg = batch[0][0], batch[0][1], batch[0][2]
-                query_ctrl = cand_ctrl = task_id
-                if type(task_id) == dict:
-                    query_ctrl = task_id["query"]
-                    cand_ctrl = task_id["candidates"]
-                query_emb, pos_emb, neg_emb = self(query['input_ids'], query['attention_mask'], idx, query_ctrl), self(
-                    pos['input_ids'], pos['attention_mask'], idx, cand_ctrl), self(neg['input_ids'],
-                                                                                   neg['attention_mask'], idx,
-                                                                                   cand_ctrl)
-                curr_loss = task.loss(query_emb, pos_emb, neg_emb)
-            else:
-                x, y = batch[0], batch[1]
-                encoding = self(x['input_ids'], x['attention_mask'], idx, task_id)
-                logits = self.heads[name](encoding)
-                if task.type == "regression":
-                    logits = logits.squeeze()
-                curr_loss = task.loss(logits, y)
-                if task.multi_label:
-                    curr_loss = torch.mean(curr_loss, dim=1)
-                elif task.contrastive_loss:
-                    scl = task.contrastive_loss(encoding, y, self.heads[name].num_labels)
-                    curr_loss = 0.1 * curr_loss + 0.9 * scl
-            loss_per_task[self.task_idx[name]] = torch.mean(curr_loss)
-        return loss_per_task
-
-    def training_step(self, train_batch, batch_idx):
-        loss_per_task = self.calc_loss(train_batch, batch_idx)
-        loss = torch.sum(loss_per_task)
-        self.log("train_loss", loss, prog_bar=True, on_step=True, on_epoch=True, batch_size=self.batch_size)
-        self.log("lr", self.lr_schedulers().get_last_lr()[-1], on_step=True, on_epoch=False, prog_bar=True, logger=True)
-        return {"loss": loss}
-
-    def validation_step(self, train_batch, batch_idx) -> Optional[STEP_OUTPUT]:
-        loss_per_task = self.calc_loss(train_batch, batch_idx)
-        # loss_per_task = torch.mul(self.loss_wt.cuda(), loss_per_task)
-        loss = torch.sum(loss_per_task)
-        dist_loss_per_task = loss_per_task.clone().data
-        dist_loss_per_task = sync_ddp_if_available(dist_loss_per_task, reduce_op=ReduceOp.SUM)
-        for task in self.task_dict:
-            self.log(f"val_loss_{task}", dist_loss_per_task[self.task_idx[task]], on_step=True, on_epoch=True,
-                     prog_bar=False,
-                     batch_size=self.batch_size, rank_zero_only=True)
-        self.log("val_loss", loss, on_step=True, on_epoch=False, prog_bar=True)
-        self.log("avg_val_loss", loss, on_epoch=True, prog_bar=True, sync_dist=True, batch_size=self.batch_size)
-        return {"val_loss": loss}
-
-    def load_data(self, split) -> CustomChainDataset:
-        hf_split = "validation" if split == "dev" else "train"
-        dataset_list = []
-        task_dataset_map = {"classification": ClassificationDataset, "regression": RegressionDataset, "ir": IRDataset}
-        for t_name, task in self.task_dict.items():
-            data_file = {hf_split: task.data_files[split]} if task.data_files else None
-            dataset_name = (task.dataset, hf_split)
-            data_src = data_file if data_file else dataset_name
-            op_token = task.ctrl_token if self.use_ctrl_tokens else None
-            if type(data_src) == dict:
-                data = datasets.load_dataset("json", data_files=data_src, streaming=True)[
-                    next(iter(data_src.keys()))]
-            else:
-                data = datasets.load_dataset(**data_src[0], split=data_src[1], streaming=True)
-            kwargs = {"data": data, "ctrl_token": op_token, "max_len": self.max_len, "task_name": t_name,
-                      "tokenizer": self.tokenizer, "fields": task.input_fields,
-                      "sample_size": task.sample_size[split] if type(task.sample_size) == dict else task.sample_size}
-
-            if task.type == "classification":
-                kwargs.update({"label_field": task.labels_field, "labels": task.labels})
-            elif task.type == "regression":
-                kwargs.update({"label_field": task.labels_field})
-            if task.multi_label:
-                dataset_list.append(MultiLabelClassificationDataset(**kwargs))
-            else:
-                dataset_list.append(task_dataset_map.get(task.type, TripletDataset)(**kwargs))
-        multi_dataset = CustomChainDataset(dataset_list, batch_size=self.batch_size,
-                                           device_rank=self.trainer.global_rank, num_devices=self.trainer.world_size,
-                                           batching_strategy=BatchingStrategy.MIXED_PROPORTIONAL)
-        if split == "train":
-            self.multi_train = multi_dataset
-        elif split == "dev":
-            self.multi_val = multi_dataset
-
-    def setup(self, stage: Optional[str] = None) -> None:
-        self.load_data("train")
-
-    def train_dataloader(self) -> TRAIN_DATALOADERS:
-        return DataLoader(self.multi_train, batch_size=self.batch_size, collate_fn=multi_collate, num_workers=8,
-                          pin_memory=True)
-
-    def val_dataloader(self) -> EVAL_DATALOADERS:
-        self.load_data("dev")
-        return DataLoader(self.multi_val, batch_size=self.batch_size, collate_fn=multi_collate, num_workers=8)
-
-    @rank_zero_only
-    def on_save_checkpoint(self, checkpoint: Dict[str, Any]) -> None:
-        try:
-            logger = self.logger
-            log_dir = f'{logger.save_dir}/{logger.name}/{logger.version}/checkpoints'
-            self.tokenizer.save_pretrained(f'{log_dir}/tokenizer/')
-            self.tokenizer.save_vocabulary(f'{log_dir}/tokenizer/')
-            self.encoder.save_pretrained(f'{log_dir}/model')
-        except:
-            print("Exception encountered while saving, try agin from checkpoint")
-
-
-if __name__ == '__main__':
-    torch.multiprocessing.set_sharing_strategy('file_system')
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--tasks-config', help='path to the task config file', default="sample_data/tasks_config.json")
-    parser.add_argument('model', help='HuggingFace model to be used')
-    parser.add_argument('--tokenizer', help='HuggingFace tokenizer to be used (same as model name if not supplied)',
-                        default=None)
-    parser.add_argument('--output', help='dir to save checkpoints and finetuned model', default="./lightning_logs/")
-    parser.add_argument('version', help='experiment version')
-    parser.add_argument('--pals-config', default=None, help='path to config file for PALS architecture')
-    parser.add_argument('--adapter-type', default=None, help='type of adapter architecture (single/fusion)')
-    parser.add_argument('--adapters-chkpt', default=None,
-                        help='Adapters to be loaded either from a directory path or a dictionary of pretrained huggingface adapters with id')
-    parser.add_argument('--batch-size', type=int, default=16, help='batch size')
-    parser.add_argument('--lr', type=float, default=1e-4, help='initial learning rate')
-    parser.add_argument('--peak-lr', type=float, default=5e-5, help='initial learning rate')
-    parser.add_argument('--warmup', type=int, default=700, help='number of warmup steps')
-    parser.add_argument('--epochs', type=int, default=2, help='number of epochs')
-    parser.add_argument('--grad-accum', type=int, default=8, help='grad accumulation steps')
-    parser.add_argument('--ctrl-tokens', action='store_true', default=False, help='use control codes for tasks')
-    parser.add_argument('--gpu', type=int, default=None, help='number of gpus')
-    parser.add_argument('--max-len', type=int, default=512, help='max sequence length')
-    parser.add_argument('--val-check_interval', type=float, default=1.0, help='validation loop interval')
-    parser.add_argument('--checkpoint', default=None, help='resume from checkpoint path')
-
-    args = parser.parse_args()
-    mconfig = AutoConfig.from_pretrained(args.model)
-    tasks_dict = load_tasks(args.tasks_config, mconfig.hidden_size)
-    log_dir = args.output
-    logger = TensorBoardLogger(
-        save_dir=log_dir,
-        version=args.version,
-        name='full_run',
-    )
-
-    # second part of the path shouldn't be f-string
-    filepath = f'{log_dir}/{logger.name}/{logger.version}/checkpoints/'
-    checkpoint_callback = ModelCheckpoint(
-        dirpath=filepath,
-        filename='ep-{epoch}_avg_val_loss-{avg_val_loss:.3f}',
-        save_top_k=4,
-        verbose=True,
-        monitor='avg_val_loss',  # monitors metrics logged by self.log.
-        mode='min'
-    )
-
-    model = SciRepTrain(batch_size=args.batch_size, init_lr=args.lr,
-                        peak_lr=args.peak_lr,
-                        tokenizer=args.tokenizer if args.tokenizer else args.model,
-                        model=args.model,
-                        warmup_steps=args.warmup,
-                        use_ctrl_tokens=args.ctrl_tokens, task_dict=tasks_dict, pals_cfg=args.pals_config,
-                        adapter_type=args.adapter_type, log_dir=filepath, max_len=args.max_len,
-                        load_adapters_as=args.adapters_chkpt)
-
-    hparams = {"gpus": args.gpu, "val_check_interval": args.val_check_interval, "num_sanity_val_steps": 4,
-               "max_epochs": args.epochs,
-               "accumulate_grad_batches": args.grad_accum, "resume_from_checkpoint": args.checkpoint}
-
-    trainer = pl.Trainer(logger=logger,
-                         strategy="ddp" if hparams["gpus"] > 1 else None,
-                         enable_checkpointing=True,
-                         callbacks=[checkpoint_callback],
-                         precision=16,
-                         **hparams)
-    logger.log_hyperparams(hparams)
-    logger.log_hyperparams({"tasks": {k: str(v) for k, v in tasks_dict.items()}})
-    trainer.fit(model)

training/sample_data/fos_labels.txt

@@ -1,23 +0,0 @@
-Agricultural and Food sciences
-Art
-Biology
-Business
-Chemistry
-Computer science
-Economics
-Education
-Engineering
-Environmental science
-Geography
-Geology
-History
-Law
-Linguistics
-Materials science
-Mathematics
-Medicine
-Philosophy
-Physics
-Political science
-Psychology
-Sociology

training/sample_data/mesh_descriptors.txt

@@ -1,30 +0,0 @@
-Brain
-Neoplasms
-Breast Neoplasms
-Liver
-Anti-Bacterial Agents
-Neurons
-Antineoplastic Agents
-HIV Infections
-DNA
-Proteins
-Calcium
-Hypertension
-Postoperative Complications
-Escherichia coli
-Lung Neoplasms
-Bacterial Proteins
-Aging
-Obesity
-Kidney
-Myocardial Infarction
-Diabetes Mellitus, Type 2
-Lung
-Liver Neoplasms
-Mental Disorders
-Asthma
-Prostatic Neoplasms
-Skin Neoplasms
-Cardiovascular Diseases
-Carcinoma, Squamous Cell
-Adenocarcinoma