```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-boolq


model author: AdapterHub


task: text-classification


tags: bert, en, dataset:boolq, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:qa/boolq, infinity_compatible


tags:


- text-classification
- roberta
- adapterhub:sts/mrpc
- adapter-transformers
language:
- en


# Adapter `AdapterHub/roberta-base-pf-mrpc` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [sts/mrpc](https://adapterhub.ml/explore/sts/mrpc/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


## Usage


First, install `adapter-transformers`:


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-mrpc", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


## Citation


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


model name: roberta-base-pf-mrpc


model author: AdapterHub


task: text-classification


tags: roberta, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:sts/mrpc, infinity_compatible


tags:


- text-classification
- adapter-transformers
- adapterhub:sts/qqp
- roberta
language:
- en


# Adapter `AdapterHub/roberta-base-pf-qqp` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [sts/qqp](https://adapterhub.ml/explore/sts/qqp/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-qqp", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-qqp


tags: roberta, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:sts/qqp, infinity_compatible


- question-answering
- bert
- adapter-transformers
datasets:
- hotpot_qa
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-hotpotqa` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [hotpot_qa](https://huggingface.co/datasets/hotpot_qa/) dataset and includes a prediction head for question answering.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-hotpotqa", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


## Citation


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


model name: bert-base-uncased-pf-hotpotqa


model author: AdapterHub


task: question-answering


tags: bert, en, dataset:hotpot_qa, arxiv:2104.08247, adapter-transformers, question-answering, infinity_compatible


tags:


- text-classification
- bert
- adapter-transformers
datasets:
- emo
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-emo` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [emo](https://huggingface.co/datasets/emo/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-emo", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-emo


task: text-classification


tags: bert, en, dataset:emo, arxiv:2104.08247, adapter-transformers, text-classification, infinity_compatible


- roberta
- adapter-transformers
datasets:
- swag
language:
- en


# Adapter `AdapterHub/roberta-base-pf-swag` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [swag](https://huggingface.co/datasets/swag/) dataset and includes a prediction head for multiple choice.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-swag", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


## Citation


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-what-to-pre-train-on,
    title={What to Pre-Train on? Efficient Intermediate Task Selection},
    author={Clifton Poth and Jonas Pfeiffer and Andreas Rücklé and Iryna Gurevych},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
    month = nov,
    year = "2021",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/2104.08247",
    pages = "to appear",
}
```


model name: roberta-base-pf-swag


model author: AdapterHub


tags: roberta, en, dataset:swag, arxiv:2104.08247, adapter-transformers, infinity_compatible


tags:


- roberta
- adapterhub:comsense/copa
- adapter-transformers
language:
- en


# Adapter `AdapterHub/roberta-base-pf-copa` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [comsense/copa](https://adapterhub.ml/explore/comsense/copa/) dataset and includes a prediction head for multiple choice.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-copa", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


model name: roberta-base-pf-copa


tags: roberta, en, arxiv:2104.08247, adapter-transformers, adapterhub:comsense/copa, infinity_compatible


- roberta
- adapterhub:dp/ud_ewt
- adapter-transformers
datasets:
- universal_dependencies
language:
- en


# Adapter `AdapterHub/roberta-base-pf-ud_en_ewt` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [dp/ud_ewt](https://adapterhub.ml/explore/dp/ud_ewt/) dataset and includes a prediction head for dependency parsing.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-ud_en_ewt", source="hf", set_active=True)
```


This adapter was trained using adapter-transformer's example script for dependency parsing.
See https://github.com/Adapter-Hub/adapter-transformers/tree/master/examples/dependency-parsing.


## Evaluation results


Scores achieved by dependency parsing adapters on the test set of UD English EWT after training:


| Model | UAS | LAS |
| --- | --- | --- |
| `bert-base-uncased` | 91.74 | 89.15 |
| `roberta-base` | 91.43 | 88.43 |


## Citation


<!-- Add some description here -->


model name: roberta-base-pf-ud_en_ewt


model author: AdapterHub


tags: roberta, en, dataset:universal_dependencies, adapter-transformers, adapterhub:dp/ud_ewt, infinity_compatible


tags:


- text-classification
- roberta
- adapterhub:nli/multinli
- adapter-transformers
datasets:
- multi_nli
language:
- en


# Adapter `AdapterHub/roberta-base-pf-mnli` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [nli/multinli](https://adapterhub.ml/explore/nli/multinli/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-mnli", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-mnli


task: text-classification


tags: roberta, en, dataset:multi_nli, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:nli/multinli, infinity_compatible


- text-classification
- bert
- adapterhub:nli/scitail
- adapter-transformers
datasets:
- scitail
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-scitail` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [nli/scitail](https://adapterhub.ml/explore/nli/scitail/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-scitail", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: bert-base-uncased-pf-scitail


model author: AdapterHub


tags: bert, en, dataset:scitail, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:nli/scitail, infinity_compatible


tags:


- text-classification
- roberta
- adapterhub:rc/record
- adapter-transformers
language:
- en


# Adapter `AdapterHub/roberta-base-pf-record` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [rc/record](https://adapterhub.ml/explore/rc/record/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-record", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-record


task: text-classification


tags: roberta, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:rc/record, infinity_compatible


- text-classification
- roberta
- adapter-transformers
datasets:
- yelp_polarity
language:
- en


# Adapter `AdapterHub/roberta-base-pf-yelp_polarity` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [yelp_polarity](https://huggingface.co/datasets/yelp_polarity/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-yelp_polarity", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-yelp_polarity


model author: AdapterHub


tags: roberta, en, dataset:yelp_polarity, arxiv:2104.08247, adapter-transformers, text-classification, infinity_compatible


tags:


- text-classification
- bert
- adapterhub:sentiment/imdb
- adapter-transformers
datasets:
- imdb
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-imdb` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [sentiment/imdb](https://adapterhub.ml/explore/sentiment/imdb/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-imdb", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-imdb


task: text-classification


tags: bert, en, dataset:imdb, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:sentiment/imdb, infinity_compatible


- token-classification
- bert
- adapterhub:ged/fce
- adapter-transformers
datasets:
- fce_error_detection
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-fce_error_detection` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [ged/fce](https://adapterhub.ml/explore/ged/fce/) dataset and includes a prediction head for tagging.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-fce_error_detection", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: bert-base-uncased-pf-fce_error_detection


model author: AdapterHub


task: token-classification


tags: bert, en, dataset:fce_error_detection, arxiv:2104.08247, adapter-transformers, token-classification, adapterhub:ged/fce, infinity_compatible


tags:


- token-classification
- bert
- adapterhub:ner/mit_movie_trivia
- adapter-transformers
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-mit_movie_trivia` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [ner/mit_movie_trivia](https://adapterhub.ml/explore/ner/mit_movie_trivia/) dataset and includes a prediction head for tagging.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-mit_movie_trivia", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-mit_movie_trivia


tags: bert, en, arxiv:2104.08247, adapter-transformers, token-classification, adapterhub:ner/mit_movie_trivia, infinity_compatible


- text-classification
- roberta
- adapter-transformers
datasets:
- emo
language:
- en


# Adapter `AdapterHub/roberta-base-pf-emo` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [emo](https://huggingface.co/datasets/emo/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-emo", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-emo


model author: AdapterHub


task: text-classification


tags: roberta, en, dataset:emo, arxiv:2104.08247, adapter-transformers, text-classification, infinity_compatible


tags:


- text-classification
- bert
- adapter-transformers
datasets:
- trec
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-trec` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [trec](https://huggingface.co/datasets/trec/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-trec", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-trec


tags: bert, en, dataset:trec, arxiv:2104.08247, adapter-transformers, text-classification, infinity_compatible


- text-classification
- adapter-transformers
- bert
- adapterhub:nli/sick
datasets:
- sick
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-sick` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [nli/sick](https://adapterhub.ml/explore/nli/sick/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-sick", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: bert-base-uncased-pf-sick


model author: AdapterHub


task: text-classification


tags: bert, en, dataset:sick, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:nli/sick, infinity_compatible


tags:


- question-answering
- bert
- adapter-transformers
datasets:
- duorc
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-duorc_p` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [duorc](https://huggingface.co/datasets/duorc/) dataset and includes a prediction head for question answering.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-duorc_p", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-duorc_p


task: question-answering


tags: bert, en, dataset:duorc, arxiv:2104.08247, adapter-transformers, question-answering, infinity_compatible


- token-classification
- bert
- adapterhub:chunk/conll2000
- adapter-transformers
datasets:
- conll2000
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-conll2000` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [chunk/conll2000](https://adapterhub.ml/explore/chunk/conll2000/) dataset and includes a prediction head for tagging.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-conll2000", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: bert-base-uncased-pf-conll2000


model author: AdapterHub


task: token-classification


tags: bert, en, dataset:conll2000, arxiv:2104.08247, adapter-transformers, token-classification, adapterhub:chunk/conll2000, infinity_compatible


tags:


- text-classification
- roberta
- adapter-transformers
datasets:
- emotion
language:
- en


# Adapter `AdapterHub/roberta-base-pf-emotion` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [emotion](https://huggingface.co/datasets/emotion/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-emotion", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-emotion


task: text-classification


tags: roberta, en, dataset:emotion, arxiv:2104.08247, adapter-transformers, text-classification, infinity_compatible


- text-classification
- roberta
- adapterhub:nli/qnli
- adapter-transformers
language:
- en


# Adapter `AdapterHub/roberta-base-pf-qnli` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [nli/qnli](https://adapterhub.ml/explore/nli/qnli/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-qnli", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-qnli


model author: AdapterHub


tags: roberta, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:nli/qnli, infinity_compatible


tags:


- text-classification
- bert
- adapterhub:sentiment/rotten_tomatoes
- adapter-transformers
datasets:
- rotten_tomatoes
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-rotten_tomatoes` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [sentiment/rotten_tomatoes](https://adapterhub.ml/explore/sentiment/rotten_tomatoes/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-rotten_tomatoes", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-rotten_tomatoes


task: text-classification


tags: bert, en, dataset:rotten_tomatoes, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:sentiment/rotten_tomatoes, infinity_compatible


- question-answering
- roberta
- adapterhub:qa/squad2
- adapter-transformers
datasets:
- squad_v2
language:
- en


# Adapter `AdapterHub/roberta-base-pf-squad_v2` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [qa/squad2](https://adapterhub.ml/explore/qa/squad2/) dataset and includes a prediction head for question answering.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-squad_v2", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-squad_v2


model author: AdapterHub


task: question-answering


tags: roberta, en, dataset:squad_v2, arxiv:2104.08247, adapter-transformers, question-answering, adapterhub:qa/squad2, infinity_compatible


tags:


- question-answering
- bert
- adapter-transformers
datasets:
- duorc
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-duorc_s` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [duorc](https://huggingface.co/datasets/duorc/) dataset and includes a prediction head for question answering.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-duorc_s", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-duorc_s


tags: bert, en, dataset:duorc, arxiv:2104.08247, adapter-transformers, question-answering, infinity_compatible


- question-answering
- roberta
- adapter-transformers
datasets:
- duorc
language:
- en


# Adapter `AdapterHub/roberta-base-pf-duorc_s` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [duorc](https://huggingface.co/datasets/duorc/) dataset and includes a prediction head for question answering.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-duorc_s", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-duorc_s


model author: AdapterHub


task: question-answering


tags: roberta, en, dataset:duorc, arxiv:2104.08247, adapter-transformers, question-answering, infinity_compatible


tags:


- question-answering
- roberta
- adapterhub:qa/cq
- adapter-transformers
language:
- en


# Adapter `AdapterHub/roberta-base-pf-cq` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [qa/cq](https://adapterhub.ml/explore/qa/cq/) dataset and includes a prediction head for question answering.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-cq", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-cq


tags: roberta, en, arxiv:2104.08247, adapter-transformers, question-answering, adapterhub:qa/cq, infinity_compatible


- token-classification
- roberta
- adapterhub:chunk/conll2000
- adapter-transformers
datasets:
- conll2000
language:
- en


# Adapter `AdapterHub/roberta-base-pf-conll2000` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [chunk/conll2000](https://adapterhub.ml/explore/chunk/conll2000/) dataset and includes a prediction head for tagging.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-conll2000", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-conll2000


model author: AdapterHub


task: token-classification


tags: roberta, en, dataset:conll2000, arxiv:2104.08247, adapter-transformers, token-classification, adapterhub:chunk/conll2000, infinity_compatible


tags:


- text-classification
- roberta
- adapterhub:qa/boolq
- adapter-transformers
datasets:
- boolq
language:
- en


# Adapter `AdapterHub/roberta-base-pf-boolq` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [qa/boolq](https://adapterhub.ml/explore/qa/boolq/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-boolq", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-boolq


task: text-classification


tags: roberta, en, dataset:boolq, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:qa/boolq, infinity_compatible


- question-answering
- bert
- adapterhub:qa/cq
- adapter-transformers
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-cq` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [qa/cq](https://adapterhub.ml/explore/qa/cq/) dataset and includes a prediction head for question answering.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-cq", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: bert-base-uncased-pf-cq


model author: AdapterHub


task: question-answering


tags: bert, en, arxiv:2104.08247, adapter-transformers, question-answering, adapterhub:qa/cq, infinity_compatible


tags:


- bert
- adapter-transformers
datasets:
- art
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-art` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [art](https://huggingface.co/datasets/art/) dataset and includes a prediction head for multiple choice.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-art", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-what-to-pre-train-on,
    title={What to Pre-Train on? Efficient Intermediate Task Selection},
    author={Clifton Poth and Jonas Pfeiffer and Andreas Rücklé and Iryna Gurevych},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
    month = nov,
    year = "2021",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/2104.08247",
    pages = "to appear",
}
```


model name: bert-base-uncased-pf-art


tags: bert, en, dataset:art, arxiv:2104.08247, adapter-transformers, infinity_compatible


- text-classification
- bert
- adapterhub:sts/sts-b
- adapter-transformers
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-stsb` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [sts/sts-b](https://adapterhub.ml/explore/sts/sts-b/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-stsb", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-stsb


model author: AdapterHub


task: text-classification


tags: bert, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:sts/sts-b, infinity_compatible


tags:


- text-classification
- bert
- adapter-transformers
datasets:
- emotion
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-emotion` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [emotion](https://huggingface.co/datasets/emotion/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-emotion", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


model name: bert-base-uncased-pf-emotion


tags: bert, en, dataset:emotion, arxiv:2104.08247, adapter-transformers, text-classification, infinity_compatible


- text-classification
- roberta
- adapterhub:nli/scitail
- adapter-transformers
datasets:
- scitail
language:
- en


# Adapter `AdapterHub/roberta-base-pf-scitail` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [nli/scitail](https://adapterhub.ml/explore/nli/scitail/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-scitail", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-scitail


model author: AdapterHub


task: text-classification


tags: roberta, en, dataset:scitail, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:nli/scitail, infinity_compatible


tags:


- text-classification
- bert
- adapter-transformers
datasets:
- yelp_polarity
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-yelp_polarity` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [yelp_polarity](https://huggingface.co/datasets/yelp_polarity/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-yelp_polarity", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


model name: bert-base-uncased-pf-yelp_polarity


tags: bert, en, dataset:yelp_polarity, arxiv:2104.08247, adapter-transformers, text-classification, infinity_compatible


- question-answering
- bert
- adapter-transformers
datasets:
- newsqa
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-newsqa` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [newsqa](https://huggingface.co/datasets/newsqa/) dataset and includes a prediction head for question answering.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-newsqa", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-newsqa


model author: AdapterHub


task: question-answering


tags: bert, en, dataset:newsqa, arxiv:2104.08247, adapter-transformers, question-answering, infinity_compatible


tags:


- bert
- adapter-transformers
datasets:
- social_i_qa
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-social_i_qa` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [social_i_qa](https://huggingface.co/datasets/social_i_qa/) dataset and includes a prediction head for multiple choice.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-social_i_qa", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-what-to-pre-train-on,
    title={What to Pre-Train on? Efficient Intermediate Task Selection},
    author={Clifton Poth and Jonas Pfeiffer and Andreas Rücklé and Iryna Gurevych},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
    month = nov,
    year = "2021",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/2104.08247",
    pages = "to appear",
}
```


model name: bert-base-uncased-pf-social_i_qa


tags: bert, en, dataset:social_i_qa, arxiv:2104.08247, adapter-transformers, infinity_compatible


- roberta
- adapterhub:comsense/cosmosqa
- adapter-transformers
datasets:
- cosmos_qa
language:
- en


# Adapter `AdapterHub/roberta-base-pf-cosmos_qa` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [comsense/cosmosqa](https://adapterhub.ml/explore/comsense/cosmosqa/) dataset and includes a prediction head for multiple choice.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-cosmos_qa", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-cosmos_qa


model author: AdapterHub


tags: roberta, en, dataset:cosmos_qa, arxiv:2104.08247, adapter-transformers, adapterhub:comsense/cosmosqa, infinity_compatible


tags:


- question-answering
- roberta
- adapter-transformers
datasets:
- duorc
language:
- en


# Adapter `AdapterHub/roberta-base-pf-duorc_p` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [duorc](https://huggingface.co/datasets/duorc/) dataset and includes a prediction head for question answering.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-duorc_p", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-duorc_p


task: question-answering


tags: roberta, en, dataset:duorc, arxiv:2104.08247, adapter-transformers, question-answering, infinity_compatible


- roberta
- adapterhub:comsense/csqa
- adapter-transformers
datasets:
- commonsense_qa
language:
- en


# Adapter `AdapterHub/roberta-base-pf-commonsense_qa` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [comsense/csqa](https://adapterhub.ml/explore/comsense/csqa/) dataset and includes a prediction head for multiple choice.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-commonsense_qa", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


```bibtex
@inproceedings{poth-etal-2021-what-to-pre-train-on,
    title={What to Pre-Train on? Efficient Intermediate Task Selection},
    author={Clifton Poth and Jonas Pfeiffer and Andreas Rücklé and Iryna Gurevych},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
    month = nov,
    year = "2021",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/2104.08247",
    pages = "to appear",
}
```


model name: roberta-base-pf-commonsense_qa


model author: AdapterHub


tags: roberta, en, dataset:commonsense_qa, arxiv:2104.08247, adapter-transformers, adapterhub:comsense/csqa, infinity_compatible


tags:


- question-answering
- bert
- adapterhub:qa/squad2
- adapter-transformers
datasets:
- squad_v2
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-squad_v2` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [qa/squad2](https://adapterhub.ml/explore/qa/squad2/) dataset and includes a prediction head for question answering.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-squad_v2", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-squad_v2


task: question-answering


tags: bert, en, dataset:squad_v2, arxiv:2104.08247, adapter-transformers, question-answering, adapterhub:qa/squad2, infinity_compatible


- text-classification
- bert
- adapter-transformers
datasets:
- anli
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-anli_r3` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [anli](https://huggingface.co/datasets/anli/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-anli_r3", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: bert-base-uncased-pf-anli_r3


model author: AdapterHub


task: text-classification


tags: bert, en, dataset:anli, arxiv:2104.08247, adapter-transformers, text-classification, infinity_compatible


tags:


- text-classification
- bert
- adapterhub:nli/rte
- adapter-transformers
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-rte` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [nli/rte](https://adapterhub.ml/explore/nli/rte/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-rte", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-rte


tags: bert, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:nli/rte, infinity_compatible


- token-classification
- roberta
- adapterhub:ged/fce
- adapter-transformers
datasets:
- fce_error_detection
language:
- en


# Adapter `AdapterHub/roberta-base-pf-fce_error_detection` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [ged/fce](https://adapterhub.ml/explore/ged/fce/) dataset and includes a prediction head for tagging.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-fce_error_detection", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-fce_error_detection


model author: AdapterHub


task: token-classification


tags: roberta, en, dataset:fce_error_detection, arxiv:2104.08247, adapter-transformers, token-classification, adapterhub:ged/fce, infinity_compatible


tags:


- token-classification
- bert
- adapterhub:semtag/pmb
- adapter-transformers
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-pmb_sem_tagging` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [semtag/pmb](https://adapterhub.ml/explore/semtag/pmb/) dataset and includes a prediction head for tagging.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-pmb_sem_tagging", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-pmb_sem_tagging


tags: bert, en, arxiv:2104.08247, adapter-transformers, token-classification, adapterhub:semtag/pmb, infinity_compatible


- token-classification
- roberta
- adapterhub:semtag/pmb
- adapter-transformers
language:
- en


# Adapter `AdapterHub/roberta-base-pf-pmb_sem_tagging` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [semtag/pmb](https://adapterhub.ml/explore/semtag/pmb/) dataset and includes a prediction head for tagging.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-pmb_sem_tagging", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-pmb_sem_tagging


model author: AdapterHub


task: token-classification


tags: roberta, en, arxiv:2104.08247, adapter-transformers, token-classification, adapterhub:semtag/pmb, infinity_compatible


tags:


- text-classification
- bert
- adapterhub:nli/multinli
- adapter-transformers
datasets:
- multi_nli
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-mnli` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [nli/multinli](https://adapterhub.ml/explore/nli/multinli/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-mnli", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-mnli


task: text-classification


tags: bert, en, dataset:multi_nli, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:nli/multinli, infinity_compatible


- bert
- adapterhub:comsense/cosmosqa
- adapter-transformers
datasets:
- cosmos_qa
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-cosmos_qa` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [comsense/cosmosqa](https://adapterhub.ml/explore/comsense/cosmosqa/) dataset and includes a prediction head for multiple choice.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-cosmos_qa", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


```bibtex
@inproceedings{poth-etal-2021-what-to-pre-train-on,
    title={What to Pre-Train on? Efficient Intermediate Task Selection},
    author={Clifton Poth and Jonas Pfeiffer and Andreas Rücklé and Iryna Gurevych},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
    month = nov,
    year = "2021",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/2104.08247",
    pages = "to appear",
}
```


model name: bert-base-uncased-pf-cosmos_qa


model author: AdapterHub


tags: bert, en, dataset:cosmos_qa, arxiv:2104.08247, adapter-transformers, adapterhub:comsense/cosmosqa, infinity_compatible


tags:


- token-classification
- roberta
- adapterhub:pos/ud_ewt
- adapter-transformers
datasets:
- universal_dependencies
language:
- en


# Adapter `AdapterHub/roberta-base-pf-ud_pos` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [pos/ud_ewt](https://adapterhub.ml/explore/pos/ud_ewt/) dataset and includes a prediction head for tagging.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-ud_pos", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-ud_pos


task: token-classification


tags: roberta, en, dataset:universal_dependencies, arxiv:2104.08247, adapter-transformers, token-classification, adapterhub:pos/ud_ewt, infinity_compatible


- token-classification
- roberta
- adapterhub:pos/conll2003
- adapter-transformers
- token-classification
datasets:
- conll2003
language:
- en


# Adapter `AdapterHub/roberta-base-pf-conll2003_pos` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [pos/conll2003](https://adapterhub.ml/explore/pos/conll2003/) dataset and includes a prediction head for tagging.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-conll2003_pos", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: roberta-base-pf-conll2003_pos


model author: AdapterHub


tags: roberta, en, dataset:conll2003, arxiv:2104.08247, adapter-transformers, token-classification, adapterhub:pos/conll2003, infinity_compatible


tags:


- roberta
- adapterhub:comsense/winogrande
- adapter-transformers
datasets:
- winogrande
language:
- en


# Adapter `AdapterHub/roberta-base-pf-winogrande` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [comsense/winogrande](https://adapterhub.ml/explore/comsense/winogrande/) dataset and includes a prediction head for multiple choice.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-winogrande", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-what-to-pre-train-on,
    title={What to Pre-Train on? Efficient Intermediate Task Selection},
    author={Clifton Poth and Jonas Pfeiffer and Andreas Rücklé and Iryna Gurevych},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
    month = nov,
    year = "2021",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/2104.08247",
    pages = "to appear",
}
```


model name: roberta-base-pf-winogrande


tags: roberta, en, dataset:winogrande, arxiv:2104.08247, adapter-transformers, adapterhub:comsense/winogrande, infinity_compatible


- question-answering
- bert
- adapter-transformers
datasets:
- com_qa
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-comqa` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [com_qa](https://huggingface.co/datasets/com_qa/) dataset and includes a prediction head for question answering.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-comqa", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-comqa


model author: AdapterHub


task: question-answering


tags: bert, en, dataset:com_qa, arxiv:2104.08247, adapter-transformers, question-answering, infinity_compatible


tags:


- text-classification
- bert
- adapterhub:rc/record
- adapter-transformers
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-record` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [rc/record](https://adapterhub.ml/explore/rc/record/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-record", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


model name: bert-base-uncased-pf-record


task: text-classification


tags: bert, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:rc/record, infinity_compatible


- adapterhub:qa/narrativeqa
- adapter-transformers
- bart
datasets:
- narrativeqa


# Adapter `hSterz/narrativeqa` for facebook/bart-base


An [adapter](https://adapterhub.ml) for the `facebook/bart-base` model that was trained on the [qa/narrativeqa](https://adapterhub.ml/explore/qa/narrativeqa/) dataset.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("facebook/bart-base")
adapter_name = model.load_adapter("hSterz/narrativeqa", source="hf", set_active=True)
```


## Architecture & Training


<!-- Add some description here -->


## Citation


model name: narrativeqa


model author: AdapterHub


tags: bart, dataset:narrativeqa, adapter-transformers, adapterhub:qa/narrativeqa


tags:


- roberta
- adapter-transformers
datasets:
- art
language:
- en


# Adapter `AdapterHub/roberta-base-pf-art` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [art](https://huggingface.co/datasets/art/) dataset and includes a prediction head for multiple choice.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-art", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-what-to-pre-train-on,
    title={What to Pre-Train on? Efficient Intermediate Task Selection},
    author={Clifton Poth and Jonas Pfeiffer and Andreas Rücklé and Iryna Gurevych},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
    month = nov,
    year = "2021",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/2104.08247",
    pages = "to appear",
}
```


model name: roberta-base-pf-art


tags: roberta, en, dataset:art, arxiv:2104.08247, adapter-transformers, infinity_compatible


- text-classification
- bert
- adapterhub:nli/qnli
- adapter-transformers
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-qnli` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [nli/qnli](https://adapterhub.ml/explore/nli/qnli/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-qnli", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: bert-base-uncased-pf-qnli


model author: AdapterHub


task: text-classification


tags: bert, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:nli/qnli, infinity_compatible


tags:


- question-answering
- roberta
- adapter-transformers
datasets:
- com_qa
language:
- en


# Adapter `AdapterHub/roberta-base-pf-comqa` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [com_qa](https://huggingface.co/datasets/com_qa/) dataset and includes a prediction head for question answering.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-comqa", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


model name: roberta-base-pf-comqa


task: question-answering


tags: roberta, en, dataset:com_qa, arxiv:2104.08247, adapter-transformers, question-answering, infinity_compatible


- bert
- adapterhub:comsense/copa
- adapter-transformers
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-copa` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [comsense/copa](https://adapterhub.ml/explore/comsense/copa/) dataset and includes a prediction head for multiple choice.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-copa", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


```bibtex
@inproceedings{poth-etal-2021-what-to-pre-train-on,
    title={What to Pre-Train on? Efficient Intermediate Task Selection},
    author={Clifton Poth and Jonas Pfeiffer and Andreas Rücklé and Iryna Gurevych},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
    month = nov,
    year = "2021",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/2104.08247",
    pages = "to appear",
}
```


model name: bert-base-uncased-pf-copa


model author: AdapterHub


tags: bert, en, arxiv:2104.08247, adapter-transformers, adapterhub:comsense/copa, infinity_compatible


tags:


- text-classification
- adapterhub:rc/multirc
- roberta
- adapter-transformers
language:
- en


# Adapter `AdapterHub/roberta-base-pf-multirc` for roberta-base


An [adapter](https://adapterhub.ml) for the `roberta-base` model that was trained on the [rc/multirc](https://adapterhub.ml/explore/rc/multirc/) dataset and includes a prediction head for classification.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("roberta-base")
adapter_name = model.load_adapter("AdapterHub/roberta-base-pf-multirc", source="hf")
model.active_adapters = adapter_name
```


The training code for this adapter is available at https://github.com/adapter-hub/efficient-task-transfer.
In particular, training configurations for all tasks can be found [here](https://github.com/adapter-hub/efficient-task-transfer/tree/master/run_configs).


## Evaluation results


Refer to [the paper](https://arxiv.org/pdf/2104.08247) for more information on results.


If you use this adapter, please cite our paper ["What to Pre-Train on? Efficient Intermediate Task Selection"](https://arxiv.org/pdf/2104.08247):


```bibtex
@inproceedings{poth-etal-2021-pre,
    title = "{W}hat to Pre-Train on? {E}fficient Intermediate Task Selection",
    author = {Poth, Clifton  and
      Pfeiffer, Jonas  and
      R{"u}ckl{'e}, Andreas  and
      Gurevych, Iryna},
    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
    month = nov,
    year = "2021",
    address = "Online and Punta Cana, Dominican Republic",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2021.emnlp-main.827",
    pages = "10585--10605",
}
```


model name: roberta-base-pf-multirc


task: text-classification


tags: roberta, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:rc/multirc, infinity_compatible


- text-classification
- adapterhub:rc/multirc
- bert
- adapter-transformers
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-multirc` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [rc/multirc](https://adapterhub.ml/explore/rc/multirc/) dataset and includes a prediction head for classification.


This adapter was created for usage with the **[adapter-transformers](https://github.com/Adapter-Hub/adapter-transformers)** library.


```
pip install -U adapter-transformers
```


*Note: adapter-transformers is a fork of transformers that acts as a drop-in replacement with adapter support. [More](https://docs.adapterhub.ml/installation.html)*


Now, the adapter can be loaded and activated like this:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-multirc", source="hf")
model.active_adapters = adapter_name
```


## Architecture & Training


## Citation


model name: bert-base-uncased-pf-multirc


model author: AdapterHub


tags: bert, en, arxiv:2104.08247, adapter-transformers, text-classification, adapterhub:rc/multirc, infinity_compatible


tags:


- bert
- adapter-transformers
datasets:
- swag
language:
- en


# Adapter `AdapterHub/bert-base-uncased-pf-swag` for bert-base-uncased


An [adapter](https://adapterhub.ml) for the `bert-base-uncased` model that was trained on the [swag](https://huggingface.co/datasets/swag/) dataset and includes a prediction head for multiple choice.


## Usage


First, install `adapter-transformers`:


```python
from transformers import AutoModelWithHeads

model = AutoModelWithHeads.from_pretrained("bert-base-uncased")
adapter_name = model.load_adapter("AdapterHub/bert-base-uncased-pf-swag", source="hf")
model.active_adapters = adapter_name
```