diff --git a/README.md b/README.md index 9d82251138..9f161b8364 100644 --- a/README.md +++ b/README.md @@ -172,8 +172,9 @@ for Open-Domain Question Answering](https://arxiv.org/abs/2004.04906) by Vladimi Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 23. **[Pegasus](https://github.com/google-research/pegasus)** (from Google) released with the paper [PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization](https://arxiv.org/abs/1912.08777)> by Jingqing Zhang, Yao Zhao, Mohammad Saleh and Peter J. Liu. 24. **[MBart](https://github.com/pytorch/fairseq/tree/master/examples/mbart)** (from Facebook) released with the paper [Multilingual Denoising Pre-training for Neural Machine Translation](https://arxiv.org/abs/2001.08210) by Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, Luke Zettlemoyer. -25. **[Other community models](https://huggingface.co/models)**, contributed by the [community](https://huggingface.co/users). -26. Want to contribute a new model? We have added a **detailed guide and templates** to guide you in the process of adding a new model. You can find them in the [`templates`](./templates) folder of the repository. Be sure to check the [contributing guidelines](./CONTRIBUTING.md) and contact the maintainers or open an issue to collect feedbacks before starting your PR. +25. **[LXMERT](https://github.com/airsplay/lxmert)** (from UNC Chapel Hill) released with the paper [LXMERT: Learning Cross-Modality Encoder Representations from Transformers for Open-Domain Question Answering](https://arxiv.org/abs/1908.07490) by Hao Tan and Mohit Bansal. +26. **[Other community models](https://huggingface.co/models)**, contributed by the [community](https://huggingface.co/users). +27. Want to contribute a new model? We have added a **detailed guide and templates** to guide you in the process of adding a new model. You can find them in the [`templates`](./templates) folder of the repository. Be sure to check the [contributing guidelines](./CONTRIBUTING.md) and contact the maintainers or open an issue to collect feedbacks before starting your PR. These implementations have been tested on several datasets (see the example scripts) and should match the performances of the original implementations (e.g. ~93 F1 on SQuAD for BERT Whole-Word-Masking, ~88 F1 on RocStories for OpenAI GPT, ~18.3 perplexity on WikiText 103 for Transformer-XL, ~0.916 Pearson R coefficient on STS-B for XLNet). You can find more details on the performances in the Examples section of the [documentation](https://huggingface.co/transformers/examples.html). diff --git a/docs/source/index.rst b/docs/source/index.rst index 33b549d17f..a2acc39466 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -128,7 +128,10 @@ conversion utilities for the following models: `_ by Jingqing Zhang, Yao Zhao, Mohammad Saleh and Peter J. Liu. 24. `MBart `_ (from Facebook) released with the paper `Multilingual Denoising Pre-training for Neural Machine Translation `_ by Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, Luke Zettlemoyer. -25. `Other community models `_, contributed by the `community +25. `LXMERT `_ (from UNC Chapel Hill) released with the paper `LXMERT: Learning + Cross-Modality Encoder Representations from Transformers for Open-Domain Question + Answering `_ by Hao Tan and Mohit Bansal. +26. `Other community models `_, contributed by the `community `_. .. toctree:: @@ -213,6 +216,7 @@ conversion utilities for the following models: model_doc/dpr model_doc/pegasus model_doc/mbart + model_doc/lxmert internal/modeling_utils internal/tokenization_utils internal/pipelines_utils diff --git a/docs/source/model_doc/lxmert.rst b/docs/source/model_doc/lxmert.rst new file mode 100644 index 0000000000..e9c7ad339f --- /dev/null +++ b/docs/source/model_doc/lxmert.rst @@ -0,0 +1,109 @@ +LXMERT +---------------------------------------------------- + +Overview +~~~~~~~~~~~~~~~~~~~~~ + +The LXMERT model was proposed in `LXMERT: Learning Cross-Modality Encoder Representations from Transformers `__ +by Hao Tan & Mohit Bansal. It is a series of bidirectional transformer encoders (one for the vision modality, one for the language modality, and then one to fuse both modalities) +pre-trained using a combination of masked language modeling, visual-language text alignment, ROI-feature regression, masked visual-attribute modeling, masked visual-object modeling, and visual-question answering objectives. +The pretraining consists of multiple multi-modal datasets: MSCOCO, Visual-Genome + Visual-Genome Question Answering, VQA 2.0, and GQA. + +The abstract from the paper is the following: + +*Vision-and-language reasoning requires an understanding of visual concepts, language semantics, and, most importantly, the alignment and relationships between these two +modalities. We thus propose the LXMERT +(Learning Cross-Modality Encoder Representations from Transformers) framework to learn +these vision-and-language connections. In +LXMERT, we build a large-scale Transformer +model that consists of three encoders: an object relationship encoder, a language encoder, +and a cross-modality encoder. Next, to endow our model with the capability of connecting vision and language semantics, we +pre-train the model with large amounts of +image-and-sentence pairs, via five diverse representative pre-training tasks: masked language modeling, masked object prediction +(feature regression and label classification), +cross-modality matching, and image question answering. These tasks help in learning both intra-modality and cross-modality relationships. After fine-tuning from our pretrained parameters, our model achieves the +state-of-the-art results on two visual question answering datasets (i.e., VQA and GQA). +We also show the generalizability of our pretrained cross-modality model by adapting it to +a challenging visual-reasoning task, NLVR +, +and improve the previous best result by 22% +absolute (54% to 76%). Lastly, we demonstrate detailed ablation studies to prove that +both our novel model components and pretraining strategies significantly contribute to +our strong results; and also present several +attention visualizations for the different encoders* + +Tips: + +- Bounding boxes are not necessary to be used in the visual feature embeddings, any kind of visual-spacial features will work. +- Both the language hidden states and the visual hidden states that LXMERT outputs are passed through the cross-modality layer, so they + contain information from both modalities. To access a modality that only attends to itself, select the vision/language hidden states from the first input in the tuple. +- The bi-directional cross-modality encoder attention only returns attention values when the language modality is used as the input and the vision modality is used as the context vector. Further, + while the cross-modality encoder contains self-attention for each respective modality and cross-attention, only the cross attention is returned and both self attention outputs are disregarded. + +The code can be found `here `__ + + +LxmertConfig +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: transformers.LxmertConfig + :members: + + +LxmertTokenizer +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: transformers.LxmertTokenizer + :members: build_inputs_with_special_tokens, get_special_tokens_mask, + create_token_type_ids_from_sequences, save_vocabulary + + +Lxmert specific outputs +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: transformers.modeling_lxmert.LxmertModelOutput + :members: + +.. autoclass:: transformers.modeling_lxmert.LxmertForPreTrainingOutput + :members: + +.. autoclass:: transformers.modeling_lxmert.LxmertForQuestionAnsweringOutput + :members: + +.. autoclass:: transformers.modeling_tf_lxmert.TFLxmertModelOutput + :members: + +.. autoclass:: transformers.modeling_tf_lxmert.TFLxmertForPreTrainingOutput + :members: + + +LxmertModel +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: transformers.LxmertModel + :members: + +LxmertForPreTraining +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: transformers.LxmertForPreTraining + :members: + +LxmertForQuestionAnswering +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: transformers.LxmertForQuestionAnswering + :members: + + +TFLxmertModel +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: transformers.TFLxmertModel + :members: + +TFLxmertForPreTraining +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. autoclass:: transformers.TFLxmertForPreTraining + :members: diff --git a/docs/source/pretrained_models.rst b/docs/source/pretrained_models.rst index 44a6b721fa..5acdb9f761 100644 --- a/docs/source/pretrained_models.rst +++ b/docs/source/pretrained_models.rst @@ -363,4 +363,8 @@ For a list that includes community-uploaded models, refer to `https://huggingfac | +------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | | ``facebook/mbart-large-en-ro`` | | 24-layer, 1024-hidden, 16-heads, 610M parameters | | | | | mbart-large-cc25 model finetuned on WMT english romanian translation. | -+-------------------+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ \ No newline at end of file ++-------------------+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ +| Lxmert | ``lxmert-base-uncased`` | | 9-language layers, 9-relationship layers, and 12-cross-modality layers | +| | | | 768-hidden, 12-heads (for each layer) ~ 228M parameters | +| | | | Starting from lxmert-base checkpoint, trained on over 9 million image-text couplets from COCO, VisualGenome, GQA, VQA | ++-------------------+------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ diff --git a/model_cards/uncnlp/lxmert-base-uncased/LICENSE b/model_cards/uncnlp/lxmert-base-uncased/LICENSE new file mode 100644 index 0000000000..52df82d356 --- /dev/null +++ b/model_cards/uncnlp/lxmert-base-uncased/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 Hao Tan + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/model_cards/uncnlp/lxmert-base-uncased/README.md b/model_cards/uncnlp/lxmert-base-uncased/README.md new file mode 100644 index 0000000000..1cb7d36f5b --- /dev/null +++ b/model_cards/uncnlp/lxmert-base-uncased/README.md @@ -0,0 +1,34 @@ +# LXMERT + +## Model Description + +[LXMERT](https://arxiv.org/abs/1908.07490) is a pre-trained multimodal transformer. The model takes an image and a sentence as input and compute cross-modal representions. The model is converted from [LXMERT github](https://github.com/airsplay/lxmert) by [Antonio Mendoza](https://avmendoza.info/) and is authored by [Hao Tan](https://www.cs.unc.edu/~airsplay/). + +![](./lxmert_model-1.jpg?raw=True) + +## Usage + + +## Training Data and Prodcedure +The model is jointly trained on multiple vision-and-language datasets. +We included two image captioning datsets (i.e., [MS COCO](http://cocodataset.org/#home), [Visual Genome](https://visualgenome.org/)) and three image-question answering datasets (i.e., [VQA](https://visualqa.org/), [GQA](https://cs.stanford.edu/people/dorarad/gqa/), [VG QA](https://github.com/yukezhu/visual7w-toolkit)). The model is pre-trained on the above datasets for 20 epochs (roughly 670K iterations with batch size 256), which takes around 8 days on 4 Titan V cards. The details of training could be found in the [LXMERT paper](https://arxiv.org/pdf/1908.07490.pdf). + +## Eval Results +| Split | [VQA](https://visualqa.org/) | [GQA](https://cs.stanford.edu/people/dorarad/gqa/) | [NLVR2](http://lil.nlp.cornell.edu/nlvr/) | +|----------- |:----: |:---: |:------:| +| Local Validation | 69.90% | 59.80% | 74.95% | +| Test-Dev | 72.42% | 60.00% | 74.45% (Test-P) | +| Test-Standard | 72.54% | 60.33% | 76.18% (Test-U) | + + +## Reference +```bibtex +@inproceedings{tan2019lxmert, + title={LXMERT: Learning Cross-Modality Encoder Representations from Transformers}, + author={Tan, Hao and Bansal, Mohit}, + booktitle={Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing}, + year={2019} +} +``` + + diff --git a/model_cards/uncnlp/lxmert-base-uncased/lxmert_model-1.jpg b/model_cards/uncnlp/lxmert-base-uncased/lxmert_model-1.jpg new file mode 100644 index 0000000000..20e3b7cce3 Binary files /dev/null and b/model_cards/uncnlp/lxmert-base-uncased/lxmert_model-1.jpg differ diff --git a/src/transformers/__init__.py b/src/transformers/__init__.py index 48e812fb98..624246b338 100755 --- a/src/transformers/__init__.py +++ b/src/transformers/__init__.py @@ -31,6 +31,7 @@ from .configuration_encoder_decoder import EncoderDecoderConfig from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig from .configuration_gpt2 import GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2Config from .configuration_longformer import LONGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, LongformerConfig +from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig from .configuration_marian import MarianConfig from .configuration_mbart import MBartConfig from .configuration_mmbt import MMBTConfig @@ -156,6 +157,7 @@ from .tokenization_electra import ElectraTokenizer, ElectraTokenizerFast from .tokenization_flaubert import FlaubertTokenizer from .tokenization_gpt2 import GPT2Tokenizer, GPT2TokenizerFast from .tokenization_longformer import LongformerTokenizer, LongformerTokenizerFast +from .tokenization_lxmert import LxmertTokenizer, LxmertTokenizerFast from .tokenization_mbart import MBartTokenizer from .tokenization_mobilebert import MobileBertTokenizer, MobileBertTokenizerFast from .tokenization_openai import OpenAIGPTTokenizer, OpenAIGPTTokenizerFast @@ -343,6 +345,15 @@ if is_torch_available(): LongformerModel, LongformerSelfAttention, ) + from .modeling_lxmert import ( + LxmertEncoder, + LxmertForPreTraining, + LxmertForQuestionAnswering, + LxmertModel, + LxmertPreTrainedModel, + LxmertVisualFeatureEncoder, + LxmertXLayer, + ) from .modeling_marian import MarianMTModel from .modeling_mbart import MBartForConditionalGeneration from .modeling_mmbt import MMBTForClassification, MMBTModel, ModalEmbeddings @@ -573,6 +584,14 @@ if is_tf_available(): TFLongformerModel, TFLongformerSelfAttention, ) + from .modeling_tf_lxmert import ( + TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST, + TFLxmertForPreTraining, + TFLxmertMainLayer, + TFLxmertModel, + TFLxmertPreTrainedModel, + TFLxmertVisualFeatureEncoder, + ) from .modeling_tf_mobilebert import ( TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, TFMobileBertForMaskedLM, diff --git a/src/transformers/commands/convert.py b/src/transformers/commands/convert.py index 8c3f952f4a..f9e7822409 100644 --- a/src/transformers/commands/convert.py +++ b/src/transformers/commands/convert.py @@ -155,5 +155,13 @@ class ConvertCommand(BaseTransformersCLICommand): ) convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint, self._pytorch_dump_output) + elif self._model_type == "lxmert": + from transformers.convert_lxmert_original_pytorch_checkpoint_to_pytorch import ( + convert_lxmert_checkpoint_to_pytorch, + ) + + convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint, self._pytorch_dump_output) else: - raise ValueError("--model_type should be selected in the list [bert, gpt, gpt2, transfo_xl, xlnet, xlm]") + raise ValueError( + "--model_type should be selected in the list [bert, gpt, gpt2, transfo_xl, xlnet, xlm, lxmert]" + ) diff --git a/src/transformers/configuration_auto.py b/src/transformers/configuration_auto.py index 737cd811aa..6dc1e5dd0d 100644 --- a/src/transformers/configuration_auto.py +++ b/src/transformers/configuration_auto.py @@ -28,6 +28,7 @@ from .configuration_encoder_decoder import EncoderDecoderConfig from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig from .configuration_gpt2 import GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2Config from .configuration_longformer import LONGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, LongformerConfig +from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig from .configuration_marian import MarianConfig from .configuration_mbart import MBART_PRETRAINED_CONFIG_ARCHIVE_MAP, MBartConfig from .configuration_mobilebert import MobileBertConfig @@ -66,6 +67,7 @@ ALL_PRETRAINED_CONFIG_ARCHIVE_MAP = dict( ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, LONGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, RETRIBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, + LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ] for key, value, in pretrained_map.items() ) @@ -166,6 +168,10 @@ CONFIG_MAPPING = OrderedDict( "encoder-decoder", EncoderDecoderConfig, ), + ( + "lxmert", + LxmertConfig, + ), ] ) diff --git a/src/transformers/configuration_lxmert.py b/src/transformers/configuration_lxmert.py new file mode 100644 index 0000000000..7e5c0a168a --- /dev/null +++ b/src/transformers/configuration_lxmert.py @@ -0,0 +1,179 @@ +# coding=utf-8 +# Copyright 2018, Hao Tan, Mohit Bansal +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" LXMERT model configuration """ + + +import logging + +from .configuration_utils import PretrainedConfig + + +logger = logging.getLogger(__name__) + +LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP = { + "unc-nlp/lxmert-base-uncased": "", +} + + +class LxmertConfig(PretrainedConfig): + r""" + This is the configuration class to store the configuration of a :class:`~transformers.BertModel`. + It is used to instantiate an Lxmert model according to the specified arguments, defining the model + architecture. + + + Args: + vocab_size (:obj:`int`, optional, defaults to 30522): + Vocabulary size of the BERT model. Defines the different tokens that + can be represented by the `inputs_ids` passed to the forward method of :class:`~transformers.BertModel`. + hidden_size (:obj:`int`, optional, defaults to 768): + Dimensionality of the encoder layers and the pooler layer. + r_layers (:obj:`int`, optional, defaults to 5): + Number of hidden layers in the Transformer visual encoder. + l_layers (:obj:`int`, optional, defaults to 9): + Number of hidden layers in the Transformer language encoder. + x_layers (:obj:`int`, optional, defaults to 5): + Number of hidden layers in the Transformer cross modality encoder. + num_attention_heads (:obj:`int`, optional, defaults to 5): + Number of attention heads for each attention layer in the Transformer encoder. + intermediate_size (:obj:`int`, optional, defaults to 3072): + Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder. + hidden_act (:obj:`str` or :obj:`function`, optional, defaults to "gelu"): + The non-linear activation function (function or string) in the encoder and pooler. + If string, "gelu", "relu", "swish" and "gelu_new" are supported. + hidden_dropout_prob (:obj:`float`, optional, defaults to 0.1): + The dropout probabilitiy for all fully connected layers in the embeddings, encoder, and pooler. + attention_probs_dropout_prob (:obj:`float`, optional, defaults to 0.1): + The dropout ratio for the attention probabilities. + max_position_embeddings (:obj:`int`, optional, defaults to 512): + The maximum sequence length that this model might ever be used with. + Typically set this to something large just in case (e.g., 512 or 1024 or 2048). + type_vocab_size (:obj:`int`, optional, defaults to 2): + The vocabulary size of the `token_type_ids` passed into :class:`~transformers.BertModel`. + initializer_range (:obj:`float`, optional, defaults to 0.02): + The standard deviation of the truncated_normal_initializer for initializing all weight matrices. + layer_norm_eps (:obj:`float`, optional, defaults to 1e-12): + The epsilon used by the layer normalization layers. + visual_feat_dim (:obj:`int`, optional, defaults to 2048): + This represents the last dimension of the pooled-object features used as input for the model, + representing the size of each object feature itself. + visual_pos_dim (:obj:`int`, optional, defaults to 4): + This represents the number of spacial features that are mixed into the visual features. + The default is set to 4 because most commonly this will represent the location of a bounding box. + i.e. (x, y, width, height) + visual_loss_normalizer (:obj:`float`, optional, defaults to 1/15): + This represents the scaling factor in which each visual loss is multiplied by if during pretraining, + one decided to train with multiple vision-based loss objectives. + num_qa_labels (:obj:`int`, optional, defaults to 9500): + This represents the total number of different question answering (QA) labels there are. If using more than one dataset with QA, + the user will need to account for the total number of labels that all of the datasets have in total. + num_object_labels (:obj:`int`, optional, defaults to 1600): + This represents the total number of semantically unique objects that lxmert will be able to classify a pooled-object feature + as belonging too. + num_attr_labels (:obj:`int`, optional, defaults to 400): + This represents the total number of semantically unique attributes that lxmert will be able to classify a pooled-object feature + as possessing. + task_matched (:obj:`bool`, optional, defaults to True): + This task is used for sentence-image matching. If the sentence correctly describes the image the label will be 1. + If the sentence does not correctly describe the image, the label will be 0. + task_mask_lm (:obj:`bool`, optional, defaults to True): + This task is the defacto masked langauge modeling used in pretraining models such as BERT. + task_obj_predict (:obj:`bool`, optional, defaults to True): + This task is set to true if the user would like to perform one of the following loss objectives: + object predicition, atrribute predicition, feature regression + task_qa (:obj:`bool`, optional, defaults to True): + This task specifies whether or not Lxmert will calculate the question-asnwering loss objective + visual_obj_loss (:obj:`bool`, optional, defaults to True): + This task specifies whether or not Lxmert will calculate the object-prediction loss objective + visual_attr_loss (:obj:`bool`, optional, defaults to True): + This task specifies whether or not Lxmert will calculate the attribute-prediction loss objective + visual_feat_loss (:obj:`bool`, optional, defaults to True): + This task specifies whether or not Lxmert will calculate the feature-regression loss objective + output_attentions (:obj:`bool`, optional, defaults to False): + if True, the vision, langauge, and cross-modality layers will be returned + output_hidden_states (:obj:`bool`, optional, defaults to False): + if True, final cross-modality hidden states for language and vision features will be returned + + """ + + model_type = "lxmert" + + def __init__( + self, + vocab_size=30522, + hidden_size=768, + num_attention_heads=12, + num_labels=2, + num_qa_labels=9500, + num_object_labels=1600, + num_attr_labels=400, + intermediate_size=3072, + hidden_act="gelu", + hidden_dropout_prob=0.1, + attention_probs_dropout_prob=0.1, + max_position_embeddings=512, + type_vocab_size=2, + initializer_range=0.02, + layer_norm_eps=1e-12, + pad_token_id=0, + l_layers=9, + x_layers=5, + r_layers=5, + visual_feat_dim=2048, + visual_pos_dim=4, + visual_loss_normalizer=6.67, + task_matched=True, + task_mask_lm=True, + task_obj_predict=True, + task_qa=True, + visual_obj_loss=True, + visual_attr_loss=True, + visual_feat_loss=True, + output_attentions=False, + output_hidden_states=False, + **kwargs, + ): + super().__init__(**kwargs) + self.vocab_size = vocab_size + self.hidden_size = hidden_size + self.num_attention_heads = num_attention_heads + self.num_labels = num_labels + self.hidden_act = hidden_act + self.intermediate_size = intermediate_size + self.hidden_dropout_prob = hidden_dropout_prob + self.attention_probs_dropout_prob = attention_probs_dropout_prob + self.max_position_embeddings = max_position_embeddings + self.type_vocab_size = type_vocab_size + self.initializer_range = initializer_range + self.layer_norm_eps = layer_norm_eps + self.num_qa_labels = num_qa_labels + self.num_object_labels = num_object_labels + self.num_attr_labels = num_attr_labels + self.l_layers = l_layers + self.x_layers = x_layers + self.r_layers = r_layers + self.visual_feat_dim = visual_feat_dim + self.visual_pos_dim = visual_pos_dim + self.visual_loss_normalizer = visual_loss_normalizer + self.task_matched = task_matched + self.task_mask_lm = task_mask_lm + self.task_obj_predict = task_obj_predict + self.task_qa = task_qa + self.visual_obj_loss = visual_obj_loss + self.visual_attr_loss = visual_attr_loss + self.visual_feat_loss = visual_feat_loss + self.output_hidden_states = output_hidden_states + self.output_attentions = self.output_attentions + self.num_hidden_layers = {"vision": r_layers, "cross_encoder": x_layers, "language": l_layers} diff --git a/src/transformers/convert_lxmert_original_tf_checkpoint_to_pytorch.py b/src/transformers/convert_lxmert_original_tf_checkpoint_to_pytorch.py new file mode 100755 index 0000000000..e4125ed566 --- /dev/null +++ b/src/transformers/convert_lxmert_original_tf_checkpoint_to_pytorch.py @@ -0,0 +1,61 @@ +# coding=utf-8 +# Copyright 2018 The HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Convert LXMERT checkpoint.""" + + +import argparse +import logging + +import torch + +from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert + + +logging.basicConfig(level=logging.INFO) + + +def convert_tf_checkpoint_to_pytorch(tf_checkpoint_path, config_file, pytorch_dump_path): + # Initialise PyTorch model + config = LxmertConfig.from_json_file(config_file) + print("Building PyTorch model from configuration: {}".format(str(config))) + model = LxmertForPreTraining(config) + + # Load weights from tf checkpoint + load_tf_weights_in_lxmert(model, config, tf_checkpoint_path) + + # Save pytorch-model + print("Save PyTorch model to {}".format(pytorch_dump_path)) + torch.save(model.state_dict(), pytorch_dump_path) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + # Required parameters + parser.add_argument( + "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path." + ) + parser.add_argument( + "--config_file", + default=None, + type=str, + required=True, + help="The config json file corresponding to the pre-trained model. \n" + "This specifies the model architecture.", + ) + parser.add_argument( + "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model." + ) + args = parser.parse_args() + convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path) diff --git a/src/transformers/convert_pytorch_checkpoint_to_tf2.py b/src/transformers/convert_pytorch_checkpoint_to_tf2.py index 51b57d005f..cb0ef84848 100755 --- a/src/transformers/convert_pytorch_checkpoint_to_tf2.py +++ b/src/transformers/convert_pytorch_checkpoint_to_tf2.py @@ -27,6 +27,7 @@ from transformers import ( ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, + LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, @@ -43,6 +44,7 @@ from transformers import ( ElectraConfig, FlaubertConfig, GPT2Config, + LxmertConfig, OpenAIGPTConfig, RobertaConfig, T5Config, @@ -57,6 +59,8 @@ from transformers import ( TFElectraForPreTraining, TFFlaubertWithLMHeadModel, TFGPT2LMHeadModel, + TFLxmertForPreTraining, + TFLxmertVisualFeatureEncoder, TFOpenAIGPTLMHeadModel, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, @@ -94,6 +98,8 @@ if is_torch_available(): ElectraForPreTraining, FlaubertWithLMHeadModel, GPT2LMHeadModel, + LxmertForPreTraining, + LxmertVisualFeatureEncoder, OpenAIGPTLMHeadModel, RobertaForMaskedLM, RobertaForSequenceClassification, @@ -204,6 +210,18 @@ MODEL_CLASSES = { DistilBertForQuestionAnswering, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), + "lxmert": ( + LxmertConfig, + TFLxmertForPreTraining, + LxmertForPreTraining, + LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, + ), + "lxmert-visual-feature-encoder": ( + LxmertConfig, + TFLxmertVisualFeatureEncoder, + LxmertVisualFeatureEncoder, + LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, + ), "ctrl": ( CTRLConfig, TFCTRLLMHeadModel, diff --git a/src/transformers/modeling_auto.py b/src/transformers/modeling_auto.py index 390c303a96..7f85ce16dd 100644 --- a/src/transformers/modeling_auto.py +++ b/src/transformers/modeling_auto.py @@ -31,6 +31,7 @@ from .configuration_auto import ( FlaubertConfig, GPT2Config, LongformerConfig, + LxmertConfig, MBartConfig, MobileBertConfig, OpenAIGPTConfig, @@ -116,6 +117,7 @@ from .modeling_longformer import ( LongformerForTokenClassification, LongformerModel, ) +from .modeling_lxmert import LxmertForPreTraining, LxmertModel from .modeling_marian import MarianMTModel from .modeling_mbart import MBartForConditionalGeneration from .modeling_mobilebert import ( @@ -200,6 +202,7 @@ MODEL_MAPPING = OrderedDict( (CTRLConfig, CTRLModel), (ElectraConfig, ElectraModel), (ReformerConfig, ReformerModel), + (LxmertConfig, LxmertModel), ] ) @@ -224,6 +227,7 @@ MODEL_FOR_PRETRAINING_MAPPING = OrderedDict( (XLMConfig, XLMWithLMHeadModel), (CTRLConfig, CTRLLMHeadModel), (ElectraConfig, ElectraForPreTraining), + (LxmertConfig, LxmertForPreTraining), ] ) diff --git a/src/transformers/modeling_lxmert.py b/src/transformers/modeling_lxmert.py new file mode 100644 index 0000000000..68c08f7f09 --- /dev/null +++ b/src/transformers/modeling_lxmert.py @@ -0,0 +1,1426 @@ +# coding=utf-8 +# Copyright 2018 Hao Tan, Mohit Bansal, and the HuggingFace team +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" PyTorch LXMERT model. """ + + +import logging +import math +import os +from dataclasses import dataclass +from typing import Optional, Tuple + +import torch +from torch import nn +from torch.nn import CrossEntropyLoss, SmoothL1Loss + +from .activations import gelu, swish +from .configuration_lxmert import LxmertConfig +from .file_utils import ( + ModelOutput, + add_code_sample_docstrings, + add_start_docstrings, + add_start_docstrings_to_callable, + replace_return_docstrings, +) +from .modeling_utils import PreTrainedModel + + +logger = logging.getLogger(__name__) + +_CONFIG_FOR_DOC = "LxmertConfig" +_TOKENIZER_FOR_DOC = "LxmertTokenizer" + +LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ + "unc-nlp/lxmert-base-uncased", +] + + +class GeLU(nn.Module): + def __init__(self): + super().__init__() + + def forward(self, x): + return gelu(x) + + +@dataclass +class LxmertModelOutput(ModelOutput): + """ + Lxmert's outputs that contain the last hidden states, pooled outputs, and attention probabilites for + the language, visual, and, cross-modality encoders. + (note: the visual encoder in Lxmert is referred to as the "relation-ship" encoder") + + + Args: + language_output (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`): + Sequence of hidden-states at the output of the last layer of the language encoder. + vision_output (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`): + Sequence of hidden-states at the output of the last layer of the visual encoder. + pooled_output (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, hidden_size)`): + Last layer hidden-state of the first token of the sequence (classification, CLS, token) + further processed by a Linear layer and a Tanh activation function. The Linear + language_hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`torch.FloatTensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + vision_hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`torch.FloatTensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + language_attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + vision_attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + cross_encoder_attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + """ + + language_output: Optional[torch.FloatTensor] = None + vision_output: Optional[torch.FloatTensor] = None + pooled_output: Optional[torch.FloatTensor] = None + language_hidden_states: Optional[Tuple[torch.FloatTensor]] = None + vision_hidden_states: Optional[Tuple[torch.FloatTensor]] = None + language_attentions: Optional[Tuple[torch.FloatTensor]] = None + vision_attentions: Optional[Tuple[torch.FloatTensor]] = None + cross_encoder_attentions: Optional[Tuple[torch.FloatTensor]] = None + + +@dataclass +class LxmertForQuestionAnsweringOutput(ModelOutput): + """ + Output type of :class:`~transformers.LxmertForQuestionAnswering`. + + Args: + loss (`optional`, returned when ``labels`` is provided, ``torch.FloatTensor`` of shape :obj:`(1,)`): + Total loss as the sum of the masked language modeling loss and the next sequence prediction (classification) loss.k. + question_answering_score: (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, n_qa_answers)`, `optional`): + Prediction scores of question answering objective (classification). + language_hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`torch.FloatTensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + vision_hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`torch.FloatTensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + language_attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + vision_attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + cross_encoder_attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + """ + + loss: Optional[torch.FloatTensor] = None + question_answering_score: Optional[torch.FloatTensor] = None + language_hidden_states: Optional[Tuple[torch.FloatTensor]] = None + vision_hidden_states: Optional[Tuple[torch.FloatTensor]] = None + language_attentions: Optional[Tuple[torch.FloatTensor]] = None + vision_attentions: Optional[Tuple[torch.FloatTensor]] = None + cross_encoder_attentions: Optional[Tuple[torch.FloatTensor]] = None + + +@dataclass +class LxmertForPreTrainingOutput(ModelOutput): + """ + Output type of :class:`~transformers.LxmertForPreTrainingModel`. + + Args: + loss (`optional`, returned when ``labels`` is provided, ``torch.FloatTensor`` of shape :obj:`(1,)`): + Total loss as the sum of the masked language modeling loss and the next sequence prediction (classification) loss. + prediction_logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, config.vocab_size)`): + Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax). + cross_relationship_score: (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, 2)`): + Prediction scores of the textual matching objective (classification) head (scores of True/False + continuation before SoftMax). + question_answering_score: (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, n_qa_answers)`): + Prediction scores of question answering objective (classification). + language_hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`torch.FloatTensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + vision_hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`torch.FloatTensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + language_attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + vision_attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + cross_encoder_attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + + """ + + loss: [torch.FloatTensor] = None + prediction_logits: Optional[torch.FloatTensor] = None + cross_relationship_score: Optional[torch.FloatTensor] = None + question_answering_score: Optional[torch.FloatTensor] = None + language_hidden_states: Optional[Tuple[torch.FloatTensor]] = None + vision_hidden_states: Optional[Tuple[torch.FloatTensor]] = None + language_attentions: Optional[Tuple[torch.FloatTensor]] = None + vision_attentions: Optional[Tuple[torch.FloatTensor]] = None + cross_encoder_attentions: Optional[Tuple[torch.FloatTensor]] = None + + +def load_tf_weights_in_lxmert(model, config, tf_checkpoint_path): + """Load tf checkpoints in a pytorch model.""" + try: + import re + + import numpy as np + import tensorflow as tf + except ImportError: + logger.error( + "Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see " + "https://www.tensorflow.org/install/ for installation instructions." + ) + raise + tf_path = os.path.abspath(tf_checkpoint_path) + logger.info("Converting TensorFlow checkpoint from {}".format(tf_path)) + # Load weights from TF model + init_vars = tf.train.list_variables(tf_path) + names = [] + arrays = [] + for name, shape in init_vars: + logger.info("Loading TF weight {} with shape {}".format(name, shape)) + array = tf.train.load_variable(tf_path, name) + names.append(name) + arrays.append(array) + + for name, array in zip(names, arrays): + name = name.split("/") + # adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v + # which are not required for using pretrained model + if any( + n + in [ + "adam_v", + "adam_m", + "AdamWeightDecayOptimizer", + "AdamWeightDecayOptimizer_1", + "global_step", + ] + for n in name + ): + logger.info("Skipping {}".format("/".join(name))) + continue + pointer = model + for m_name in name: + if re.fullmatch(r"[A-Za-z]+_\d+", m_name): + scope_names = re.split(r"_(\d+)", m_name) + else: + scope_names = [m_name] + if scope_names[0] == "kernel" or scope_names[0] == "gamma": + pointer = getattr(pointer, "weight") + elif scope_names[0] == "output_bias" or scope_names[0] == "beta": + pointer = getattr(pointer, "bias") + elif scope_names[0] == "output_weights": + pointer = getattr(pointer, "weight") + elif scope_names[0] == "squad": + pointer = getattr(pointer, "classifier") + else: + try: + pointer = getattr(pointer, scope_names[0]) + except AttributeError: + logger.info("Skipping {}".format("/".join(name))) + continue + if len(scope_names) >= 2: + num = int(scope_names[1]) + pointer = pointer[num] + if m_name[-11:] == "_embeddings": + pointer = getattr(pointer, "weight") + elif m_name == "kernel": + array = np.transpose(array) + try: + assert pointer.shape == array.shape + except AssertionError as e: + e.args += (pointer.shape, array.shape) + raise + logger.info("Initialize PyTorch weight {}".format(name)) + pointer.data = torch.from_numpy(array) + return model + + +ACT2FN = {"gelu": gelu, "relu": torch.nn.functional.relu, "swish": swish} + +LxmertLayerNorm = torch.nn.LayerNorm + + +class LxmertEmbeddings(nn.Module): + """Construct the embeddings from word, position and token_type embeddings.""" + + def __init__(self, config): + super().__init__() + self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=0) + self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size, padding_idx=0) + self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size, padding_idx=0) + + # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load + # any TensorFlow checkpoint file + self.LayerNorm = LxmertLayerNorm(config.hidden_size, eps=1e-12) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, input_ids, token_type_ids=None, inputs_embeds=None): + if input_ids is not None: + input_shape = input_ids.size() + device = input_ids.device + else: + input_shape = inputs_embeds.size()[:-1] + device = inputs_embeds.device + seq_length = input_shape[1] + + position_ids = torch.arange(seq_length, dtype=torch.long, device=device) + position_ids = position_ids.unsqueeze(0).expand(input_shape) + + if token_type_ids is None: + token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=self.position_ids.device) + + if inputs_embeds is None: + inputs_embeds = self.word_embeddings(input_ids) + position_embeddings = self.position_embeddings(position_ids) + token_type_embeddings = self.token_type_embeddings(token_type_ids) + + embeddings = inputs_embeds + position_embeddings + token_type_embeddings + embeddings = self.LayerNorm(embeddings) + embeddings = self.dropout(embeddings) + return embeddings + + +class LxmertAttention(nn.Module): + def __init__(self, config, ctx_dim=None): + super().__init__() + if config.hidden_size % config.num_attention_heads != 0: + raise ValueError( + "The hidden size (%d) is not a multiple of the number of attention " + "heads (%d)" % (config.hidden_size, config.num_attention_heads) + ) + self.num_attention_heads = config.num_attention_heads + self.attention_head_size = int(config.hidden_size / config.num_attention_heads) + self.head_size = self.num_attention_heads * self.attention_head_size + + # visual_dim = 2048 + if ctx_dim is None: + ctx_dim = config.hidden_size + self.query = nn.Linear(config.hidden_size, self.head_size) + self.key = nn.Linear(ctx_dim, self.head_size) + self.value = nn.Linear(ctx_dim, self.head_size) + + self.dropout = nn.Dropout(config.attention_probs_dropout_prob) + + def transpose_for_scores(self, x): + new_x_shape = x.size()[:-1] + ( + self.num_attention_heads, + self.attention_head_size, + ) + x = x.view(*new_x_shape) + return x.permute(0, 2, 1, 3) + + def forward(self, hidden_states, context, attention_mask=None, output_attentions=False): + mixed_query_layer = self.query(hidden_states) + mixed_key_layer = self.key(context) + mixed_value_layer = self.value(context) + + query_layer = self.transpose_for_scores(mixed_query_layer) + key_layer = self.transpose_for_scores(mixed_key_layer) + value_layer = self.transpose_for_scores(mixed_value_layer) + + # Take the dot product between "query" and "key" to get the raw attention scores. + attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2)) + attention_scores = attention_scores / math.sqrt(self.attention_head_size) + # Apply the attention mask is (precomputed for all layers in BertModel forward() function) + if attention_mask is not None: + attention_scores = attention_scores + attention_mask + + # Normalize the attention scores to probabilities. + attention_probs = nn.Softmax(dim=-1)(attention_scores) + + # This is actually dropping out entire tokens to attend to, which might + # seem a bit unusual, but is taken from the original Transformer paper. + attention_probs = self.dropout(attention_probs) + + context_layer = torch.matmul(attention_probs, value_layer) + context_layer = context_layer.permute(0, 2, 1, 3).contiguous() + new_context_layer_shape = context_layer.size()[:-2] + (self.head_size,) + context_layer = context_layer.view(*new_context_layer_shape) + + outputs = (context_layer, attention_probs) if output_attentions else (context_layer,) + return outputs + + +class LxmertAttentionOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + self.LayerNorm = LxmertLayerNorm(config.hidden_size, eps=1e-12) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class LxmertCrossAttentionLayer(nn.Module): + def __init__(self, config): + super().__init__() + self.att = LxmertAttention(config) + self.output = LxmertAttentionOutput(config) + + def forward(self, input_tensor, ctx_tensor, ctx_att_mask=None, output_attentions=False): + output = self.att(input_tensor, ctx_tensor, ctx_att_mask, output_attentions=output_attentions) + if output_attentions: + attention_probs = output[1] + attention_output = self.output(output[0], input_tensor) + outputs = (attention_output, attention_probs) if output_attentions else (attention_output,) + return outputs + + +class LxmertSelfAttentionLayer(nn.Module): + def __init__(self, config): + super().__init__() + self.self = LxmertAttention(config) + self.output = LxmertAttentionOutput(config) + + def forward(self, input_tensor, attention_mask, output_attentions=False): + # Self attention attends to itself, thus keys and querys are the same (input_tensor). + output = self.self( + input_tensor, + input_tensor, + attention_mask, + output_attentions=output_attentions, + ) + if output_attentions: + attention_probs = output[1] + attention_output = self.output(output[0], input_tensor) + outputs = (attention_output, attention_probs) if output_attentions else (attention_output,) + return outputs + + +class LxmertIntermediate(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.intermediate_size) + self.intermediate_act_fn = ACT2FN[config.hidden_act] + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.intermediate_act_fn(hidden_states) + return hidden_states + + +class LxmertOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.intermediate_size, config.hidden_size) + self.LayerNorm = LxmertLayerNorm(config.hidden_size, eps=1e-12) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class LxmertLayer(nn.Module): + def __init__(self, config): + super().__init__() + self.attention = LxmertSelfAttentionLayer(config) + self.intermediate = LxmertIntermediate(config) + self.output = LxmertOutput(config) + + def forward(self, hidden_states, attention_mask=None, output_attentions=False): + outputs = self.attention(hidden_states, attention_mask, output_attentions=output_attentions) + attention_output = outputs[0] + intermediate_output = self.intermediate(attention_output) + layer_output = self.output(intermediate_output, attention_output) + outputs = (layer_output,) + outputs[1:] # add attentions if we output them + return outputs + + +class LxmertXLayer(nn.Module): + def __init__(self, config): + super().__init__() + # The cross-attention Layer + self.visual_attention = LxmertCrossAttentionLayer(config) + + # Self-attention Layers + self.lang_self_att = LxmertSelfAttentionLayer(config) + self.visn_self_att = LxmertSelfAttentionLayer(config) + + # Intermediate and Output Layers (FFNs) + self.lang_inter = LxmertIntermediate(config) + self.lang_output = LxmertOutput(config) + self.visn_inter = LxmertIntermediate(config) + self.visn_output = LxmertOutput(config) + + def cross_att( + self, + lang_input, + lang_attention_mask, + visual_input, + visual_attention_mask, + output_x_attentions=False, + ): + # Cross Attention + lang_att_output = self.visual_attention( + lang_input, + visual_input, + ctx_att_mask=visual_attention_mask, + output_attentions=output_x_attentions, + ) + visual_att_output = self.visual_attention( + visual_input, + lang_input, + ctx_att_mask=lang_attention_mask, + output_attentions=False, + ) + return lang_att_output, visual_att_output + + def self_att(self, lang_input, lang_attention_mask, visual_input, visual_attention_mask): + # Self Attention + lang_att_output = self.lang_self_att(lang_input, lang_attention_mask, output_attentions=False) + visual_att_output = self.visn_self_att(visual_input, visual_attention_mask, output_attentions=False) + return lang_att_output[0], visual_att_output[0] + + def output_fc(self, lang_input, visual_input): + # FC layers + lang_inter_output = self.lang_inter(lang_input) + visual_inter_output = self.visn_inter(visual_input) + + # Layer output + lang_output = self.lang_output(lang_inter_output, lang_input) + visual_output = self.visn_output(visual_inter_output, visual_input) + + return lang_output, visual_output + + def forward( + self, + lang_feats, + lang_attention_mask, + visual_feats, + visual_attention_mask, + output_attentions=False, + ): + + lang_att_output, visual_att_output = self.cross_att( + lang_input=lang_feats, + lang_attention_mask=lang_attention_mask, + visual_input=visual_feats, + visual_attention_mask=visual_attention_mask, + output_x_attentions=output_attentions, + ) + attention_probs = lang_att_output[1:] + lang_att_output, visual_att_output = self.self_att( + lang_att_output[0], + lang_attention_mask, + visual_att_output[0], + visual_attention_mask, + ) + + lang_output, visual_output = self.output_fc(lang_att_output, visual_att_output) + return ( + ( + lang_output, + visual_output, + attention_probs[0], + ) + if output_attentions + else (lang_output, visual_output) + ) + + +class LxmertVisualFeatureEncoder(nn.Module): + def __init__(self, config): + super().__init__() + feat_dim = config.visual_feat_dim + pos_dim = config.visual_pos_dim + + # Object feature encoding + self.visn_fc = nn.Linear(feat_dim, config.hidden_size) + self.visn_layer_norm = LxmertLayerNorm(config.hidden_size, eps=1e-12) + + # Box position encoding + self.box_fc = nn.Linear(pos_dim, config.hidden_size) + self.box_layer_norm = LxmertLayerNorm(config.hidden_size, eps=1e-12) + + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, visual_feats, visual_pos): + x = self.visn_fc(visual_feats) + x = self.visn_layer_norm(x) + y = self.box_fc(visual_pos) + y = self.box_layer_norm(y) + output = (x + y) / 2 + + output = self.dropout(output) + return output + + +class LxmertEncoder(nn.Module): + def __init__(self, config): + super().__init__() + + # Obj-level image embedding layer + self.visn_fc = LxmertVisualFeatureEncoder(config) + self.config = config + + # Number of layers + self.num_l_layers = config.l_layers + self.num_x_layers = config.x_layers + self.num_r_layers = config.r_layers + + # Layers + # Using self.layer instead of self.l_layer to support loading BERT weights. + self.layer = nn.ModuleList([LxmertLayer(config) for _ in range(self.num_l_layers)]) + self.x_layers = nn.ModuleList([LxmertXLayer(config) for _ in range(self.num_x_layers)]) + self.r_layers = nn.ModuleList([LxmertLayer(config) for _ in range(self.num_r_layers)]) + + def forward( + self, + lang_feats, + lang_attention_mask, + visual_feats, + visual_pos, + visual_attention_mask=None, + output_attentions=None, + ): + + vision_hidden_states = () + language_hidden_states = () + vision_attentions = () if output_attentions or self.config.output_attentions else None + language_attentions = () if output_attentions or self.config.output_attentions else None + cross_encoder_attentions = () if output_attentions or self.config.output_attentions else None + + visual_feats = self.visn_fc(visual_feats, visual_pos) + + # Run language layers + for layer_module in self.layer: + l_outputs = layer_module(lang_feats, lang_attention_mask, output_attentions=output_attentions) + lang_feats = l_outputs[0] + language_hidden_states = language_hidden_states + (lang_feats,) + if language_attentions is not None: + language_attentions = language_attentions + (l_outputs[1],) + + # Run relational layers + for layer_module in self.r_layers: + v_outputs = layer_module(visual_feats, visual_attention_mask, output_attentions=output_attentions) + visual_feats = v_outputs[0] + vision_hidden_states = vision_hidden_states + (visual_feats,) + if vision_attentions is not None: + vision_attentions = vision_attentions + (v_outputs[1],) + + # Run cross-modality layers + for layer_module in self.x_layers: + x_outputs = layer_module( + lang_feats, + lang_attention_mask, + visual_feats, + visual_attention_mask, + output_attentions=output_attentions, + ) + lang_feats, visual_feats = x_outputs[:2] + vision_hidden_states = vision_hidden_states + (visual_feats,) + language_hidden_states = language_hidden_states + (lang_feats,) + if cross_encoder_attentions is not None: + cross_encoder_attentions = cross_encoder_attentions + (x_outputs[2],) + visual_encoder_outputs = ( + vision_hidden_states, + vision_attentions if output_attentions else None, + ) + lang_encoder_outputs = ( + language_hidden_states, + language_attentions if output_attentions else None, + ) + return ( + visual_encoder_outputs, + lang_encoder_outputs, + cross_encoder_attentions if output_attentions else None, + ) + + +class LxmertPooler(nn.Module): + def __init__(self, config): + super(LxmertPooler, self).__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + self.activation = nn.Tanh() + + def forward(self, hidden_states): + # We "pool" the model by simply taking the hidden state corresponding + # to the first token. + first_token_tensor = hidden_states[:, 0] + pooled_output = self.dense(first_token_tensor) + pooled_output = self.activation(pooled_output) + return pooled_output + + +class LxmertPredictionHeadTransform(nn.Module): + def __init__(self, config): + super(LxmertPredictionHeadTransform, self).__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + self.transform_act_fn = ACT2FN[config.hidden_act] + self.LayerNorm = LxmertLayerNorm(config.hidden_size, eps=1e-12) + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.transform_act_fn(hidden_states) + hidden_states = self.LayerNorm(hidden_states) + return hidden_states + + +class LxmertLMPredictionHead(nn.Module): + def __init__(self, config, lxmert_model_embedding_weights): + super(LxmertLMPredictionHead, self).__init__() + self.transform = LxmertPredictionHeadTransform(config) + + # The output weights are the same as the input embeddings, but there is + # an output-only bias for each token. + self.decoder = nn.Linear( + lxmert_model_embedding_weights.size(1), + lxmert_model_embedding_weights.size(0), + bias=False, + ) + self.decoder.weight = lxmert_model_embedding_weights + self.bias = nn.Parameter(torch.zeros(lxmert_model_embedding_weights.size(0))) + + def forward(self, hidden_states): + hidden_states = self.transform(hidden_states) + hidden_states = self.decoder(hidden_states) + self.bias + return hidden_states + + +class LxmertVisualAnswerHead(nn.Module): + def __init__(self, config, num_labels): + super().__init__() + hid_dim = config.hidden_size + self.logit_fc = nn.Sequential( + nn.Linear(hid_dim, hid_dim * 2), + GeLU(), + LxmertLayerNorm(hid_dim * 2, eps=1e-12), + nn.Linear(hid_dim * 2, num_labels), + ) + + def forward(self, hidden_states): + return self.logit_fc(hidden_states) + + +class LxmertVisualObjHead(nn.Module): + def __init__(self, config): + super().__init__() + self.transform = LxmertPredictionHeadTransform(config) + # Decide the use of visual losses + visual_losses = {} + if config.visual_obj_loss: + visual_losses["obj"] = {"shape": (-1,), "num": config.num_object_labels} + if config.visual_attr_loss: + visual_losses["attr"] = {"shape": (-1,), "num": config.num_attr_labels} + if config.visual_obj_loss: + visual_losses["feat"] = { + "shape": (-1, config.visual_feat_dim), + "num": config.visual_feat_dim, + } + self.visual_losses = visual_losses + + # The output weights are the same as the input embeddings, but there is + # an output-only bias for each token. + self.decoder_dict = nn.ModuleDict( + {key: nn.Linear(config.hidden_size, self.visual_losses[key]["num"]) for key in self.visual_losses} + ) + + def forward(self, hidden_states): + hidden_states = self.transform(hidden_states) + output = {} + for key in self.visual_losses: + output[key] = self.decoder_dict[key](hidden_states) + return output + + +class LxmertPreTrainingHeads(nn.Module): + def __init__(self, config, lxmert_model_embedding_weights): + super(LxmertPreTrainingHeads, self).__init__() + self.predictions = LxmertLMPredictionHead(config, lxmert_model_embedding_weights) + self.seq_relationship = nn.Linear(config.hidden_size, 2) + + def forward(self, sequence_output, pooled_output): + prediction_scores = self.predictions(sequence_output) + seq_relationship_score = self.seq_relationship(pooled_output) + return prediction_scores, seq_relationship_score + + +class LxmertPreTrainedModel(PreTrainedModel): + """An abstract class to handle weights initialization and + a simple interface for downloading and loading pretrained models. + """ + + config_class = LxmertConfig + load_tf_weights = load_tf_weights_in_lxmert + base_model_prefix = "lxmert" + + def _init_weights(self, module): + """ Initialize the weights """ + if isinstance(module, (nn.Linear, nn.Embedding)): + # Slightly different from the TF version which uses truncated_normal for initialization + # cf https://github.com/pytorch/pytorch/pull/5617 + module.weight.data.normal_(mean=0.0, std=self.config.initializer_range) + elif isinstance(module, LxmertLayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + + +LXMERT_START_DOCSTRING = r""" + The LXMERT model was proposed in `LXMERT: Learning Cross-Modality Encoder Representations from Transformers `__ + by Hao Tan and Mohit Bansal. It's a vision and language transformer model, + pre-trained on a variety of multi-modal datasets comprising of GQA, VQAv2.0, MCSCOCO captions, and Visual genome, + using a combination of masked language modeling, region of interest feature regression, + cross entropy loss for question answering attribute prediction, and object tag predicition. + + This model is a PyTorch `torch.nn.Module `_ sub-class. + Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general + usage and behavior. + + Parameters: + config (:class:`~transformers.LxmertConfig`): Model configuration class with all the parameters of the model. + Initializing with a config file does not load the weights associated with the model, only the configuration. + Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model weights. +""" + +LXMERT_INPUTS_DOCSTRING = r""" + + Args: + input_ids (:obj:`torch.LongTensor` of shape :obj:`{0}`): + Indices of input sequence tokens in the vocabulary. + + Indices can be obtained using :class:`transformers.LxmertTokenizer`. + See :func:`transformers.PreTrainedTokenizer.encode` and + :func:`transformers.PreTrainedTokenizer.__call__` for details. + + `What are input IDs? <../glossary.html#input-ids>`__ + visual_feats: (:obj:`torch.FloatTensor` of shape :obj:՝(batch_size, num_visual_features, visual_feat_dim)՝): + This input represents visual features. They ROI pooled object features from bounding boxes using a faster-RCNN model) + These are currently not provided by the transformers library + visual_pos: (:obj:`torch.FloatTensor` of shape :obj:՝(batch_size, num_visual_features, visual_pos_dim)՝): + This input represents spacial features corresponding to their relative (via index) visual features. + The pre-trained lxmert model expects these spacial features to be normalized bounding boxes on a scale of 0~1. + These are currently not provided by the transformers library + attention_mask (:obj:`torch.FloatTensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): + Mask to avoid performing attention on padding token indices. + Mask values selected in ``[0, 1]``: + ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens. + + `What are attention masks? <../glossary.html#attention-mask>`__ + visual_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): + Mask to avoid performing attention on padding token indices. + Mask values selected in ``[0, 1]``: + ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens. + + `What are attention masks? <../glossary.html#attention-mask>`__ + token_type_ids (:obj:`torch.LongTensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): + Segment token indices to indicate first and second portions of the inputs. + Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1`` + corresponds to a `sentence B` token + + `What are token type IDs? <../glossary.html#token-type-ids>`_ + inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`): + Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation. + This is useful if you want more control over how to convert `input_ids` indices into associated vectors + than the model's internal embedding lookup matrix. + output_attentions: (:obj:`bool`, `optional`, defaults to :obj:`None`): + If set to ``True``, the attentions tensors of all attention layers for the visual, language, and cross-modality encoder are returned. + output_hidden_states (:obj:`bool`, `optional`, defaults to :obj:`None`): + If set to ``True``, the hidden states for each respective modality will be returned when used as the input vector in the cross-modality encoder. + return_dict (:obj:`bool`, `optional`, defaults to :obj:`None`): + If set to ``True``, the model will return a :class:`~transformers.file_utils.LxmertModelOutput` instead of a + plain tuple. +""" + + +@add_start_docstrings( + "The bare Lxmert Model transformer outputting raw hidden-states without any specific head on top.", + LXMERT_START_DOCSTRING, +) +class LxmertModel(LxmertPreTrainedModel): + def __init__(self, config): + super().__init__(config) + self.embeddings = LxmertEmbeddings(config) + self.encoder = LxmertEncoder(config) + self.pooler = LxmertPooler(config) + self.init_weights() + + def get_input_embeddings(self): + return self.embeddings.word_embeddings + + def set_input_embeddings(self, new_embeddings): + self.embeddings.word_embeddings = new_embeddings + + @add_start_docstrings_to_callable(LXMERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)")) + @add_code_sample_docstrings( + tokenizer_class=_TOKENIZER_FOR_DOC, + checkpoint="unc-nlp/lxmert-base-uncased", + output_type=LxmertModelOutput, + config_class=_CONFIG_FOR_DOC, + ) + def forward( + self, + input_ids=None, + visual_feats=None, + visual_pos=None, + attention_mask=None, + visual_attention_mask=None, + token_type_ids=None, + inputs_embeds=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + ): + + output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions + output_hidden_states = ( + output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states + ) + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + if input_ids is not None and inputs_embeds is not None: + raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time") + elif input_ids is not None: + input_shape = input_ids.size() + elif inputs_embeds is not None: + input_shape = inputs_embeds.size()[:-1] + else: + raise ValueError("You have to specify either input_ids or inputs_embeds") + + assert visual_feats is not None, "`visual_feats` cannot be `None`" + assert visual_pos is not None, "`visual_pos` cannot be `None`" + + device = input_ids.device if input_ids is not None else inputs_embeds.device + + if attention_mask is None: + attention_mask = torch.ones(input_shape, device=device) + if token_type_ids is None: + token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device) + + # We create a 3D attention mask from a 2D tensor mask. + # Sizes are [batch_size, 1, 1, to_seq_length] + # So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length] + # this attention mask is more simple than the triangular masking of causal attention + # used in OpenAI GPT, we just need to prepare the broadcast dimension here. + extended_attention_mask = attention_mask.unsqueeze(1).unsqueeze(2) + + # Since attention_mask is 1.0 for positions we want to attend and 0.0 for + # masked positions, this operation will create a tensor which is 0.0 for + # positions we want to attend and -10000.0 for masked positions. + # Since we are adding it to the raw scores before the softmax, this is + # effectively the same as removing these entirely. + extended_attention_mask = extended_attention_mask.to(dtype=next(self.parameters()).dtype) + extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0 + + # Process the visual attention mask + if visual_attention_mask is not None: + extended_visual_attention_mask = visual_attention_mask.unsqueeze(1).unsqueeze(2) + extended_visual_attention_mask = extended_visual_attention_mask.to(dtype=next(self.parameters()).dtype) + extended_visual_attention_mask = (1.0 - extended_visual_attention_mask) * -10000.0 + else: + extended_visual_attention_mask = None + + # Positional Word Embeddings + embedding_output = self.embeddings(input_ids, token_type_ids, inputs_embeds) + + # Run Lxmert encoder + encoder_outputs = self.encoder( + embedding_output, + extended_attention_mask, + visual_feats=visual_feats, + visual_pos=visual_pos, + visual_attention_mask=extended_visual_attention_mask, + output_attentions=output_attentions, + ) + + visual_encoder_outputs, lang_encoder_outputs = encoder_outputs[:2] + vision_hidden_states = visual_encoder_outputs[0] + language_hidden_states = lang_encoder_outputs[0] + + all_attentions = () + if output_attentions: + language_attentions = lang_encoder_outputs[1] + vision_attentions = visual_encoder_outputs[1] + cross_encoder_attentions = encoder_outputs[2] + all_attentions = ( + language_attentions, + vision_attentions, + cross_encoder_attentions, + ) + + hidden_states = (language_hidden_states, vision_hidden_states) if output_hidden_states else () + + visual_output = vision_hidden_states[-1] + lang_output = language_hidden_states[-1] + pooled_output = self.pooler(lang_output) + + if not return_dict: + return (lang_output, visual_output, pooled_output) + hidden_states + all_attentions + + return LxmertModelOutput( + pooled_output=pooled_output, + language_output=lang_output, + vision_output=visual_output, + language_hidden_states=language_hidden_states if output_hidden_states else None, + vision_hidden_states=vision_hidden_states if output_hidden_states else None, + language_attentions=language_attentions if output_attentions else None, + vision_attentions=vision_attentions if output_attentions else None, + cross_encoder_attentions=cross_encoder_attentions if output_attentions else None, + ) + + +@add_start_docstrings( + """Lxmert Model with a specified pre-training head on top. """, + LXMERT_START_DOCSTRING, +) +class LxmertForPreTraining(LxmertPreTrainedModel): + def __init__(self, config): + super().__init__(config) + # Configuration + self.config = config + self.num_qa_labels = config.num_qa_labels + self.visual_loss_normalizer = config.visual_loss_normalizer + + # Use of pre-training tasks + self.task_mask_lm = config.task_mask_lm + self.task_obj_predict = config.task_obj_predict + self.task_matched = config.task_matched + self.task_qa = config.task_qa + + # Lxmert backbone + self.lxmert = LxmertModel(config) + + # Pre-training heads + self.cls = LxmertPreTrainingHeads(config, self.lxmert.embeddings.word_embeddings.weight) + if self.task_obj_predict: + self.obj_predict_head = LxmertVisualObjHead(config) + if self.task_qa: + self.answer_head = LxmertVisualAnswerHead(config, self.num_qa_labels) + + # Weight initialization + self.init_weights() + + # Loss functions + self.loss_fcts = { + "l2": SmoothL1Loss(reduction="none"), + "visual_ce": CrossEntropyLoss(reduction="none"), + "ce": CrossEntropyLoss(), + } + + visual_losses = {} + if config.visual_obj_loss: + visual_losses["obj"] = { + "shape": (-1,), + "num": config.num_object_labels, + "loss": "visual_ce", + } + if config.visual_attr_loss: + visual_losses["attr"] = { + "shape": (-1,), + "num": config.num_attr_labels, + "loss": "visual_ce", + } + if config.visual_obj_loss: + visual_losses["feat"] = { + "shape": (-1, config.visual_feat_dim), + "num": config.visual_feat_dim, + "loss": "l2", + } + self.visual_losses = visual_losses + + def resize_num_qa_labels(self, num_labels): + """ + Build a resized question answering linear layer Module from a provided new linear layer. Increasing the size will add newly + initialized weights. Reducing the size will remove weights from the end + + Args: + cur_qa_logit_layer (:obj:`torch.nn.Linear`): + Old linear layer to be resized. + num_labels (:obj:`int`, `optional`): + New number of labels in the linear layer weight matrix. + Increasing the size will add newly initialized weights at the end. Reducing the size will remove + weights from the end. If not provided or :obj:`None`, just returns a pointer to the qa labels + :obj:`torch.nn.Linear`` module of the model wihtout doing anything. + + Return: + :obj:`torch.nn.Linear`: Pointer to the resized Linear layer or the old Linear layer + """ + + cur_qa_logit_layer = self.get_qa_logit_layer() + if num_labels is None or cur_qa_logit_layer is None: + return + new_qa_logit_layer = self._resize_qa_labels(num_labels) + self.config.num_qa_labels = num_labels + self.num_qa_labels = num_labels + + return new_qa_logit_layer + + def _resize_qa_labels(self, num_labels): + cur_qa_logit_layer = self.get_qa_logit_layer() + new_qa_logit_layer = self._get_resized_qa_labels(cur_qa_logit_layer, num_labels) + self._set_qa_logit_layer(new_qa_logit_layer) + return self.get_qa_logit_layer() + + def get_qa_logit_layer(self) -> nn.Module: + """ + Returns the the linear layer that produces question answering logits. + + Returns: + :obj:`nn.Module`: A torch module mapping the question answering prediction hidden states or :obj:`None` if + LXMERT does not have a visual answering head. + """ + if hasattr(self, "answer_head"): + return self.answer_head.logit_fc[-1] + + def _set_qa_logit_layer(self, qa_logit_layer): + self.answer_head.logit_fc[-1] = qa_logit_layer + + def _get_resized_qa_labels(self, cur_qa_logit_layer, num_labels): + + if num_labels is None: + return cur_qa_logit_layer + + cur_qa_labels, hidden_dim = cur_qa_logit_layer.weight.size() + if cur_qa_labels == num_labels: + return cur_qa_logit_layer + + # Build new linear output + if getattr(cur_qa_logit_layer, "bias", None) is not None: + new_qa_logit_layer = nn.Linear(hidden_dim, num_labels) + else: + new_qa_logit_layer = nn.Linear(hidden_dim, num_labels, bias=False) + + new_qa_logit_layer.to(cur_qa_logit_layer.weight.device) + + # initialize all new labels + self._init_weights(new_qa_logit_layer) + + # Copy labels from the previous weights + num_labels_to_copy = min(cur_qa_labels, num_labels) + new_qa_logit_layer.weight.data[:num_labels_to_copy, :] = cur_qa_logit_layer.weight.data[:num_labels_to_copy, :] + if getattr(cur_qa_logit_layer, "bias", None) is not None: + new_qa_logit_layer.bias.data[:num_labels_to_copy] = cur_qa_logit_layer.bias.data[:num_labels_to_copy] + + return new_qa_logit_layer + + @add_start_docstrings_to_callable(LXMERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)")) + @replace_return_docstrings(output_type=LxmertForPreTrainingOutput, config_class=_CONFIG_FOR_DOC) + def forward( + self, + input_ids=None, + visual_feats=None, + visual_pos=None, + attention_mask=None, + visual_attention_mask=None, + token_type_ids=None, + inputs_embeds=None, + masked_lm_labels=None, + obj_labels=None, + matched_label=None, + ans=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + ): + r""" + masked_lm_labels (``torch.LongTensor`` of shape ``(batch_size, sequence_length)``, `optional`, defaults to :obj:`None`): + Labels for computing the masked language modeling loss. + Indices should be in ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring) + Tokens with indices set to ``-100`` are ignored (masked), the loss is only computed for the tokens with labels + in ``[0, ..., config.vocab_size]`` + obj_labels: (``Dict[Str: Tuple[Torch.FloatTensor, Torch.FloatTensor]]``, `optional`, defaults to :obj: `None`): + each key is named after each one of the visual losses and each element of the tuple is of the shape + ``(batch_size, num_features)`` and ``(batch_size, num_features, visual_feature_dim)`` + for each the label id and the label score respectively + matched_label (``torch.LongTensor`` of shape ``(batch_size,)``, `optional`, defaults to :obj:`None`): + Labels for computing the whether or not the text input matches the image (classification) loss. Input should be a sequence pair (see :obj:`input_ids` docstring) + Indices should be in ``[0, 1]``. + ``0`` indicates that the sentence does not match the image + ``1`` indicates that the sentence does match the image + ans: (``Torch.Tensor`` of shape ``(batch_size)``, `optional`, defaults to :obj: `None`): + a one hot representation hof the correct answer `optional` + + Returns: + """ + + device = input_ids.device if input_ids is not None else inputs_embeds.device + lxmert_output = self.lxmert( + input_ids=input_ids, + visual_feats=visual_feats, + visual_pos=visual_pos, + token_type_ids=token_type_ids, + attention_mask=attention_mask, + visual_attention_mask=visual_attention_mask, + inputs_embeds=inputs_embeds, + output_hidden_states=output_hidden_states, + output_attentions=output_attentions, + return_dict=return_dict, + ) + + lang_output, visual_output, pooled_output = ( + lxmert_output[0], + lxmert_output[1], + lxmert_output[2], + ) + lang_prediction_scores, cross_relationship_score = self.cls(lang_output, pooled_output) + if self.task_qa: + answer_score = self.answer_head(pooled_output) + else: + answer_score = pooled_output[0][0] + + total_loss = ( + None + if (masked_lm_labels is None and matched_label is None and obj_labels is None and ans is None) + else torch.tensor(0.0, device=device) + ) + if masked_lm_labels is not None and self.task_mask_lm: + masked_lm_loss = self.loss_fcts["ce"]( + lang_prediction_scores.view(-1, self.config.vocab_size), + masked_lm_labels.view(-1), + ) + total_loss += masked_lm_loss + if matched_label is not None and self.task_matched: + matched_loss = self.loss_fcts["ce"](cross_relationship_score.view(-1, 2), matched_label.view(-1)) + total_loss += matched_loss + if obj_labels is not None and self.task_obj_predict: + total_visual_loss = torch.tensor(0.0, device=input_ids.device) + visual_prediction_scores_dict = self.obj_predict_head(visual_output) + for key, key_info in self.visual_losses.items(): + label, mask_conf = obj_labels[key] + output_dim = key_info["num"] + loss_fct_name = key_info["loss"] + label_shape = key_info["shape"] + weight = self.visual_loss_normalizer + visual_loss_fct = self.loss_fcts[loss_fct_name] + visual_prediction_scores = visual_prediction_scores_dict[key] + visual_loss = visual_loss_fct( + visual_prediction_scores.view(-1, output_dim), + label.view(*label_shape), + ) + if visual_loss.dim() > 1: # Regression Losses + visual_loss = visual_loss.mean(1) + visual_loss = (visual_loss * mask_conf.view(-1)).mean() * weight + total_visual_loss += visual_loss + total_loss += total_visual_loss + if ans is not None and self.task_qa: + answer_loss = self.loss_fcts["ce"](answer_score.view(-1, self.num_qa_labels), ans.view(-1)) + total_loss += answer_loss + + if not return_dict: + output = ( + lang_prediction_scores, + cross_relationship_score, + answer_score, + ) + lxmert_output[3:] + return ((total_loss,) + output) if total_loss is not None else output + + return LxmertForPreTrainingOutput( + loss=total_loss, + prediction_logits=lang_prediction_scores, + cross_relationship_score=cross_relationship_score, + question_answering_score=answer_score, + language_hidden_states=lxmert_output.language_hidden_states, + vision_hidden_states=lxmert_output.vision_hidden_states, + language_attentions=lxmert_output.language_attentions, + vision_attentions=lxmert_output.vision_attentions, + cross_encoder_attentions=lxmert_output.cross_encoder_attentions, + ) + + +@add_start_docstrings( + """Lxmert Model with a visual-answering head on top for downstream QA tasks""", + LXMERT_START_DOCSTRING, +) +class LxmertForQuestionAnswering(LxmertPreTrainedModel): + def __init__(self, config): + super().__init__(config) + # Configuration + self.config = config + self.num_qa_labels = config.num_qa_labels + self.visual_loss_normalizer = config.visual_loss_normalizer + + # Lxmert backbone + self.lxmert = LxmertModel(config) + + self.answer_head = LxmertVisualAnswerHead(config, self.num_qa_labels) + + # Weight initialization + self.init_weights() + + # Loss function + self.loss = CrossEntropyLoss() + + def resize_num_qa_labels(self, num_labels): + """ + Build a resized question answering linear layer Module from a provided new linear layer. Increasing the size will add newly + initialized weights. Reducing the size will remove weights from the end + + Args: + cur_qa_logit_layer (:obj:`torch.nn.Linear`): + Old linear layer to be resized. + num_labels (:obj:`int`, `optional`): + New number of labels in the linear layer weight matrix. + Increasing the size will add newly initialized weights at the end. Reducing the size will remove + weights from the end. If not provided or :obj:`None`, just returns a pointer to the qa labels + :obj:`torch.nn.Linear`` module of the model wihtout doing anything. + + Return: + :obj:`torch.nn.Linear`: Pointer to the resized Linear layer or the old Linear layer + """ + + cur_qa_logit_layer = self.get_qa_logit_layer() + if num_labels is None or cur_qa_logit_layer is None: + return + new_qa_logit_layer = self._resize_qa_labels(num_labels) + self.config.num_qa_labels = num_labels + self.num_qa_labels = num_labels + + return new_qa_logit_layer + + def _resize_qa_labels(self, num_labels): + cur_qa_logit_layer = self.get_qa_logit_layer() + new_qa_logit_layer = self._get_resized_qa_labels(cur_qa_logit_layer, num_labels) + self._set_qa_logit_layer(new_qa_logit_layer) + return self.get_qa_logit_layer() + + def get_qa_logit_layer(self) -> nn.Module: + """ + Returns the the linear layer that produces question answering logits + + Returns: + :obj:`nn.Module`: A torch module mapping the question answering prediction hidden states. + :obj:`None`: A NoneType object if Lxmert does not have the visual answering head. + """ + + if hasattr(self, "answer_head"): + return self.answer_head.logit_fc[-1] + + def _set_qa_logit_layer(self, qa_logit_layer): + self.answer_head.logit_fc[-1] = qa_logit_layer + + def _get_resized_qa_labels(self, cur_qa_logit_layer, num_labels): + + if num_labels is None: + return cur_qa_logit_layer + + cur_qa_labels, hidden_dim = cur_qa_logit_layer.weight.size() + if cur_qa_labels == num_labels: + return cur_qa_logit_layer + + # Build new linear output + if getattr(cur_qa_logit_layer, "bias", None) is not None: + new_qa_logit_layer = nn.Linear(hidden_dim, num_labels) + else: + new_qa_logit_layer = nn.Linear(hidden_dim, num_labels, bias=False) + + new_qa_logit_layer.to(cur_qa_logit_layer.weight.device) + + # initialize all new labels + self._init_weights(new_qa_logit_layer) + + # Copy labels from the previous weights + num_labels_to_copy = min(cur_qa_labels, num_labels) + new_qa_logit_layer.weight.data[:num_labels_to_copy, :] = cur_qa_logit_layer.weight.data[:num_labels_to_copy, :] + if getattr(cur_qa_logit_layer, "bias", None) is not None: + new_qa_logit_layer.bias.data[:num_labels_to_copy] = cur_qa_logit_layer.bias.data[:num_labels_to_copy] + + return new_qa_logit_layer + + @add_start_docstrings_to_callable(LXMERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)")) + @add_code_sample_docstrings( + tokenizer_class=_TOKENIZER_FOR_DOC, + checkpoint="unc-nlp/lxmert-base-uncased", + output_type=LxmertForQuestionAnsweringOutput, + config_class=_CONFIG_FOR_DOC, + ) + def forward( + self, + input_ids=None, + visual_feats=None, + visual_pos=None, + attention_mask=None, + visual_attention_mask=None, + token_type_ids=None, + inputs_embeds=None, + labels=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + ): + r""" + labels: (``Torch.Tensor`` of shape ``(batch_size)``, `optional`): + a one hot representation of the correct answer + + Returns: + """ + + lxmert_output = self.lxmert( + input_ids=input_ids, + visual_feats=visual_feats, + visual_pos=visual_pos, + token_type_ids=token_type_ids, + attention_mask=attention_mask, + visual_attention_mask=visual_attention_mask, + inputs_embeds=inputs_embeds, + output_hidden_states=output_hidden_states, + output_attentions=output_attentions, + return_dict=return_dict, + ) + + pooled_output = lxmert_output[2] + answer_score = self.answer_head(pooled_output) + loss = None + if labels is not None: + loss = self.loss(answer_score.view(-1, self.num_qa_labels), labels.view(-1)) + + if not return_dict: + output = (answer_score,) + lxmert_output[3:] + return (loss,) + output if loss is not None else output + + return LxmertForQuestionAnsweringOutput( + loss=loss, + question_answering_score=answer_score, + language_hidden_states=lxmert_output.language_hidden_states, + vision_hidden_states=lxmert_output.vision_hidden_states, + language_attentions=lxmert_output.language_attentions, + vision_attentions=lxmert_output.vision_attentions, + cross_encoder_attentions=lxmert_output.cross_encoder_attentions, + ) diff --git a/src/transformers/modeling_tf_lxmert.py b/src/transformers/modeling_tf_lxmert.py new file mode 100644 index 0000000000..3905b13459 --- /dev/null +++ b/src/transformers/modeling_tf_lxmert.py @@ -0,0 +1,1378 @@ +# coding=utf-8 +# Copyright 2018 The Google AI Language Team Authors, The HuggingFace Inc. team, and the +# Lxmert Authors. +# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" TF 2.0 LXMERT model. """ + + +import logging +from dataclasses import dataclass +from typing import Dict, Optional, Tuple + +import numpy as np +import tensorflow as tf + +from transformers import BatchEncoding + +from .configuration_lxmert import LxmertConfig +from .file_utils import ( + ModelOutput, + add_code_sample_docstrings, + add_start_docstrings, + add_start_docstrings_to_callable, + replace_return_docstrings, +) +from .modeling_tf_utils import TFPreTrainedModel, get_initializer, keras_serializable, shape_list + + +logger = logging.getLogger(__name__) + + +_CONFIG_FOR_DOC = "LxmertConfig" +_TOKENIZER_FOR_DOC = "LxmertTokenizer" + +TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST = [ + "unc-nlp/lxmert-base-uncased", +] + + +def gelu(x): + """Gaussian Error Linear Unit. + Original Implementation of the gelu activation function in Google Bert repo when initially created. + For information: OpenAI GPT's gelu is slightly different (and gives slightly different results): + 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3)))) + Also see https://arxiv.org/abs/1606.08415 + """ + cdf = 0.5 * (1.0 + tf.math.erf(x / tf.math.sqrt(2.0))) + return x * cdf + + +def gelu_new(x): + """Gaussian Error Linear Unit. + This is a smoother version of the RELU. + Original paper: https://arxiv.org/abs/1606.08415 + Args: + x: float Tensor to perform activation. + Returns: + `x` with the GELU activation applied. + """ + cdf = 0.5 * (1.0 + tf.tanh((np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3))))) + return x * cdf + + +def swish(x): + return x * tf.sigmoid(x) + + +ACT2FN = { + "gelu": tf.keras.layers.Activation(gelu), + "relu": tf.keras.activations.relu, + "swish": tf.keras.layers.Activation(swish), + "gelu_new": tf.keras.layers.Activation(gelu_new), +} + + +@dataclass +class TFLxmertModelOutput(ModelOutput): + """ + Lxmert's outputs that contain the last hidden states, pooled outputs, and attention probabilites for + the language, visual, and, cross-modality encoders. + (note: the visual encoder in Lxmert is referred to as the "relation-ship" encoder") + + + Args: + language_output (:obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`): + Sequence of hidden-states at the output of the last layer of the language encoder. + vision_output (:obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`): + Sequence of hidden-states at the output of the last layer of the visual encoder. + pooled_output (:obj:`tf.Tensor` of shape :obj:`(batch_size, hidden_size)`): + Last layer hidden-state of the first token of the sequence (classification, CLS, token) + further processed by a Linear layer and a Tanh activation function. The Linear + language_hidden_states (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`tf.Tensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + vision_hidden_states (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`tf.Tensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + language_attentions (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`tf.Tensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + vision_attentions (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`tf.Tensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + cross_encoder_attentions (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`tf.Tensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + """ + + language_output: Optional[tf.Tensor] = None + vision_output: Optional[tf.Tensor] = None + pooled_output: Optional[tf.Tensor] = None + language_hidden_states: Optional[Tuple[tf.Tensor]] = None + vision_hidden_states: Optional[Tuple[tf.Tensor]] = None + language_attentions: Optional[Tuple[tf.Tensor]] = None + vision_attentions: Optional[Tuple[tf.Tensor]] = None + cross_encoder_attentions: Optional[Tuple[tf.Tensor]] = None + + +@dataclass +class TFLxmertForPreTrainingOutput(ModelOutput): + """ + Output type of :class:`~transformers.LxmertForPreTrainingModel`. + + Args: + loss (`optional`, returned when ``labels`` is provided, ``tf.Tensor`` of shape :obj:`(1,)`): + Total loss as the sum of the masked language modeling loss and the next sequence prediction (classification) loss. + prediction_logits (:obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, config.vocab_size)`): + Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax). + cross_relationship_score: (:obj:`tf.Tensor` of shape :obj:`(batch_size, 2)`): + Prediction scores of the textual matching objective (classification) head (scores of True/False + continuation before SoftMax). + question_answering_score: (:obj:`tf.Tensor` of shape :obj:`(batch_size, n_qa_answers)`): + Prediction scores of question answering objective (classification). + language_hidden_states (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`tf.Tensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + vision_hidden_states (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``): + Tuple of :obj:`tf.Tensor` (one for input features + one for the output of each cross-modality layer) + of shape :obj:`(batch_size, sequence_length, hidden_size)`. + language_attentions (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`tf.Tensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + vision_attentions (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`tf.Tensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + cross_encoder_attentions (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``): + Tuple of :obj:`tf.Tensor` (one for each layer) of shape + :obj:`(batch_size, num_heads, sequence_length, sequence_length)`. + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + + """ + + loss: [tf.Tensor] = None + prediction_logits: Optional[tf.Tensor] = None + cross_relationship_score: Optional[tf.Tensor] = None + question_answering_score: Optional[tf.Tensor] = None + language_hidden_states: Optional[Tuple[tf.Tensor]] = None + vision_hidden_states: Optional[Tuple[tf.Tensor]] = None + language_attentions: Optional[Tuple[tf.Tensor]] = None + vision_attentions: Optional[Tuple[tf.Tensor]] = None + cross_encoder_attentions: Optional[Tuple[tf.Tensor]] = None + + +class TFLxmertVisualFeatureEncoder(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + + # Object feature encoding + self.visn_fc = tf.keras.layers.Dense( + config.hidden_size, + kernel_initializer=get_initializer(config.initializer_range), + name="visn_fc", + ) + self.visn_layer_norm = tf.keras.layers.LayerNormalization( + epsilon=config.layer_norm_eps, name="visn_layer_norm" + ) + + # Box position encoding + self.box_fc = tf.keras.layers.Dense( + config.hidden_size, + kernel_initializer=get_initializer(config.initializer_range), + name="box_fc", + ) + self.box_layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name="box_layer_norm") + + self.dropout = tf.keras.layers.Dropout(config.hidden_dropout_prob) + + def call(self, visn_input, training=False): + feats, boxes = visn_input + + x = self.visn_fc(feats) + x = self.visn_layer_norm(x) + y = self.box_fc(boxes) + y = self.box_layer_norm(y) + output = (x + y) / 2 + + output = self.dropout(output, training=training) + return output + + +class TFLxmertEmbeddings(tf.keras.layers.Layer): + """Construct the embeddings from word, position and token_type embeddings.""" + + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.vocab_size = config.vocab_size + self.hidden_size = config.hidden_size + self.initializer_range = config.initializer_range + + self.position_embeddings = tf.keras.layers.Embedding( + config.max_position_embeddings, + config.hidden_size, + embeddings_initializer=get_initializer(self.initializer_range), + name="position_embeddings", + ) + self.token_type_embeddings = tf.keras.layers.Embedding( + config.type_vocab_size, + config.hidden_size, + embeddings_initializer=get_initializer(self.initializer_range), + name="token_type_embeddings", + ) + + # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load + # any TensorFlow checkpoint file + self.LayerNorm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name="LayerNorm") + self.dropout = tf.keras.layers.Dropout(config.hidden_dropout_prob) + + def build(self, input_shape): + """Build shared word embedding layer """ + with tf.name_scope("word_embeddings"): + # Create and initialize weights. The random normal initializer was chosen + # arbitrarily, and works well. + self.word_embeddings = self.add_weight( + "weight", + shape=[self.vocab_size, self.hidden_size], + initializer=get_initializer(self.initializer_range), + ) + super().build(input_shape) + + def call(self, inputs, mode="embedding", training=False): + """Get token embeddings of inputs. + Args: + inputs: list of three int64 tensors with shape [batch_size, length]: (input_ids, position_ids, token_type_ids) + mode: string, a valid value is one of "embedding" and "linear". + Returns: + outputs: (1) If mode == "embedding", output embedding tensor, float32 with + shape [batch_size, length, embedding_size]; (2) mode == "linear", output + linear tensor, float32 with shape [batch_size, length, vocab_size]. + Raises: + ValueError: if mode is not valid. + + Shared weights logic adapted from + https://github.com/tensorflow/models/blob/a009f4fb9d2fc4949e32192a944688925ef78659/official/transformer/v2/embedding_layer.py#L24 + """ + if mode == "embedding": + return self._embedding(inputs, training=training) + elif mode == "linear": + return self._linear(inputs) + else: + raise ValueError("mode {} is not valid.".format(mode)) + + def _embedding(self, inputs, training=False): + """Applies embedding based on inputs tensor.""" + input_ids, token_type_ids, inputs_embeds = inputs + + if input_ids is not None: + input_shape = shape_list(input_ids) + else: + input_shape = shape_list(inputs_embeds)[:-1] + + seq_length = input_shape[1] + position_ids = tf.range(seq_length, dtype=tf.int32)[tf.newaxis, :] + if token_type_ids is None: + token_type_ids = tf.fill(input_shape, 0) + + if inputs_embeds is None: + inputs_embeds = tf.gather(self.word_embeddings, input_ids) + position_embeddings = self.position_embeddings(position_ids) + token_type_embeddings = self.token_type_embeddings(token_type_ids) + + embeddings = inputs_embeds + position_embeddings + token_type_embeddings + embeddings = self.LayerNorm(embeddings) + embeddings = self.dropout(embeddings, training=training) + return embeddings + + def _linear(self, inputs): + """Computes logits by running inputs through a linear layer. + Args: + inputs: A float32 tensor with shape [batch_size, length, hidden_size] + Returns: + float32 tensor with shape [batch_size, length, vocab_size]. + """ + batch_size = shape_list(inputs)[0] + length = shape_list(inputs)[1] + + x = tf.reshape(inputs, [-1, self.hidden_size]) + logits = tf.matmul(x, self.word_embeddings, transpose_b=True) + + return tf.reshape(logits, [batch_size, length, self.vocab_size]) + + +class TFLxmertAttention(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + if config.hidden_size % config.num_attention_heads != 0: + raise ValueError( + "The hidden size (%d) is not a multiple of the number of attention " + "heads (%d)" % (config.hidden_size, config.num_attention_heads) + ) + + self.num_attention_heads = config.num_attention_heads + assert config.hidden_size % config.num_attention_heads == 0 + self.attention_head_size = int(config.hidden_size / config.num_attention_heads) + self.all_head_size = self.num_attention_heads * self.attention_head_size + + self.query = tf.keras.layers.Dense( + self.all_head_size, + kernel_initializer=get_initializer(config.initializer_range), + name="query", + ) + self.key = tf.keras.layers.Dense( + self.all_head_size, + kernel_initializer=get_initializer(config.initializer_range), + name="key", + ) + self.value = tf.keras.layers.Dense( + self.all_head_size, + kernel_initializer=get_initializer(config.initializer_range), + name="value", + ) + + self.dropout = tf.keras.layers.Dropout(config.attention_probs_dropout_prob) + + def transpose_for_scores(self, x, batch_size): + x = tf.reshape(x, (batch_size, -1, self.num_attention_heads, self.attention_head_size)) + return tf.transpose(x, perm=[0, 2, 1, 3]) + + def call(self, hidden_states, context, attention_mask, output_attentions, training=False): + batch_size = shape_list(hidden_states)[0] + mixed_query_layer = self.query(hidden_states) + mixed_key_layer = self.key(context) + mixed_value_layer = self.value(context) + + query_layer = self.transpose_for_scores(mixed_query_layer, batch_size) + key_layer = self.transpose_for_scores(mixed_key_layer, batch_size) + value_layer = self.transpose_for_scores(mixed_value_layer, batch_size) + + # Take the dot product between "query" and "key" to get the raw attention scores. + attention_scores = tf.matmul( + query_layer, key_layer, transpose_b=True + ) # (batch size, num_heads, seq_len_q, seq_len_k) + dk = tf.cast(shape_list(key_layer)[-1], tf.float32) # scale attention_scores + attention_scores = attention_scores / tf.math.sqrt(dk) + + if attention_mask is not None: + # Apply the attention mask is (precomputed for all layers in TFBertModel call() function) + attention_scores = attention_scores + attention_mask + + # Normalize the attention scores to probabilities. + attention_probs = tf.nn.softmax(attention_scores, axis=-1) + + # This is actually dropping out entire tokens to attend to, which might + # seem a bit unusual, but is taken from the original Transformer paper. + attention_probs = self.dropout(attention_probs, training=training) + context_layer = tf.matmul(attention_probs, value_layer) + + context_layer = tf.transpose(context_layer, perm=[0, 2, 1, 3]) + context_layer = tf.reshape( + context_layer, (batch_size, -1, self.all_head_size) + ) # (batch_size, seq_len_q, all_head_size) + + outputs = (context_layer, attention_probs) if output_attentions else (context_layer,) + return outputs + + +class TFLxmertIntermediate(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.dense = tf.keras.layers.Dense( + config.intermediate_size, + kernel_initializer=get_initializer(config.initializer_range), + name="dense", + ) + if isinstance(config.hidden_act, str): + self.intermediate_act_fn = ACT2FN[config.hidden_act] + else: + self.intermediate_act_fn = config.hidden_act + + def call(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.intermediate_act_fn(hidden_states) + return hidden_states + + +class TFLxmertOutput(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.dense = tf.keras.layers.Dense( + config.hidden_size, + kernel_initializer=get_initializer(config.initializer_range), + name="dense", + ) + + self.LayerNorm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name="LayerNorm") + self.dropout = tf.keras.layers.Dropout(config.hidden_dropout_prob) + + def call(self, hidden_states, input_tensor, training=False): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states, training) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class TFLxmertAttentionOutput(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.dense = tf.keras.layers.Dense( + config.hidden_size, + kernel_initializer=get_initializer(config.initializer_range), + name="dense", + ) + self.LayerNorm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name="LayerNorm") + self.dropout = tf.keras.layers.Dropout(config.hidden_dropout_prob) + + def call(self, hidden_states, input_tensor, training=False): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states, training=training) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class TFLxmertSelfAttentionLayer(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.self = TFLxmertAttention(config, name="self") + self.attention_output = TFLxmertAttentionOutput(config, name="output") + + def call(self, input_tensor, attention_mask, output_attentions, training=False): + # Self attention attends to itself, thus keys and querys are the same (input_tensor). + self_output = self.self(input_tensor, input_tensor, attention_mask, output_attentions) + if output_attentions: + attention_probs = self_output[1] + attention_output = self.attention_output(self_output[0], input_tensor) + return (attention_output, attention_probs) if output_attentions else (attention_output,) + + +class TFLxmertCrossAttentionLayer(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.att = TFLxmertAttention(config, name="att") + self.attention_output = TFLxmertAttentionOutput(config, name="output") + + def call( + self, + input_tensor, + ctx_tensor, + ctx_att_mask, + output_attentions=False, + training=False, + ): + output = self.att(input_tensor, ctx_tensor, ctx_att_mask, output_attentions, training=training) + if output_attentions: + attention_probs = output[1] + attention_output = self.attention_output(output[0], input_tensor, training=training) + outputs = (attention_output, attention_probs) if output_attentions else (attention_output,) + return outputs + + +class TFLxmertLayer(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.attention = TFLxmertSelfAttentionLayer(config, name="attention") + self.intermediate = TFLxmertIntermediate(config, name="intermediate") + self.transformer_output = TFLxmertOutput(config, name="output") + + def call(self, hidden_states, attention_mask, output_attentions, training=False): + attention_outputs = self.attention(hidden_states, attention_mask, output_attentions, training=training) + attention_output = attention_outputs[0] + intermediate_output = self.intermediate(attention_output) + layer_output = self.transformer_output(intermediate_output, attention_output, training=training) + outputs = (layer_output,) + attention_outputs[1:] # add attentions if we output them + return outputs + + +class TFLxmertXLayer(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.visual_attention = TFLxmertCrossAttentionLayer(config, name="visual_attention") + + # Self-attention Layers + self.lang_self_att = TFLxmertSelfAttentionLayer(config, name="lang_self_att") + self.visn_self_att = TFLxmertSelfAttentionLayer(config, name="visn_self_att") + + # Intermediate and Output Layers (FFNs) + self.lang_inter = TFLxmertIntermediate(config, name="lang_inter") + self.lang_output = TFLxmertOutput(config, name="lang_output") + self.visn_inter = TFLxmertIntermediate(config, name="visn_inter") + self.visn_output = TFLxmertOutput(config, name="visn_output") + + def cross_att( + self, + lang_input, + lang_attention_mask, + visn_input, + visn_attention_mask, + output_attentions, + training=False, + ): + # Cross Attention + + # Keras saving and loading model *does not work* with the same inputs for two layers. + lang_attention_lang_input = tf.identity(lang_input) + visn_attention_lang_input = tf.identity(lang_input) + lang_attention_visn_input = tf.identity(visn_input) + visn_attention_visn_input = tf.identity(visn_input) + + lang_att_output = self.visual_attention( + lang_attention_lang_input, + lang_attention_visn_input, + visn_attention_mask, + output_attentions=output_attentions, + training=training, + ) + visn_att_output = self.visual_attention( + visn_attention_visn_input, + visn_attention_lang_input, + lang_attention_mask, + output_attentions=output_attentions, + training=training, + ) + return lang_att_output, visn_att_output + + def self_att( + self, + lang_input, + lang_attention_mask, + visn_input, + visn_attention_mask, + training=False, + ): + # Self Attention + output_attentions = False + lang_att_output = self.lang_self_att(lang_input, lang_attention_mask, output_attentions, training=training) + visn_att_output = self.visn_self_att(visn_input, visn_attention_mask, output_attentions, training=training) + return lang_att_output[0], visn_att_output[0] + + def output_fc(self, lang_input, visn_input, training=False): + # FC layers + lang_inter_output = self.lang_inter(lang_input) + visn_inter_output = self.visn_inter(visn_input) + + # Layer output + lang_output = self.lang_output(lang_inter_output, lang_input, training) + visn_output = self.visn_output(visn_inter_output, visn_input, training) + return lang_output, visn_output + + def call( + self, + lang_feats, + lang_attention_mask, + visn_feats, + visn_attention_mask, + output_attentions, + training=False, + ): + lang_att_output = lang_feats + visn_att_output = visn_feats + + lang_att_output, visn_att_output = self.cross_att( + lang_att_output, + lang_attention_mask, + visn_att_output, + visn_attention_mask, + output_attentions, + training=training, + ) + attention_probs = lang_att_output[1:] + lang_att_output, visn_att_output = self.self_att( + lang_att_output[0], + lang_attention_mask, + visn_att_output[0], + visn_attention_mask, + training=training, + ) + lang_output, visn_output = self.output_fc(lang_att_output, visn_att_output, training=training) + + return (lang_output, visn_output, attention_probs[0]) if output_attentions else (lang_output, visn_output) + + +class TFLxmertEncoder(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + + self.visn_fc = TFLxmertVisualFeatureEncoder(config, name="visn_fc") + + # Number of layers + self.num_l_layers = config.l_layers + self.num_x_layers = config.x_layers + self.num_r_layers = config.r_layers + + # Layers + # Using self.layer instead of self.l_layer to support loading BERT weights. + self.layer = [TFLxmertLayer(config, name="layer_._{}".format(i)) for i in range(self.num_l_layers)] + self.x_layers = [TFLxmertXLayer(config, name="x_layers_._{}".format(i)) for i in range(self.num_x_layers)] + self.r_layers = [TFLxmertLayer(config, name="r_layers_._{}".format(i)) for i in range(self.num_r_layers)] + self.config = config + + def call( + self, + lang_feats=None, + lang_attention_mask=None, + visual_feats=None, + visual_pos=None, + visual_attention_mask=None, + output_attentions=None, + training=False, + ): + vision_hidden_states = () + language_hidden_states = () + vision_attentions = () if output_attentions or self.config.output_attentions else None + language_attentions = () if output_attentions or self.config.output_attentions else None + cross_encoder_attentions = () if output_attentions or self.config.output_attentions else None + + visual_feats = self.visn_fc([visual_feats, visual_pos], training=training) + + # Run language layers + for layer_module in self.layer: + l_outputs = layer_module(lang_feats, lang_attention_mask, output_attentions, training=training) + lang_feats = l_outputs[0] + language_hidden_states = language_hidden_states + (lang_feats,) + if language_attentions is not None: + language_attentions = language_attentions + (l_outputs[1],) + + # Run relational layers + for layer_module in self.r_layers: + v_outputs = layer_module( + visual_feats, + visual_attention_mask, + output_attentions, + training=training, + ) + visual_feats = v_outputs[0] + vision_hidden_states = vision_hidden_states + (visual_feats,) + if vision_attentions is not None: + vision_attentions = vision_attentions + (v_outputs[1],) + + # Run cross-modality layers + for layer_module in self.x_layers: + x_outputs = layer_module( + lang_feats, + lang_attention_mask, + visual_feats, + visual_attention_mask, + output_attentions, + training=training, + ) + lang_feats, visual_feats = x_outputs[:2] + vision_hidden_states = vision_hidden_states + (visual_feats,) + language_hidden_states = language_hidden_states + (lang_feats,) + if cross_encoder_attentions is not None: + cross_encoder_attentions = cross_encoder_attentions + (x_outputs[2],) + + visual_encoder_outputs = ( + vision_hidden_states, + vision_attentions if output_attentions else None, + ) + lang_encoder_outputs = ( + language_hidden_states, + language_attentions if output_attentions else None, + ) + + return ( + visual_encoder_outputs, + lang_encoder_outputs, + cross_encoder_attentions if output_attentions else None, + ) + + +@keras_serializable +class TFLxmertMainLayer(tf.keras.layers.Layer): + config_class = LxmertConfig + + @property + def dummy_inputs(self): + """Dummy inputs to build the network. + + Returns: + tf.Tensor with dummy inputs + """ + batch_size = 2 + num_visual_features = 10 + input_ids = tf.constant([[3, 5, 6], [2, 3, 4]]) + visual_feats = tf.random.uniform((batch_size, num_visual_features, self.config.visual_feat_dim)) + visual_pos = tf.random.uniform((batch_size, num_visual_features, 4)) + + return { + "input_ids": input_ids, + "visual_feats": visual_feats, + "visual_pos": visual_pos, + } + + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.num_l_layers = config.l_layers + self.num_x_layers = config.x_layers + self.num_r_layers = config.r_layers + self.initializer_range = config.initializer_range + self.output_attentions = config.output_attentions + self.output_hidden_states = config.output_hidden_states + self.return_dict = config.use_return_dict + self.embeddings = TFLxmertEmbeddings(config, name="embeddings") + self.encoder = TFLxmertEncoder(config, name="encoder") + self.pooler = TFLxmertPooler(config, name="pooler") + self.config = config + + def get_input_embeddings(self): + return self.embeddings + + def set_input_embeddings(self, value): + self.embeddings.word_embeddings = value + self.embeddings.vocab_size = value.shape[0] + + def _resize_token_embeddings(self, new_num_tokens): + raise NotImplementedError + + def _prune_heads(self, heads_to_prune): + raise NotImplementedError + + def call( + self, + inputs, + visual_feats=None, + visual_pos=None, + attention_mask=None, + visual_attention_mask=None, + token_type_ids=None, + inputs_embeds=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + training=False, + ): + if isinstance(inputs, (tuple, list)): + input_ids = inputs[0] + visual_feats = inputs[1] if len(inputs) > 1 else visual_feats + visual_pos = inputs[2] if len(inputs) > 2 else visual_pos + attention_mask = inputs[3] if len(inputs) > 3 else attention_mask + visual_attention_mask = inputs[4] if len(inputs) > 4 else visual_attention_mask + token_type_ids = inputs[5] if len(inputs) > 5 else token_type_ids + inputs_embeds = inputs[6] if len(inputs) > 6 else inputs_embeds + output_attentions = inputs[7] if len(inputs) > 7 else output_attentions + output_hidden_states = inputs[8] if len(inputs) > 8 else output_hidden_states + return_dict = inputs[9] if len(inputs) > 9 else return_dict + assert len(inputs) <= 10, "Too many inputs." + elif isinstance(inputs, dict): + input_ids = inputs.get("input_ids") + visual_feats = inputs.get("visual_feats", visual_feats) + visual_pos = inputs.get("visual_pos", visual_pos) + attention_mask = inputs.get("attention_mask", attention_mask) + visual_attention_mask = inputs.get("visual_attention_mask", visual_attention_mask) + token_type_ids = inputs.get("token_type_ids", token_type_ids) + inputs_embeds = inputs.get("inputs_embeds", inputs_embeds) + output_attentions = inputs.get("output_attentions", output_attentions) + output_hidden_states = inputs.get("output_hidden_states", output_hidden_states) + return_dict = inputs.get("return_dict", return_dict) + assert len(inputs) <= 10, "Too many inputs." + else: + input_ids = inputs + + output_attentions = output_attentions if output_attentions is not None else self.output_attentions + output_hidden_states = output_hidden_states if output_hidden_states is not None else self.output_hidden_states + return_dict = return_dict if return_dict is not None else self.return_dict + + if input_ids is not None and inputs_embeds is not None: + raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time") + elif input_ids is not None: + input_shape = shape_list(input_ids) + elif inputs_embeds is not None: + input_shape = shape_list(inputs_embeds)[:-1] + else: + raise ValueError("You have to specify either input_ids or inputs_embeds") + if visual_pos is None or visual_feats is None: + raise ValueError("visual_feats and visual_pos cannot be `None` in LXMERT's `call` method.") + + if attention_mask is None: + attention_mask = tf.fill(input_shape, 1) + if token_type_ids is None: + token_type_ids = tf.fill(input_shape, 0) + + # We create a 3D attention mask from a 2D tensor mask. + # Sizes are [batch_size, 1, 1, to_seq_length] + # So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length] + # this attention mask is more simple than the triangular masking of causal attention + # used in OpenAI GPT, we just need to prepare the broadcast dimension here. + extended_attention_mask = attention_mask[:, tf.newaxis, tf.newaxis, :] + + # Since attention_mask is 1.0 for positions we want to attend and 0.0 for + # masked positions, this operation will create a tensor which is 0.0 for + # positions we want to attend and -10000.0 for masked positions. + # Since we are adding it to the raw scores before the softmax, this is + # effectively the same as removing these entirely. + + extended_attention_mask = tf.cast(extended_attention_mask, tf.float32) + extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0 + + if visual_attention_mask is not None: + extended_visual_attention_mask = visual_attention_mask[:, tf.newaxis, tf.newaxis, :] + + extended_visual_attention_mask = tf.cast(extended_visual_attention_mask, tf.float32) + extended_visual_attention_mask = (1.0 - extended_visual_attention_mask) * -10000.0 + else: + extended_visual_attention_mask = None + + # Positional Word Embeddings + embedding_output = self.embeddings([input_ids, token_type_ids, inputs_embeds], training=training) + + # Run Lxmert encoder + encoder_outputs = self.encoder( + embedding_output, + extended_attention_mask, + visual_feats, + visual_pos, + extended_visual_attention_mask, + output_attentions=output_attentions, + training=training, + ) + visual_encoder_outputs, lang_encoder_outputs = encoder_outputs[:2] + vision_hidden_states = visual_encoder_outputs[0] + language_hidden_states = lang_encoder_outputs[0] + + all_attentions = () + if output_attentions: + language_attentions = lang_encoder_outputs[1] + vision_attentions = visual_encoder_outputs[1] + cross_encoder_attentions = encoder_outputs[2] + all_attentions = ( + language_attentions, + vision_attentions, + cross_encoder_attentions, + ) + + hidden_states = (language_hidden_states, vision_hidden_states) if output_hidden_states else () + + visual_output = vision_hidden_states[-1] + lang_output = language_hidden_states[-1] + pooled_output = self.pooler(lang_output) + + if not return_dict: + return (lang_output, visual_output, pooled_output) + hidden_states + all_attentions + + return TFLxmertModelOutput( + pooled_output=pooled_output, + language_output=lang_output, + vision_output=visual_output, + language_hidden_states=language_hidden_states if output_hidden_states else None, + vision_hidden_states=vision_hidden_states if output_hidden_states else None, + language_attentions=language_attentions if output_attentions else None, + vision_attentions=vision_attentions if output_attentions else None, + cross_encoder_attentions=cross_encoder_attentions if output_attentions else None, + ) + + +class TFLxmertPreTrainedModel(TFPreTrainedModel): + """An abstract class to handle weights initialization and + a simple interface for downloading and loading pretrained models. + """ + + config_class = LxmertConfig + base_model_prefix = "lxmert" + + @property + def dummy_inputs(self) -> Dict[str, tf.Tensor]: + return getattr(self, self.base_model_prefix).dummy_inputs + + +LXMERT_START_DOCSTRING = r""" + The LXMERT model was proposed in `LXMERT: Learning Cross-Modality Encoder Representations from Transformers `__ + by Hao Tan and Mohit Bansal. It's a vision and language transformer model, + pre-trained on a variety of multi-modal datasets comprising of GQA, VQAv2.0, MCSCOCO captions, and Visual genome, + using a combination of masked language modeling, region of interest feature regression, + cross entropy loss for question answering attribute prediction, and object tag predicition. + + This model is a `tf.keras.Model `__ sub-class. + Use it as a regular TF 2.0 Keras Model and + refer to the TF 2.0 documentation for all matter related to general usage and behavior. + + Note on the model inputs: + TF 2.0 models accepts two formats as inputs: + + - having all inputs as keyword arguments (like PyTorch models), or + - having all inputs as a list, tuple or dict in the first positional arguments. + + This second option is useful when using :obj:`tf.keras.Model.fit()` method which currently requires having + all the tensors in the first argument of the model call function: :obj:`model(inputs)`. + + If you choose this second option, there are three possibilities you can use to gather all the input Tensors + in the first positional argument : + + - a single Tensor with input_ids only and nothing else: :obj:`model(inputs_ids)` + - a list of varying length with one or several input Tensors IN THE ORDER given in the docstring: + :obj:`model([input_ids, attention_mask])` or :obj:`model([input_ids, attention_mask, token_type_ids])` + - a dictionary with one or several input Tensors associated to the input names given in the docstring: + :obj:`model({'input_ids': input_ids, 'token_type_ids': token_type_ids})` + + Parameters: + config (:class:`~transformers.LxmertConfig`): Model configuration class with all the parameters of the model. + Initializing with a config file does not load the weights associated with the model, only the configuration. + Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model weights. +""" + +LXMERT_INPUTS_DOCSTRING = r""" + Args: + input_ids (:obj:`np.ndarray` or :obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length)`): + Indices of input sequence tokens in the vocabulary. + + Indices can be obtained using :class:`transformers.LxmertTokenizer`. + See :func:`transformers.PreTrainedTokenizer.encode` and + :func:`transformers.PreTrainedTokenizer.__call__` for details. + + `What are input IDs? <../glossary.html#input-ids>`__ + attention_mask (:obj:`tf.Tensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): + Mask to avoid performing attention on padding token indices. + Mask values selected in ``[0, 1]``: + ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens. + + `What are attention masks? <../glossary.html#attention-mask>`__ + token_type_ids (:obj:`tf.Tensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): + Segment token indices to indicate first and second portions of the inputs. + Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1`` + corresponds to a `sentence B` token + + `What are token type IDs? <../glossary.html#token-type-ids>`_ + visual_feats: (:obj:`tf.Tensor` of shape :obj:՝(batch_size, num_visual_features, visual_feat_dim)՝): + This input represents visual features. They ROI pooled object features from bounding boxes using a faster-RCNN model) + These are currently not provided by the transformers library + visual_attention_mask (:obj:`tf.Tensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): + Mask to avoid performing attention on padding token indices. + Mask values selected in ``[0, 1]``: + ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens. + + `What are attention masks? <../glossary.html#attention-mask>`__ +""" + + +@add_start_docstrings( + "The bare Lxmert Model transformer outputing raw hidden-states without any specific head on top.", + LXMERT_START_DOCSTRING, +) +class TFLxmertModel(TFLxmertPreTrainedModel): + def __init__(self, config, *inputs, **kwargs): + super().__init__(config, *inputs, **kwargs) + self.lxmert = TFLxmertMainLayer(config, name="lxmert") + + @add_start_docstrings_to_callable(LXMERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)")) + @add_code_sample_docstrings( + tokenizer_class=_TOKENIZER_FOR_DOC, + checkpoint="unc-nlp/lxmert-base-uncased", + output_type=TFLxmertModelOutput, + config_class=_CONFIG_FOR_DOC, + ) + def call(self, inputs, *args, **kwargs): + outputs = self.lxmert(inputs, *args, **kwargs) + return outputs + + +class TFLxmertPooler(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.dense = tf.keras.layers.Dense( + config.hidden_size, + kernel_initializer=get_initializer(config.initializer_range), + activation="tanh", + name="dense", + ) + + def call(self, hidden_states): + # We "pool" the model by simply taking the hidden state corresponding + # to the first token. + first_token_tensor = hidden_states[:, 0] + pooled_output = self.dense(first_token_tensor) + return pooled_output + + +class TFLxmertPredictionHeadTransform(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.dense = tf.keras.layers.Dense( + config.hidden_size, + kernel_initializer=get_initializer(config.initializer_range), + name="dense", + ) + if isinstance(config.hidden_act, str): + self.transform_act_fn = ACT2FN[config.hidden_act] + else: + self.transform_act_fn = config.hidden_act + self.LayerNorm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name="LayerNorm") + + def call(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.transform_act_fn(hidden_states) + hidden_states = self.LayerNorm(hidden_states) + return hidden_states + + +class TFLxmertLMPredictionHead(tf.keras.layers.Layer): + def __init__(self, config, input_embeddings, **kwargs): + super().__init__(**kwargs) + self.vocab_size = config.vocab_size + self.transform = TFLxmertPredictionHeadTransform(config, name="transform") + + # The output weights are the same as the input embeddings, but there is + # an output-only bias for each token. + self.input_embeddings = input_embeddings + + def build(self, input_shape): + self.bias = self.add_weight(shape=(self.vocab_size,), initializer="zeros", trainable=True, name="bias") + super().build(input_shape) + + def call(self, hidden_states): + hidden_states = self.transform(hidden_states) + hidden_states = self.input_embeddings(hidden_states, mode="linear") + hidden_states = hidden_states + self.bias + return hidden_states + + +class TFLxmertMLMHead(tf.keras.layers.Layer): + def __init__(self, config, input_embeddings, **kwargs): + super().__init__(**kwargs) + + self.predictions = TFLxmertLMPredictionHead(config, input_embeddings, name="predictions") + + def call(self, sequence_output): + prediction_scores = self.predictions(sequence_output) + return prediction_scores + + +class TFLxmertPreTrainingHeads(tf.keras.layers.Layer): + def __init__(self, config, input_embeddings, **kwargs): + super().__init__(**kwargs) + self.predictions = TFLxmertLMPredictionHead(config, input_embeddings, name="predictions") + + self.seq_relationship = tf.keras.layers.Dense( + 2, + kernel_initializer=get_initializer(config.initializer_range), + name="seq_relationship", + ) + + def call(self, sequence_output, pooled_output): + prediction_scores = self.predictions(sequence_output) + seq_relationship_score = self.seq_relationship(pooled_output) + return prediction_scores, seq_relationship_score + + +class TFLxmertVisualAnswerHead(tf.keras.layers.Layer): + def __init__(self, config, num_labels, **kwargs): + super().__init__(**kwargs) + hid_dim = config.hidden_size + self.dense = tf.keras.layers.Dense( + hid_dim * 2, + kernel_initializer=get_initializer(config.initializer_range), + name="logit_fc_._0", + ) + self.activation = tf.keras.layers.Activation(gelu) + self.layer_norm = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_eps, name="logit_fc_._2") + self.dense_1 = tf.keras.layers.Dense( + num_labels, + kernel_initializer=get_initializer(config.initializer_range), + name="logit_fc_._3", + ) + + def call(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.activation(hidden_states) + hidden_states = self.layer_norm(hidden_states) + hidden_states = self.dense_1(hidden_states) + + return hidden_states + + +class TFLxmertVisualObjHead(tf.keras.layers.Layer): + def __init__(self, config, **kwargs): + super().__init__(**kwargs) + self.transform = TFLxmertPredictionHeadTransform(config, name="transform") + + # Decide the use of visual losses + visual_losses = {} + if config.visual_obj_loss: + visual_losses["obj"] = {"shape": (-1,), "num": config.num_object_labels} + if config.visual_attr_loss: + visual_losses["attr"] = {"shape": (-1,), "num": config.num_attr_labels} + if config.visual_obj_loss: + visual_losses["feat"] = {"shape": (-1, 2048), "num": config.visual_feat_dim} + self.visual_losses = visual_losses + + # The output weights are the same as the input embeddings, but there is + # an output-only bias for each token. + self.decoder_dict = { + key: tf.keras.layers.Dense( + self.visual_losses[key]["num"], + kernel_initializer=get_initializer(config.initializer_range), + name=f"decoder_dict.{key}", + ) + for key in self.visual_losses + } + + def call(self, hidden_states): + hidden_states = self.transform(hidden_states) + output = {} + for key in self.visual_losses: + output[key] = self.decoder_dict[key](hidden_states) + return output + + +@add_start_docstrings("""Lxmert Model with a `language modeling` head on top. """, LXMERT_START_DOCSTRING) +class TFLxmertForPreTraining(TFLxmertPreTrainedModel): + def __init__(self, config, *inputs, **kwargs): + super().__init__(config, *inputs, **kwargs) + + self.config = config + self.num_qa_labels = config.num_qa_labels + self.visual_loss_normalizer = config.visual_loss_normalizer + + # Use of pre-training tasks + self.task_mask_lm = config.task_mask_lm + self.task_obj_predict = config.task_obj_predict + self.task_matched = config.task_matched + self.task_qa = config.task_qa + + # Lxmert backbone + self.lxmert = TFLxmertMainLayer(config, name="lxmert") + + # Pre-training heads + self.cls = TFLxmertPreTrainingHeads(config, self.lxmert.embeddings, name="cls") + if self.task_obj_predict: + self.obj_predict_head = TFLxmertVisualObjHead(config, name="obj_predict_head") + if self.task_qa: + self.answer_head = TFLxmertVisualAnswerHead(config, self.num_qa_labels, name="answer_head") + + # Loss functions + self.loss_fcts = { + "l2": tf.keras.losses.Huber(delta=1.0, name="huber_loss"), + "visn_ce": tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), + "ce": tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), + } + + visual_losses = {} + if config.visual_obj_loss: + visual_losses["obj"] = { + "shape": (-1,), + "num": config.num_object_labels, + "loss": "visn_ce", + } + if config.visual_attr_loss: + visual_losses["attr"] = { + "shape": (-1,), + "num": config.num_attr_labels, + "loss": "visn_ce", + } + if config.visual_obj_loss: + visual_losses["feat"] = { + "shape": (-1, config.visual_feat_dim), + "num": config.visual_feat_dim, + "loss": "l2", + } + self.visual_losses = visual_losses + + @property + def dummy_inputs(self): + """Dummy inputs to build the network. + + Returns: + tf.Tensor with dummy inputs + """ + batch_size = 2 + num_visual_features = 10 + input_ids = tf.constant([[3, 5, 6], [2, 3, 4]]) + visual_feats = tf.random.uniform((batch_size, num_visual_features, self.config.visual_feat_dim)) + visual_pos = tf.random.uniform((batch_size, num_visual_features, 4)) + + if self.config.task_obj_predict: + obj_labels = {} + if self.config.visual_attr_loss and self.config.task_obj_predict: + obj_labels["attr"] = ( + tf.ones([batch_size, num_visual_features]), + tf.ones([batch_size, num_visual_features]), + ) + if self.config.visual_feat_loss and self.config.task_obj_predict: + obj_labels["feat"] = ( + tf.ones([batch_size, num_visual_features, self.config.visual_feat_dim]), + tf.ones([batch_size, num_visual_features]), + ) + if self.config.visual_obj_loss and self.config.task_obj_predict: + obj_labels["obj"] = ( + tf.ones([batch_size, num_visual_features]), + tf.ones([batch_size, num_visual_features]), + ) + + return { + **{ + "input_ids": input_ids, + "visual_feats": visual_feats, + "visual_pos": visual_pos, + }, + **({"obj_labels": obj_labels} if self.config.task_obj_predict else {}), + } + + @add_start_docstrings_to_callable(LXMERT_INPUTS_DOCSTRING.format("(batch_size, sequence_length)")) + @replace_return_docstrings(output_type=TFLxmertForPreTrainingOutput, config_class=_CONFIG_FOR_DOC) + def call( + self, + inputs=None, + visual_feats=None, + visual_pos=None, + attention_mask=None, + visual_attention_mask=None, + token_type_ids=None, + inputs_embeds=None, + masked_lm_labels=None, + obj_labels=None, + matched_label=None, + ans=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + ): + r""" + masked_lm_labels (``tf.Tensor`` of shape ``(batch_size, sequence_length)``, `optional`, defaults to :obj:`None`): + Labels for computing the masked language modeling loss. + Indices should be in ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring) + Tokens with indices set to ``-100`` are ignored (masked), the loss is only computed for the tokens with labels + in ``[0, ..., config.vocab_size]`` + obj_labels: (``Dict[Str: Tuple[tf.Tensor, tf.Tensor]]``, `optional`, defaults to :obj: `None`): + each key is named after each one of the visual losses and each element of the tuple is of the shape + ``(batch_size, num_features)`` and ``(batch_size, num_features, visual_feature_dim)`` + for each the label id and the label score respectively + matched_label (``tf.Tensor`` of shape ``(batch_size,)``, `optional`, defaults to :obj:`None`): + Labels for computing the whether or not the text input matches the image (classification) loss. Input should be a sequence pair (see :obj:`input_ids` docstring) + Indices should be in ``[0, 1]``. + ``0`` indicates that the sentence does not match the image + ``1`` indicates that the sentence does match the image + ans: (``Torch.Tensor`` of shape ``(batch_size)``, `optional`, defaults to :obj: `None`): + a one hot representation hof the correct answer `optional` + + Returns: + """ + if isinstance(inputs, (tuple, list)): + masked_lm_labels = inputs[7] if len(inputs) > 7 else masked_lm_labels + obj_labels = inputs[8] if len(inputs) > 8 else obj_labels + matched_label = inputs[9] if len(inputs) > 9 else matched_label + ans = inputs[10] if len(inputs) > 10 else ans + if len(inputs) > 10: + inputs = inputs[:10] + elif isinstance(inputs, (dict, BatchEncoding)): + masked_lm_labels = inputs.pop("masked_lm_labels", masked_lm_labels) + obj_labels = inputs.pop("obj_labels", obj_labels) + matched_label = inputs.pop("matched_label", matched_label) + ans = inputs.pop("ans", ans) + + lxmert_output = self.lxmert( + inputs, + visual_feats=visual_feats, + visual_pos=visual_pos, + attention_mask=attention_mask, + visual_attention_mask=visual_attention_mask, + token_type_ids=token_type_ids, + inputs_embeds=inputs_embeds, + output_hidden_states=output_hidden_states, + output_attentions=output_attentions, + return_dict=return_dict, + ) + + lang_output, visual_output, pooled_output = ( + lxmert_output[0], + lxmert_output[1], + lxmert_output[2], + ) + lang_prediction_scores, cross_relationship_score = self.cls(lang_output, pooled_output) + if self.task_qa: + answer_score = self.answer_head(pooled_output) + else: + answer_score = pooled_output[0][0] + + total_loss = ( + None + if (masked_lm_labels is None and matched_label is None and obj_labels is None and ans is None) + else tf.constant(0.0) + ) + losses = () + if masked_lm_labels is not None and self.task_mask_lm: + masked_lm_loss = self.loss_fcts["ce"]( + tf.reshape(masked_lm_labels, [-1]), + tf.reshape(lang_prediction_scores, [-1, self.config.vocab_size]), + ) + total_loss += masked_lm_loss + losses += (masked_lm_loss,) + if matched_label is not None and self.task_matched: + matched_loss = self.loss_fcts["ce"]( + tf.reshape(matched_label, [-1]), + tf.reshape(cross_relationship_score, [-1, 2]), + ) + total_loss += matched_loss + losses += (matched_loss,) + if obj_labels is not None and self.task_obj_predict: + total_visn_loss = 0.0 + visn_prediction_scores_dict = self.obj_predict_head(visual_output) + for key, key_info in self.visual_losses.items(): + label, mask_conf = obj_labels[key] + output_dim = key_info["num"] + loss_fct_name = key_info["loss"] + label_shape = key_info["shape"] + weight = self.visual_loss_normalizer + visn_loss_fct = self.loss_fcts[loss_fct_name] + visn_prediction_scores = visn_prediction_scores_dict[key] + visn_loss = visn_loss_fct( + tf.reshape(label, label_shape), + tf.reshape(visn_prediction_scores, [-1, output_dim]), + ) + + if visn_loss.ndim > 1: # Regression Losses + visn_loss = tf.reduce_mean(visn_loss) + visn_loss = tf.reduce_mean(visn_loss * tf.cast(tf.reshape(mask_conf, [-1]), visn_loss.dtype)) * weight + total_visn_loss += visn_loss + losses += (visn_loss,) + total_loss += total_visn_loss + if ans is not None and self.task_qa: + answer_loss = self.loss_fcts["ce"]( + tf.reshape(ans, [-1]), tf.reshape(answer_score, [-1, self.num_qa_labels]) + ) + # exclude "*2" here to match the effect of QA losses. + # Previous: (loss *0) for 6 epochs, (loss *2) for 6 epochs. (Used 10 instead of 6 in EMNLP paper) + # Now : (loss *1) for 12 epochs + # + # * 2 # Multiply by 2 because > half of the data will not have label + total_loss += answer_loss + losses += (answer_loss,) + # return total_loss, tf.stack(losses)[tf.new_axis, ...], answer_score.detach() + + if not return_dict: + output = ( + lang_prediction_scores, + cross_relationship_score, + answer_score, + ) + lxmert_output[3:] + return ((total_loss,) + output) if total_loss is not None else output + + return TFLxmertForPreTrainingOutput( + loss=total_loss, + prediction_logits=lang_prediction_scores, + cross_relationship_score=cross_relationship_score, + question_answering_score=answer_score, + language_hidden_states=lxmert_output.language_hidden_states, + vision_hidden_states=lxmert_output.vision_hidden_states, + language_attentions=lxmert_output.language_attentions, + vision_attentions=lxmert_output.vision_attentions, + cross_encoder_attentions=lxmert_output.cross_encoder_attentions, + ) diff --git a/src/transformers/modeling_tf_mobilebert.py b/src/transformers/modeling_tf_mobilebert.py index 67681be039..f9001d5867 100644 --- a/src/transformers/modeling_tf_mobilebert.py +++ b/src/transformers/modeling_tf_mobilebert.py @@ -883,7 +883,7 @@ MOBILEBERT_START_DOCSTRING = r""" MOBILEBERT_INPUTS_DOCSTRING = r""" Args: - input_ids (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`{0}`): + input_ids (:obj:`np.ndarray` or :obj:`tf.Tensor` of shape :obj:`{0}`): Indices of input sequence tokens in the vocabulary. Indices can be obtained using :class:`transformers.MobileBertTokenizer`. @@ -891,28 +891,28 @@ MOBILEBERT_INPUTS_DOCSTRING = r""" :func:`transformers.PreTrainedTokenizer.__call__` for details. `What are input IDs? <../glossary.html#input-ids>`__ - attention_mask (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): + attention_mask (:obj:`np.ndarray` or :obj:`tf.Tensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): Mask to avoid performing attention on padding token indices. Mask values selected in ``[0, 1]``: ``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens. `What are attention masks? <../glossary.html#attention-mask>`__ - token_type_ids (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): + token_type_ids (:obj:`np.ndarray` or :obj:`tf.Tensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): Segment token indices to indicate first and second portions of the inputs. Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1`` corresponds to a `sentence B` token `What are token type IDs? <../glossary.html#token-type-ids>`__ - position_ids (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): + position_ids (:obj:`np.ndarray` or :obj:`tf.Tensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`): Indices of positions of each input sequence tokens in the position embeddings. Selected in the range ``[0, config.max_position_embeddings - 1]``. `What are position IDs? <../glossary.html#position-ids>`__ - head_mask (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`, defaults to :obj:`None`): + head_mask (:obj:`np.ndarray` or :obj:`tf.Tensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`, defaults to :obj:`None`): Mask to nullify selected heads of the self-attention modules. Mask values selected in ``[0, 1]``: :obj:`1` indicates the head is **not masked**, :obj:`0` indicates the head is **masked**. - inputs_embeds (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, embedding_dim)`, `optional`, defaults to :obj:`None`): + inputs_embeds (:obj:`np.ndarray` or :obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length, embedding_dim)`, `optional`, defaults to :obj:`None`): Optionally, instead of passing :obj:`input_ids` you can to directly pass an embedded representation. This is useful if you want more control over how to convert `input_ids` indices into associated vectors than the model's internal embedding lookup matrix. diff --git a/src/transformers/modeling_tf_utils.py b/src/transformers/modeling_tf_utils.py index 4db9b4f47d..4ec504810e 100644 --- a/src/transformers/modeling_tf_utils.py +++ b/src/transformers/modeling_tf_utils.py @@ -191,7 +191,7 @@ class TFSequenceClassificationLoss: """ def compute_loss(self, labels, logits): - if shape_list(logits)[1] == 1: + if len(shape_list(logits)) == 1 or shape_list(logits)[1] == 1: loss_fn = tf.keras.losses.MeanSquaredError(reduction=tf.keras.losses.Reduction.NONE) else: loss_fn = tf.keras.losses.SparseCategoricalCrossentropy( diff --git a/src/transformers/tokenization_auto.py b/src/transformers/tokenization_auto.py index f35b445287..626e576759 100644 --- a/src/transformers/tokenization_auto.py +++ b/src/transformers/tokenization_auto.py @@ -29,6 +29,7 @@ from .configuration_auto import ( FlaubertConfig, GPT2Config, LongformerConfig, + LxmertConfig, MarianConfig, MBartConfig, MobileBertConfig, @@ -55,6 +56,7 @@ from .tokenization_electra import ElectraTokenizer, ElectraTokenizerFast from .tokenization_flaubert import FlaubertTokenizer from .tokenization_gpt2 import GPT2Tokenizer, GPT2TokenizerFast from .tokenization_longformer import LongformerTokenizer, LongformerTokenizerFast +from .tokenization_lxmert import LxmertTokenizer, LxmertTokenizerFast from .tokenization_marian import MarianTokenizer from .tokenization_mbart import MBartTokenizer from .tokenization_mobilebert import MobileBertTokenizer, MobileBertTokenizerFast @@ -91,6 +93,7 @@ TOKENIZER_MAPPING = OrderedDict( (RobertaConfig, (RobertaTokenizer, RobertaTokenizerFast)), (ReformerConfig, (ReformerTokenizer, None)), (ElectraConfig, (ElectraTokenizer, ElectraTokenizerFast)), + (LxmertConfig, (LxmertTokenizer, LxmertTokenizerFast)), (BertConfig, (BertTokenizer, BertTokenizerFast)), (OpenAIGPTConfig, (OpenAIGPTTokenizer, OpenAIGPTTokenizerFast)), (GPT2Config, (GPT2Tokenizer, GPT2TokenizerFast)), @@ -128,6 +131,7 @@ class AutoTokenizer: - `xlm`: XLMTokenizer (XLM model) - `ctrl`: CTRLTokenizer (Salesforce CTRL model) - `electra`: ElectraTokenizer (Google ELECTRA model) + - `lxmert`: LxmertTokenizer (Lxmert model) This class cannot be instantiated using `__init__()` (throw an error). """ @@ -163,6 +167,7 @@ class AutoTokenizer: - `xlm`: XLMTokenizer (XLM model) - `ctrl`: CTRLTokenizer (Salesforce CTRL model) - `electra`: ElectraTokenizer (Google ELECTRA model) + - `lxmert`: LxmertTokenizer (Lxmert model) Params: pretrained_model_name_or_path: either: diff --git a/src/transformers/tokenization_lxmert.py b/src/transformers/tokenization_lxmert.py new file mode 100644 index 0000000000..316d43f95b --- /dev/null +++ b/src/transformers/tokenization_lxmert.py @@ -0,0 +1,80 @@ +# coding=utf-8 +# Copyright 2020 The Google AI Team, Stanford University and The HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .tokenization_bert import BertTokenizer, BertTokenizerFast + + +#################################################### +# Mapping from the keyword arguments names of Tokenizer `__init__` +# to file names for serializing Tokenizer instances +#################################################### +VOCAB_FILES_NAMES = {"vocab_file": "vocab.txt"} + +#################################################### +# Mapping from the keyword arguments names of Tokenizer `__init__` +# to pretrained vocabulary URL for all the model shortcut names. +#################################################### +PRETRAINED_VOCAB_FILES_MAP = { + "vocab_file": { + "unc-nlp/lxmert-base-uncased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-vocab.txt", + } +} + +#################################################### +# Mapping from model shortcut names to max length of inputs +#################################################### +PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = { + "unc-nlp/lxmert-base-uncased": 512, +} +#################################################### +# Mapping from model shortcut names to a dictionary of additional +# keyword arguments for Tokenizer `__init__`. +# To be used for checkpoint specific configurations. +#################################################### +PRETRAINED_INIT_CONFIGURATION = { + "unc-nlp/lxmert-base-uncased": {"do_lower_case": True}, +} + + +class LxmertTokenizer(BertTokenizer): + r""" + Constructs an Lxmert tokenizer. + :class:`~transformers.LxmertTokenizer` is identical to :class:`~transformers.BertTokenizer` and runs end-to-end + tokenization: punctuation splitting + wordpiece. + + Refer to superclass :class:`~transformers.BertTokenizer` for usage examples and documentation concerning + parameters. + """ + + vocab_files_names = VOCAB_FILES_NAMES + pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP + max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES + pretrained_init_configuration = PRETRAINED_INIT_CONFIGURATION + + +class LxmertTokenizerFast(BertTokenizerFast): + r""" + Constructs a "Fast" Lxmert Fast tokenizer (backed by HuggingFace's `tokenizers` library). + + :class:`~transformers.LxmertTokenizerFast` is identical to :class:`~transformers.BertTokenizerFast` and runs end-to-end + tokenization: punctuation splitting + wordpiece. + + Refer to superclass :class:`~transformers.BertTokenizerFast` for usage examples and documentation concerning + parameters. + """ + vocab_files_names = VOCAB_FILES_NAMES + pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP + max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES + pretrained_init_configuration = PRETRAINED_INIT_CONFIGURATION diff --git a/tests/test_modeling_lxmert.py b/tests/test_modeling_lxmert.py new file mode 100644 index 0000000000..5484f2b71c --- /dev/null +++ b/tests/test_modeling_lxmert.py @@ -0,0 +1,684 @@ +# coding=utf-8 +# Copyright 2018 LXMERT Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import unittest + +from transformers import is_torch_available +from transformers.testing_utils import require_torch, slow, torch_device + +from .test_configuration_common import ConfigTester +from .test_modeling_common import ModelTesterMixin, ids_tensor + + +if is_torch_available(): + import torch + + from transformers import LxmertConfig, LxmertForPreTraining, LxmertForQuestionAnswering, LxmertModel + from transformers.modeling_lxmert import LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST + + +class LxmertModelTester: + """You can also import this e.g from .test_modeling_bart import BartModelTester """ + + def __init__( + self, + parent, + vocab_size=300, + hidden_size=28, + num_attention_heads=2, + num_labels=2, + intermediate_size=64, + hidden_act="gelu", + hidden_dropout_prob=0.1, + attention_probs_dropout_prob=0.1, + max_position_embeddings=512, + type_vocab_size=2, + initializer_range=0.02, + layer_norm_eps=1e-12, + pad_token_id=0, + num_qa_labels=30, + num_object_labels=16, + num_attr_labels=4, + num_visual_features=10, + l_layers=2, + x_layers=1, + r_layers=1, + visual_feat_dim=128, + visual_pos_dim=4, + visual_loss_normalizer=6.67, + seq_length=20, + batch_size=4, + is_training=True, + task_matched=True, + task_mask_lm=True, + task_obj_predict=True, + task_qa=True, + visual_obj_loss=True, + visual_attr_loss=True, + visual_feat_loss=True, + use_token_type_ids=True, + use_lang_mask=True, + output_attentions=False, + output_hidden_states=False, + scope=None, + ): + self.parent = parent + self.vocab_size = vocab_size + self.hidden_size = hidden_size + self.num_attention_heads = num_attention_heads + self.num_labels = num_labels + self.intermediate_size = intermediate_size + self.hidden_act = hidden_act + self.hidden_dropout_prob = hidden_dropout_prob + self.attention_probs_dropout_prob = attention_probs_dropout_prob + self.max_position_embeddings = max_position_embeddings + self.type_vocab_size = type_vocab_size + self.initializer_range = initializer_range + self.layer_norm_eps = layer_norm_eps + self.pad_token_id = pad_token_id + self.num_qa_labels = num_qa_labels + self.num_object_labels = num_object_labels + self.num_attr_labels = num_attr_labels + self.l_layers = l_layers + self.x_layers = x_layers + self.r_layers = r_layers + self.visual_feat_dim = visual_feat_dim + self.visual_pos_dim = visual_pos_dim + self.visual_loss_normalizer = visual_loss_normalizer + self.seq_length = seq_length + self.batch_size = batch_size + self.is_training = is_training + self.use_lang_mask = use_lang_mask + self.task_matched = task_matched + self.task_mask_lm = task_mask_lm + self.task_obj_predict = task_obj_predict + self.task_qa = task_qa + self.visual_obj_loss = visual_obj_loss + self.visual_attr_loss = visual_attr_loss + self.visual_feat_loss = visual_feat_loss + self.num_visual_features = num_visual_features + self.use_token_type_ids = use_token_type_ids + self.output_attentions = output_attentions + self.output_hidden_states = output_hidden_states + self.scope = scope + self.num_hidden_layers = {"vision": r_layers, "cross_encoder": x_layers, "language": l_layers} + + def prepare_config_and_inputs(self): + + output_attentions = self.output_attentions + input_ids = ids_tensor([self.batch_size, self.seq_length], vocab_size=self.vocab_size) + visual_feats = torch.rand(self.batch_size, self.num_visual_features, self.visual_feat_dim) + bounding_boxes = torch.rand(self.batch_size, self.num_visual_features, 4) + + input_mask = None + if self.use_lang_mask: + input_mask = ids_tensor([self.batch_size, self.seq_length], vocab_size=2) + token_type_ids = None + if self.use_token_type_ids: + token_type_ids = ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size) + obj_labels = None + if self.task_obj_predict: + obj_labels = {} + if self.visual_attr_loss and self.task_obj_predict: + obj_labels["attr"] = ( + ids_tensor([self.batch_size, self.num_visual_features], self.num_attr_labels), + ids_tensor([self.batch_size, self.num_visual_features], self.num_attr_labels), + ) + if self.visual_feat_loss and self.task_obj_predict: + obj_labels["feat"] = ( + ids_tensor( + [self.batch_size, self.num_visual_features, self.visual_feat_dim], self.num_visual_features + ), + ids_tensor([self.batch_size, self.num_visual_features], self.num_visual_features), + ) + if self.visual_obj_loss and self.task_obj_predict: + obj_labels["obj"] = ( + ids_tensor([self.batch_size, self.num_visual_features], self.num_object_labels), + ids_tensor([self.batch_size, self.num_visual_features], self.num_object_labels), + ) + ans = None + if self.task_qa: + ans = ids_tensor([self.batch_size], self.num_qa_labels) + masked_lm_labels = None + if self.task_mask_lm: + masked_lm_labels = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) + matched_label = None + if self.task_matched: + matched_label = ids_tensor([self.batch_size], self.num_labels) + + config = LxmertConfig( + vocab_size=self.vocab_size, + hidden_size=self.hidden_size, + num_attention_heads=self.num_attention_heads, + num_labels=self.num_labels, + intermediate_size=self.intermediate_size, + hidden_act=self.hidden_act, + hidden_dropout_prob=self.hidden_dropout_prob, + attention_probs_dropout_prob=self.attention_probs_dropout_prob, + max_position_embeddings=self.max_position_embeddings, + type_vocab_size=self.type_vocab_size, + initializer_range=self.initializer_range, + layer_norm_eps=self.layer_norm_eps, + pad_token_id=self.pad_token_id, + num_qa_labels=self.num_qa_labels, + num_object_labels=self.num_object_labels, + num_attr_labels=self.num_attr_labels, + l_layers=self.l_layers, + x_layers=self.x_layers, + r_layers=self.r_layers, + visual_feat_dim=self.visual_feat_dim, + visual_pos_dim=self.visual_pos_dim, + visual_loss_normalizer=self.visual_loss_normalizer, + task_matched=self.task_matched, + task_mask_lm=self.task_mask_lm, + task_obj_predict=self.task_obj_predict, + task_qa=self.task_qa, + visual_obj_loss=self.visual_obj_loss, + visual_attr_loss=self.visual_attr_loss, + visual_feat_loss=self.visual_feat_loss, + output_attentions=self.output_attentions, + output_hidden_states=self.output_hidden_states, + ) + + return ( + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ) + + def create_and_check_lxmert_model( + self, + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ): + model = LxmertModel(config=config) + model.to(torch_device) + model.eval() + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + output_attentions=output_attentions, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + output_attentions=not output_attentions, + ) + result = model(input_ids, visual_feats, bounding_boxes, return_dict=False) + result = model(input_ids, visual_feats, bounding_boxes, return_dict=True) + + self.parent.assertEqual(result.language_output.shape, (self.batch_size, self.seq_length, self.hidden_size)) + self.parent.assertEqual( + result.vision_output.shape, (self.batch_size, self.num_visual_features, self.hidden_size) + ) + self.parent.assertEqual(result.pooled_output.shape, (self.batch_size, self.hidden_size)) + + def create_and_check_lxmert_for_question_answering( + self, + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ): + model = LxmertForQuestionAnswering(config=config) + model.to(torch_device) + model.eval() + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + labels=ans, + output_attentions=output_attentions, + return_dict=True, + ) + result = model(input_ids, visual_feats, bounding_boxes, labels=ans) + result = model( + input_ids, + visual_feats, + bounding_boxes, + labels=ans, + token_type_ids=token_type_ids, + attention_mask=input_mask, + output_attentions=output_attentions, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + labels=ans, + output_attentions=not output_attentions, + return_dict=True, + ) + + self.parent.assertEqual(result.question_answering_score.shape, (self.batch_size, self.num_qa_labels)) + + def create_and_check_lxmert_for_pretraining( + self, + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ): + model = LxmertForPreTraining(config=config) + model.to(torch_device) + model.eval() + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + masked_lm_labels=masked_lm_labels, + obj_labels=obj_labels, + matched_label=matched_label, + ans=ans, + output_attentions=output_attentions, + return_dict=True, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + masked_lm_labels=masked_lm_labels, + output_attentions=not output_attentions, + return_dict=False, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + masked_lm_labels=masked_lm_labels, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + obj_labels=obj_labels, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + matched_label=matched_label, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + ans=ans, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + masked_lm_labels=masked_lm_labels, + obj_labels=obj_labels, + matched_label=matched_label, + ans=ans, + output_attentions=not output_attentions, + return_dict=True, + ) + + self.parent.assertEqual(result.prediction_logits.shape, (self.batch_size, self.seq_length, self.vocab_size)) + + def resize_lxmert_num_qa_labels( + self, + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ): + + start_labels = config.num_qa_labels + num_large_labels = config.num_qa_labels * 2 + num_small_labels = int(config.num_qa_labels * 2) + less_labels_ans = ids_tensor([self.batch_size], num_small_labels) + more_labels_ans = ids_tensor([self.batch_size], num_large_labels) + model_pretrain = LxmertForPreTraining(config=config) + model_qa = LxmertForQuestionAnswering(config=config) + config.num_labels = num_small_labels + end_labels = config.num_labels + + result_pretrain = model_pretrain( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + ans=ans, + return_dict=True, + ) + + result_qa = model_qa( + input_ids, + visual_feats, + bounding_boxes, + labels=ans, + token_type_ids=token_type_ids, + attention_mask=input_mask, + return_dict=True, + ) + + model_pretrain.resize_num_qa_labels(num_small_labels) + model_qa.resize_num_qa_labels(num_small_labels) + + result_pretrain_less = model_pretrain( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + ans=less_labels_ans, + return_dict=True, + ) + + result_qa_less = model_qa( + input_ids, + visual_feats, + bounding_boxes, + labels=less_labels_ans, + token_type_ids=token_type_ids, + attention_mask=input_mask, + return_dict=True, + ) + + model_pretrain.resize_num_qa_labels(num_large_labels) + model_qa.resize_num_qa_labels(num_large_labels) + + result_pretrain_more = model_pretrain( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + ans=more_labels_ans, + return_dict=True, + ) + + result_qa_more = model_qa( + input_ids, + visual_feats, + bounding_boxes, + labels=more_labels_ans, + token_type_ids=token_type_ids, + attention_mask=input_mask, + return_dict=True, + ) + + model_qa_labels = model_qa.num_qa_labels + + self.parent.assertNotEqual(start_labels, end_labels) + self.parent.assertNotEqual(model_qa_labels, start_labels) + self.parent.assertEqual(result_qa.question_answering_score.shape, (self.batch_size, start_labels)) + self.parent.assertEqual(result_pretrain.question_answering_score.shape, (self.batch_size, start_labels)) + self.parent.assertEqual(result_qa_less.question_answering_score.shape, (self.batch_size, num_small_labels)) + self.parent.assertEqual( + result_pretrain_less.question_answering_score.shape, (self.batch_size, num_small_labels) + ) + self.parent.assertEqual(result_qa_more.question_answering_score.shape, (self.batch_size, num_large_labels)) + self.parent.assertEqual( + result_pretrain_more.question_answering_score.shape, (self.batch_size, num_large_labels) + ) + + def prepare_config_and_inputs_for_common(self): + config_and_inputs = self.prepare_config_and_inputs() + ( + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ) = config_and_inputs + + inputs_dict = { + "input_ids": input_ids, + "visual_feats": visual_feats, + "visual_pos": bounding_boxes, + "token_type_ids": token_type_ids, + "attention_mask": input_mask, + } + + return config, inputs_dict + + +@require_torch +class LxmertModelTest(ModelTesterMixin, unittest.TestCase): + + all_model_classes = (LxmertModel, LxmertForPreTraining, LxmertForQuestionAnswering) if is_torch_available() else () + + test_head_masking = False + test_pruning = False + test_torchscript = False + + test_head_masking = False + test_pruning = False + test_torchscript = False + + def setUp(self): + self.model_tester = LxmertModelTester(self) + self.config_tester = ConfigTester(self, config_class=LxmertConfig, hidden_size=37) + + def test_config(self): + self.config_tester.run_common_tests() + + def test_lxmert_model(self): + config_and_inputs = self.model_tester.prepare_config_and_inputs() + self.model_tester.create_and_check_lxmert_model(*config_and_inputs) + + def test_lxmert_question_answering(self): + config_and_inputs = self.model_tester.prepare_config_and_inputs() + self.model_tester.create_and_check_lxmert_for_question_answering(*config_and_inputs) + + def test_lxmert_pretraining(self): + config_and_inputs = self.model_tester.prepare_config_and_inputs() + self.model_tester.create_and_check_lxmert_for_pretraining(*config_and_inputs) + + def test_lxmert_question_answering_labels_resize(self): + config_and_inputs = self.model_tester.prepare_config_and_inputs() + self.model_tester.resize_lxmert_num_qa_labels(*config_and_inputs) + + @slow + def test_model_from_pretrained(self): + for model_name in LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: + model = LxmertModel.from_pretrained(model_name) + self.assertIsNotNone(model) + + def test_attention_outputs(self): + config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common() + seq_len = getattr(self.model_tester, "seq_length", None) + encoder_seq_length = getattr(self.model_tester, "encoder_seq_length", seq_len) + encoder_key_length = getattr(self.model_tester, "key_length", encoder_seq_length) + chunk_length = getattr(self.model_tester, "chunk_length", None) + if chunk_length is not None and hasattr(self.model_tester, "num_hashes"): + encoder_seq_length = encoder_seq_length * self.model_tester.num_hashes + + for model_class in self.all_model_classes: + inputs_dict["output_attentions"] = True + inputs_dict["output_hidden_states"] = False + model = model_class(config) + model.to(torch_device) + model.eval() + with torch.no_grad(): + outputs = model(**self._prepare_for_class(inputs_dict, model_class)) + + language_attentions, vision_attentions, cross_encoder_attentions = (outputs[-3], outputs[-2], outputs[-1]) + + self.assertEqual(len(language_attentions), self.model_tester.num_hidden_layers["language"]) + self.assertEqual(len(vision_attentions), self.model_tester.num_hidden_layers["vision"]) + self.assertEqual(len(cross_encoder_attentions), self.model_tester.num_hidden_layers["cross_encoder"]) + + # check that output_attentions also work using config + del inputs_dict["output_attentions"] + config.output_attentions = True + model = model_class(config) + model.to(torch_device) + model.eval() + with torch.no_grad(): + outputs = model(**self._prepare_for_class(inputs_dict, model_class)) + + language_attentions, vision_attentions, cross_encoder_attentions = (outputs[-3], outputs[-2], outputs[-1]) + self.assertEqual(len(language_attentions), self.model_tester.num_hidden_layers["language"]) + self.assertEqual(len(vision_attentions), self.model_tester.num_hidden_layers["vision"]) + self.assertEqual(len(cross_encoder_attentions), self.model_tester.num_hidden_layers["cross_encoder"]) + + attentions = [language_attentions, vision_attentions, cross_encoder_attentions] + attention_shapes = [ + [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length], + [ + self.model_tester.num_attention_heads, + self.model_tester.num_visual_features, + self.model_tester.num_visual_features, + ], + [self.model_tester.num_attention_heads, encoder_key_length, self.model_tester.num_visual_features], + ] + + for attention, attention_shape in zip(attentions, attention_shapes): + self.assertListEqual(list(attention[0].shape[-3:]), attention_shape) + out_len = len(outputs) + + # Check attention is always last and order is fine + inputs_dict["output_attentions"] = True + inputs_dict["output_hidden_states"] = True + model = model_class(config) + model.to(torch_device) + model.eval() + with torch.no_grad(): + outputs = model(**self._prepare_for_class(inputs_dict, model_class)) + + # 2 hidden states were added + self.assertEqual(out_len + 2, len(outputs)) + + language_attentions, vision_attentions, cross_encoder_attentions = (outputs[-3], outputs[-2], outputs[-1]) + self.assertEqual(len(language_attentions), self.model_tester.num_hidden_layers["language"]) + self.assertEqual(len(vision_attentions), self.model_tester.num_hidden_layers["vision"]) + self.assertEqual(len(cross_encoder_attentions), self.model_tester.num_hidden_layers["cross_encoder"]) + + attentions = [language_attentions, vision_attentions, cross_encoder_attentions] + attention_shapes = [ + [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length], + [ + self.model_tester.num_attention_heads, + self.model_tester.num_visual_features, + self.model_tester.num_visual_features, + ], + [self.model_tester.num_attention_heads, encoder_key_length, self.model_tester.num_visual_features], + ] + + for attention, attention_shape in zip(attentions, attention_shapes): + self.assertListEqual(list(attention[0].shape[-3:]), attention_shape) + + def test_hidden_states_output(self): + def check_hidden_states_output(inputs_dict, config, model_class): + model = model_class(config) + model.to(torch_device) + model.eval() + + with torch.no_grad(): + outputs = model(**self._prepare_for_class(inputs_dict, model_class)) + language_hidden_states, vision_hidden_states = outputs[-2], outputs[-1] + + self.assertEqual(len(language_hidden_states), self.model_tester.num_hidden_layers["language"] + 1) + self.assertEqual(len(vision_hidden_states), self.model_tester.num_hidden_layers["vision"] + 1) + + seq_length = self.model_tester.seq_length + num_visual_features = self.model_tester.num_visual_features + + self.assertListEqual( + list(language_hidden_states[0].shape[-2:]), + [seq_length, self.model_tester.hidden_size], + ) + self.assertListEqual( + list(vision_hidden_states[0].shape[-2:]), + [num_visual_features, self.model_tester.hidden_size], + ) + + config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common() + + for model_class in self.all_model_classes: + inputs_dict["output_hidden_states"] = True + check_hidden_states_output(inputs_dict, config, model_class) + + # check that output_hidden_states also work using config + del inputs_dict["output_hidden_states"] + config.output_hidden_states = True + + check_hidden_states_output(inputs_dict, config, model_class) diff --git a/tests/test_modeling_tf_lxmert.py b/tests/test_modeling_tf_lxmert.py new file mode 100644 index 0000000000..89c67c9290 --- /dev/null +++ b/tests/test_modeling_tf_lxmert.py @@ -0,0 +1,680 @@ +# coding=utf-8 +# Copyright 2018 XXX Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import tempfile +import unittest + +from transformers import LxmertConfig, is_tf_available +from transformers.testing_utils import require_tf, slow + +from .test_configuration_common import ConfigTester +from .test_modeling_tf_common import TFModelTesterMixin, ids_tensor + + +if is_tf_available(): + import tensorflow as tf + + from transformers.modeling_tf_lxmert import TFLxmertForPreTraining, TFLxmertModel + + +class TFLxmertModelTester(object): + def __init__( + self, + parent, + vocab_size=300, + hidden_size=28, + num_attention_heads=2, + num_labels=2, + intermediate_size=64, + hidden_act="gelu", + hidden_dropout_prob=0.1, + attention_probs_dropout_prob=0.1, + max_position_embeddings=512, + type_vocab_size=2, + initializer_range=0.02, + layer_norm_eps=1e-12, + pad_token_id=0, + num_qa_labels=30, + num_object_labels=16, + num_attr_labels=4, + num_visual_features=10, + l_layers=2, + x_layers=1, + r_layers=1, + visual_feat_dim=128, + visual_pos_dim=4, + visual_loss_normalizer=6.67, + seq_length=20, + batch_size=8, + is_training=True, + task_matched=True, + task_mask_lm=True, + task_obj_predict=True, + task_qa=True, + visual_obj_loss=True, + visual_attr_loss=True, + visual_feat_loss=True, + use_token_type_ids=True, + use_lang_mask=True, + output_attentions=False, + output_hidden_states=False, + scope=None, + ): + self.parent = parent + self.vocab_size = vocab_size + self.hidden_size = hidden_size + self.num_attention_heads = num_attention_heads + self.num_labels = num_labels + self.intermediate_size = intermediate_size + self.hidden_act = hidden_act + self.hidden_dropout_prob = hidden_dropout_prob + self.attention_probs_dropout_prob = attention_probs_dropout_prob + self.max_position_embeddings = max_position_embeddings + self.type_vocab_size = type_vocab_size + self.initializer_range = initializer_range + self.layer_norm_eps = layer_norm_eps + self.pad_token_id = pad_token_id + self.num_qa_labels = num_qa_labels + self.num_object_labels = num_object_labels + self.num_attr_labels = num_attr_labels + self.l_layers = l_layers + self.x_layers = x_layers + self.r_layers = r_layers + self.visual_feat_dim = visual_feat_dim + self.visual_pos_dim = visual_pos_dim + self.visual_loss_normalizer = visual_loss_normalizer + self.seq_length = seq_length + self.batch_size = batch_size + self.is_training = is_training + self.use_lang_mask = use_lang_mask + self.task_matched = task_matched + self.task_mask_lm = task_mask_lm + self.task_obj_predict = task_obj_predict + self.task_qa = task_qa + self.visual_obj_loss = visual_obj_loss + self.visual_attr_loss = visual_attr_loss + self.visual_feat_loss = visual_feat_loss + self.num_visual_features = num_visual_features + self.use_token_type_ids = use_token_type_ids + self.output_attentions = output_attentions + self.output_hidden_states = output_hidden_states + self.scope = scope + self.num_hidden_layers = {"vision": r_layers, "cross_encoder": x_layers, "language": l_layers} + + def prepare_config_and_inputs(self): + output_attentions = self.output_attentions + input_ids = ids_tensor([self.batch_size, self.seq_length], vocab_size=self.vocab_size) + visual_feats = tf.random.uniform((self.batch_size, self.num_visual_features, self.visual_feat_dim)) + bounding_boxes = tf.random.uniform((self.batch_size, self.num_visual_features, 4)) + + input_mask = None + if self.use_lang_mask: + input_mask = ids_tensor([self.batch_size, self.seq_length], vocab_size=2) + token_type_ids = None + if self.use_token_type_ids: + token_type_ids = ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size) + obj_labels = None + if self.task_obj_predict: + obj_labels = {} + if self.visual_attr_loss and self.task_obj_predict: + obj_labels["attr"] = ( + ids_tensor([self.batch_size, self.num_visual_features], self.num_attr_labels), + ids_tensor([self.batch_size, self.num_visual_features], self.num_attr_labels), + ) + if self.visual_feat_loss and self.task_obj_predict: + obj_labels["feat"] = ( + ids_tensor( + [self.batch_size, self.num_visual_features, self.visual_feat_dim], self.num_visual_features + ), + ids_tensor([self.batch_size, self.num_visual_features], self.num_visual_features), + ) + if self.visual_obj_loss and self.task_obj_predict: + obj_labels["obj"] = ( + ids_tensor([self.batch_size, self.num_visual_features], self.num_object_labels), + ids_tensor([self.batch_size, self.num_visual_features], self.num_object_labels), + ) + ans = None + if self.task_qa: + ans = ids_tensor([self.batch_size], self.num_qa_labels) + masked_lm_labels = None + if self.task_mask_lm: + masked_lm_labels = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) + matched_label = None + if self.task_matched: + matched_label = ids_tensor([self.batch_size], self.num_labels) + + config = LxmertConfig( + vocab_size=self.vocab_size, + hidden_size=self.hidden_size, + num_attention_heads=self.num_attention_heads, + num_labels=self.num_labels, + intermediate_size=self.intermediate_size, + hidden_act=self.hidden_act, + hidden_dropout_prob=self.hidden_dropout_prob, + attention_probs_dropout_prob=self.attention_probs_dropout_prob, + max_position_embeddings=self.max_position_embeddings, + type_vocab_size=self.type_vocab_size, + initializer_range=self.initializer_range, + layer_norm_eps=self.layer_norm_eps, + pad_token_id=self.pad_token_id, + num_qa_labels=self.num_qa_labels, + num_object_labels=self.num_object_labels, + num_attr_labels=self.num_attr_labels, + l_layers=self.l_layers, + x_layers=self.x_layers, + r_layers=self.r_layers, + visual_feat_dim=self.visual_feat_dim, + visual_pos_dim=self.visual_pos_dim, + visual_loss_normalizer=self.visual_loss_normalizer, + task_matched=self.task_matched, + task_mask_lm=self.task_mask_lm, + task_obj_predict=self.task_obj_predict, + task_qa=self.task_qa, + visual_obj_loss=self.visual_obj_loss, + visual_attr_loss=self.visual_attr_loss, + visual_feat_loss=self.visual_feat_loss, + output_attentions=self.output_attentions, + output_hidden_states=self.output_hidden_states, + ) + + return ( + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ) + + def create_and_check_lxmert_model( + self, + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ): + model = TFLxmertModel(config=config) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + output_attentions=output_attentions, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + output_attentions=not output_attentions, + ) + result = model(input_ids, visual_feats, bounding_boxes, return_dict=False) + result = model(input_ids, visual_feats, bounding_boxes, return_dict=True) + + self.parent.assertEqual(result.language_output.shape, (self.batch_size, self.seq_length, self.hidden_size)) + self.parent.assertEqual( + result.vision_output.shape, (self.batch_size, self.num_visual_features, self.hidden_size) + ) + self.parent.assertEqual(result.pooled_output.shape, (self.batch_size, self.hidden_size)) + + def prepare_config_and_inputs_for_common(self, return_obj_labels=False): + config_and_inputs = self.prepare_config_and_inputs() + ( + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ) = config_and_inputs + + inputs_dict = { + "input_ids": input_ids, + "visual_feats": visual_feats, + "visual_pos": bounding_boxes, + "token_type_ids": token_type_ids, + "attention_mask": input_mask, + } + + if return_obj_labels: + inputs_dict["obj_labels"] = obj_labels + + return config, inputs_dict + + def create_and_check_lxmert_for_pretraining( + self, + config, + input_ids, + visual_feats, + bounding_boxes, + token_type_ids, + input_mask, + obj_labels, + masked_lm_labels, + matched_label, + ans, + output_attentions, + ): + model = TFLxmertForPreTraining(config=config) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + masked_lm_labels=masked_lm_labels, + obj_labels=obj_labels, + matched_label=matched_label, + ans=ans, + output_attentions=output_attentions, + return_dict=True, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + masked_lm_labels=masked_lm_labels, + output_attentions=not output_attentions, + return_dict=False, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + masked_lm_labels=masked_lm_labels, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + obj_labels=obj_labels, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + matched_label=matched_label, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + ans=ans, + ) + result = model( + input_ids, + visual_feats, + bounding_boxes, + token_type_ids=token_type_ids, + attention_mask=input_mask, + masked_lm_labels=masked_lm_labels, + obj_labels=obj_labels, + matched_label=matched_label, + ans=ans, + output_attentions=not output_attentions, + return_dict=True, + ) + + self.parent.assertEqual(result.prediction_logits.shape, (self.batch_size, self.seq_length, self.vocab_size)) + + +@require_tf +class TFLxmertModelTest(TFModelTesterMixin, unittest.TestCase): + + all_model_classes = (TFLxmertModel, TFLxmertForPreTraining) if is_tf_available() else () + + def setUp(self): + self.model_tester = TFLxmertModelTester(self) + self.config_tester = ConfigTester(self, config_class=LxmertConfig, hidden_size=37) + + def test_config(self): + self.config_tester.run_common_tests() + + def test_lxmert_model(self): + config_and_inputs = self.model_tester.prepare_config_and_inputs() + self.model_tester.create_and_check_lxmert_model(*config_and_inputs) + + def test_lxmert_for_pretraining(self): + config_and_inputs = self.model_tester.prepare_config_and_inputs() + self.model_tester.create_and_check_lxmert_for_pretraining(*config_and_inputs) + + @slow + def test_model_from_pretrained(self): + for model_name in ["unc-nlp/lxmert-base-uncased"]: + model = TFLxmertModel.from_pretrained(model_name) + self.assertIsNotNone(model) + + def test_attention_outputs(self): + config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common() + + encoder_seq_length = ( + self.model_tester.encoder_seq_length + if hasattr(self.model_tester, "encoder_seq_length") + else self.model_tester.seq_length + ) + encoder_key_length = ( + self.model_tester.key_length if hasattr(self.model_tester, "key_length") else encoder_seq_length + ) + + for model_class in self.all_model_classes: + inputs_dict["output_attentions"] = True + inputs_dict["output_hidden_states"] = False + model = model_class(config) + outputs = model(self._prepare_for_class(inputs_dict, model_class)) + language_attentions, vision_attentions, cross_encoder_attentions = (outputs[-3], outputs[-2], outputs[-1]) + + self.assertEqual(model.config.output_hidden_states, False) + + self.assertEqual(len(language_attentions), self.model_tester.num_hidden_layers["language"]) + self.assertEqual(len(vision_attentions), self.model_tester.num_hidden_layers["vision"]) + self.assertEqual(len(cross_encoder_attentions), self.model_tester.num_hidden_layers["cross_encoder"]) + + attentions = [language_attentions, vision_attentions, cross_encoder_attentions] + attention_shapes = [ + [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length], + [ + self.model_tester.num_attention_heads, + self.model_tester.num_visual_features, + self.model_tester.num_visual_features, + ], + [self.model_tester.num_attention_heads, encoder_key_length, self.model_tester.num_visual_features], + ] + + for attention, attention_shape in zip(attentions, attention_shapes): + self.assertListEqual(list(attention[0].shape[-3:]), attention_shape) + out_len = len(outputs) + + # Check attention is always last and order is fine + inputs_dict["output_attentions"] = True + inputs_dict["output_hidden_states"] = True + model = model_class(config) + outputs = model(self._prepare_for_class(inputs_dict, model_class)) + + # 2 hidden states were added + self.assertEqual(out_len + 2, len(outputs)) + language_attentions, vision_attentions, cross_encoder_attentions = (outputs[-3], outputs[-2], outputs[-1]) + self.assertEqual(len(language_attentions), self.model_tester.num_hidden_layers["language"]) + self.assertEqual(len(vision_attentions), self.model_tester.num_hidden_layers["vision"]) + self.assertEqual(len(cross_encoder_attentions), self.model_tester.num_hidden_layers["cross_encoder"]) + + attentions = [language_attentions, vision_attentions, cross_encoder_attentions] + attention_shapes = [ + [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length], + [ + self.model_tester.num_attention_heads, + self.model_tester.num_visual_features, + self.model_tester.num_visual_features, + ], + [self.model_tester.num_attention_heads, encoder_key_length, self.model_tester.num_visual_features], + ] + + for attention, attention_shape in zip(attentions, attention_shapes): + self.assertListEqual(list(attention[0].shape[-3:]), attention_shape) + + def test_hidden_states_output(self): + config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common() + + def check_hidden_states_output(config, inputs_dict, model_class): + model = model_class(config) + outputs = model(self._prepare_for_class(inputs_dict, model_class)) + language_hidden_states, vision_hidden_states = outputs[-2], outputs[-1] + + self.assertEqual(len(language_hidden_states), self.model_tester.num_hidden_layers["language"] + 1) + self.assertEqual(len(vision_hidden_states), self.model_tester.num_hidden_layers["vision"] + 1) + + seq_length = self.model_tester.seq_length + num_visual_features = self.model_tester.num_visual_features + + self.assertListEqual( + list(language_hidden_states[0].shape[-2:]), + [seq_length, self.model_tester.hidden_size], + ) + self.assertListEqual( + list(vision_hidden_states[0].shape[-2:]), + [num_visual_features, self.model_tester.hidden_size], + ) + + for model_class in self.all_model_classes: + inputs_dict["output_hidden_states"] = True + check_hidden_states_output(config, inputs_dict, model_class) + + del inputs_dict["output_hidden_states"] + config.output_hidden_states = True + check_hidden_states_output(config, inputs_dict, model_class) + + def test_pt_tf_model_equivalence(self): + from transformers import is_torch_available + + if not is_torch_available(): + return + + import torch + + import transformers + + for model_class in self.all_model_classes: + config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common( + return_obj_labels="PreTraining" in model_class.__name__ + ) + + pt_model_class_name = model_class.__name__[2:] # Skip the "TF" at the beggining + pt_model_class = getattr(transformers, pt_model_class_name) + + config.output_hidden_states = True + config.task_obj_predict = False + + tf_model = model_class(config) + pt_model = pt_model_class(config) + + # Check we can load pt model in tf and vice-versa with model => model functions + + tf_model = transformers.load_pytorch_model_in_tf2_model( + tf_model, pt_model, tf_inputs=self._prepare_for_class(inputs_dict, model_class) + ) + pt_model = transformers.load_tf2_model_in_pytorch_model(pt_model, tf_model) + + # Check predictions on first output (logits/hidden-states) are close enought given low-level computational differences + pt_model.eval() + + # Delete obj labels as we want to compute the hidden states and not the loss + + if "obj_labels" in inputs_dict: + del inputs_dict["obj_labels"] + + def torch_type(key): + if key in ("visual_feats", "visual_pos"): + return torch.float32 + else: + return torch.long + + def recursive_numpy_convert(iterable): + return_dict = {} + for key, value in iterable.items(): + if isinstance(value, dict): + return_dict[key] = recursive_numpy_convert(value) + else: + if isinstance(value, (list, tuple)): + return_dict[key] = ( + torch.from_numpy(iter_value.numpy()).to(torch_type(key)) for iter_value in value + ) + else: + return_dict[key] = torch.from_numpy(value.numpy()).to(torch_type(key)) + return return_dict + + pt_inputs_dict = recursive_numpy_convert(self._prepare_for_class(inputs_dict, model_class)) + + # need to rename encoder-decoder "inputs" for PyTorch + if "inputs" in pt_inputs_dict and self.is_encoder_decoder: + pt_inputs_dict["input_ids"] = pt_inputs_dict.pop("inputs") + + with torch.no_grad(): + pto = pt_model(**pt_inputs_dict) + tfo = tf_model(self._prepare_for_class(inputs_dict, model_class), training=False) + tf_hidden_states = tfo[0].numpy() + pt_hidden_states = pto[0].numpy() + + import numpy as np + + tf_nans = np.copy(np.isnan(tf_hidden_states)) + pt_nans = np.copy(np.isnan(pt_hidden_states)) + + pt_hidden_states[tf_nans] = 0 + tf_hidden_states[tf_nans] = 0 + pt_hidden_states[pt_nans] = 0 + tf_hidden_states[pt_nans] = 0 + + max_diff = np.amax(np.abs(tf_hidden_states - pt_hidden_states)) + # Debug info (remove when fixed) + if max_diff >= 2e-2: + print("===") + print(model_class) + print(config) + print(inputs_dict) + print(pt_inputs_dict) + self.assertLessEqual(max_diff, 6e-2) + + # Check we can load pt model in tf and vice-versa with checkpoint => model functions + with tempfile.TemporaryDirectory() as tmpdirname: + import os + + pt_checkpoint_path = os.path.join(tmpdirname, "pt_model.bin") + torch.save(pt_model.state_dict(), pt_checkpoint_path) + tf_model = transformers.load_pytorch_checkpoint_in_tf2_model(tf_model, pt_checkpoint_path) + + tf_checkpoint_path = os.path.join(tmpdirname, "tf_model.h5") + tf_model.save_weights(tf_checkpoint_path) + pt_model = transformers.load_tf2_checkpoint_in_pytorch_model(pt_model, tf_checkpoint_path) + + # Check predictions on first output (logits/hidden-states) are close enought given low-level computational differences + pt_model.eval() + pt_inputs_dict = dict( + (name, torch.from_numpy(key.numpy()).to(torch.long)) + for name, key in self._prepare_for_class(inputs_dict, model_class).items() + ) + + for key, value in pt_inputs_dict.items(): + if key in ("visual_feats", "visual_pos"): + pt_inputs_dict[key] = value.to(torch.float32) + else: + pt_inputs_dict[key] = value.to(torch.long) + + with torch.no_grad(): + pto = pt_model(**pt_inputs_dict) + tfo = tf_model(self._prepare_for_class(inputs_dict, model_class)) + tfo = tfo[0].numpy() + pto = pto[0].numpy() + tf_nans = np.copy(np.isnan(tfo)) + pt_nans = np.copy(np.isnan(pto)) + + pto[tf_nans] = 0 + tfo[tf_nans] = 0 + pto[pt_nans] = 0 + tfo[pt_nans] = 0 + + max_diff = np.amax(np.abs(tfo - pto)) + self.assertLessEqual(max_diff, 6e-2) + + def test_save_load(self): + for model_class in self.all_model_classes: + config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common( + return_obj_labels="PreTraining" in model_class.__name__ + ) + + model = model_class(config) + outputs = model(self._prepare_for_class(inputs_dict, model_class)) + + with tempfile.TemporaryDirectory() as tmpdirname: + model.save_pretrained(tmpdirname) + model = model_class.from_pretrained(tmpdirname) + after_outputs = model(self._prepare_for_class(inputs_dict, model_class)) + + self.assert_outputs_same(after_outputs, outputs) + + def test_compile_tf_model(self): + optimizer = tf.keras.optimizers.Adam(learning_rate=3e-5, epsilon=1e-08, clipnorm=1.0) + loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) + metric = tf.keras.metrics.SparseCategoricalAccuracy("accuracy") + + for model_class in self.all_model_classes: + config, inputs_dict = self.model_tester.prepare_config_and_inputs_for_common( + return_obj_labels="PreTraining" in model_class.__name__ + ) + + input_ids = tf.keras.Input( + batch_shape=(self.model_tester.batch_size, self.model_tester.seq_length), + name="input_ids", + dtype="int32", + ) + visual_feats = tf.keras.Input( + batch_shape=( + self.model_tester.batch_size, + self.model_tester.num_visual_features, + self.model_tester.visual_feat_dim, + ), + name="visual_feats", + dtype="int32", + ) + visual_pos = tf.keras.Input( + batch_shape=(self.model_tester.batch_size, self.model_tester.num_visual_features, 4), + name="visual_pos", + dtype="int32", + ) + + # Prepare our model + model = model_class(config) + + # Let's load it from the disk to be sure we can use pretrained weights + with tempfile.TemporaryDirectory() as tmpdirname: + outputs = model(self._prepare_for_class(inputs_dict, model_class)) # build the model + model.save_pretrained(tmpdirname) + model = model_class.from_pretrained(tmpdirname) + + outputs_dict = model(input_ids, visual_feats, visual_pos) + hidden_states = outputs_dict[0] + + # Add a dense layer on top to test integration with other keras modules + outputs = tf.keras.layers.Dense(2, activation="softmax", name="outputs")(hidden_states) + + # Compile extended model + extended_model = tf.keras.Model(inputs=[input_ids, visual_feats, visual_pos], outputs=[outputs]) + extended_model.compile(optimizer=optimizer, loss=loss, metrics=[metric]) diff --git a/tests/test_tokenization_lxmert.py b/tests/test_tokenization_lxmert.py new file mode 100644 index 0000000000..e3c157568c --- /dev/null +++ b/tests/test_tokenization_lxmert.py @@ -0,0 +1,65 @@ +# coding=utf-8 +# Copyright 2018 LXMERT Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import os +import unittest + +from transformers.tokenization_bert import VOCAB_FILES_NAMES +from transformers.tokenization_lxmert import LxmertTokenizer + +from .test_tokenization_common import TokenizerTesterMixin + + +class LxmertTokenizationTest(TokenizerTesterMixin, unittest.TestCase): + + tokenizer_class = LxmertTokenizer + + def setUp(self): + super().setUp() + + vocab_tokens = [ + "[UNK]", + "[CLS]", + "[SEP]", + "want", + "##want", + "##ed", + "wa", + "un", + "runn", + "##ing", + ",", + "low", + "lowest", + ] + self.vocab_file = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES["vocab_file"]) + with open(self.vocab_file, "w", encoding="utf-8") as vocab_writer: + vocab_writer.write("".join([x + "\n" for x in vocab_tokens])) + + def get_tokenizer(self, **kwargs): + return LxmertTokenizer.from_pretrained(self.tmpdirname, **kwargs) + + def get_input_output_texts(self, tokenizer): + input_text = "UNwant\u00E9d,running" + output_text = "unwanted, running" + return input_text, output_text + + def test_full_tokenizer(self): + tokenizer = self.tokenizer_class(self.vocab_file) + + tokens = tokenizer.tokenize("UNwant\u00E9d,running") + self.assertListEqual(tokens, ["un", "##want", "##ed", ",", "runn", "##ing"]) + self.assertListEqual(tokenizer.convert_tokens_to_ids(tokens), [7, 4, 5, 10, 8, 9])