Spaces:
Runtime error
Runtime error
| # coding=utf-8 | |
| # Copyright The HuggingFace Inc. team. All rights reserved. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| """ VLE model configuration""" | |
| import copy | |
| from transformers.configuration_utils import PretrainedConfig | |
| from transformers.utils import logging | |
| from transformers.models.auto.configuration_auto import AutoConfig | |
| from transformers.models.clip.configuration_clip import CLIPVisionConfig | |
| from typing import Union, Dict | |
| logger = logging.get_logger(__name__) | |
| class VLEConfig(PretrainedConfig): | |
| r""" | |
| [`VLEConfig`] is the configuration class to store the configuration of a | |
| [`VLEModel`]. It is used to instantiate [`VLEModel`] model according to the | |
| specified arguments, defining the text model and vision model configs. | |
| Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the | |
| documentation from [`PretrainedConfig`] for more information. | |
| Args: | |
| text_config (`dict`): | |
| Dictionary of configuration options that defines text model config. | |
| vision_config (`dict`): | |
| Dictionary of configuration options that defines vison model config. | |
| #TODO | |
| logit_scale_init_value (`float`, *optional*, defaults to 2.6592): | |
| The inital value of the *logit_scale* paramter. Default is used as per the original CLIP implementation. | |
| kwargs (*optional*): | |
| Dictionary of keyword arguments. | |
| Examples: | |
| ```python | |
| >>> from transformers import ViTConfig, BertConfig | |
| >>> from configuration_vle import VLEconfig | |
| >>> from modeling_vle import VLEModel | |
| >>> # Initializing a BERT and ViT configuration | |
| >>> config_vision = ViTConfig() | |
| >>> config_text = BertConfig() | |
| >>> config = VLEConfig.from_vision_text_configs(config_vision, config_text) #TODO | |
| >>> # Initializing a BERT and ViT model (with random weights) | |
| >>> model = VLEModel(config=config) | |
| >>> # Accessing the model configuration | |
| >>> config_vision = model.config.vision_config | |
| >>> config_text = model.config.text_config | |
| >>> # Saving the model, including its configuration | |
| >>> model.save_pretrained("vit-bert") | |
| >>> # loading model and config from pretrained folder | |
| >>> vision_text_config = VLEConfig.from_pretrained("vit-bert") | |
| >>> model = VLEModel.from_pretrained("vit-bert", config=vision_text_config) | |
| ```""" | |
| model_type = "vle" | |
| is_composition = True | |
| def __init__( | |
| self, | |
| text_config: Union[PretrainedConfig, Dict], | |
| vision_config: Union[PretrainedConfig, Dict], | |
| num_token_types=2, | |
| hidden_size=768, | |
| num_hidden_layers=6, | |
| num_attention_heads=12, | |
| intermediate_size=3072, | |
| hidden_act="gelu", | |
| hidden_dropout_prob=0.1, | |
| attention_probs_dropout_prob=0.1, | |
| initializer_range=0.02, | |
| layer_norm_eps=1e-12, | |
| classifier_dropout=None, | |
| **kwargs): | |
| super().__init__(**kwargs) | |
| if not isinstance(text_config,PretrainedConfig): | |
| text_model_type = text_config.pop('model_type') | |
| text_config = AutoConfig.for_model(text_model_type, **text_config) | |
| self.text_config = text_config | |
| if not isinstance(vision_config, PretrainedConfig): | |
| vision_model_type = vision_config.pop('model_type') | |
| if vision_model_type == "clip": | |
| vision_config = AutoConfig.for_model(vision_model_type, **vision_config).vision_config | |
| elif vision_model_type == "clip_vision_model": | |
| vision_config = CLIPVisionConfig(**vision_config) | |
| else: | |
| vision_config = AutoConfig.for_model(vision_model_type, **vision_config) | |
| self.vision_config = vision_config | |
| else: | |
| vision_model_type = vision_config.model_type | |
| if vision_model_type== "clip": | |
| vision_config = vision_config.vision_config | |
| self.vision_config = vision_config | |
| # co-attention | |
| self.num_token_types=num_token_types | |
| self.hidden_size=hidden_size | |
| self.num_hidden_layers=num_hidden_layers | |
| self.num_attention_heads=num_attention_heads | |
| 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.initializer_range=initializer_range | |
| self.layer_norm_eps=layer_norm_eps | |
| self.classifier_dropout=classifier_dropout | |
| def to_dict(self): | |
| """ | |
| Serializes this instance to a Python dictionary. Override the default [`~PretrainedConfig.to_dict`]. | |
| Returns: | |
| `Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance, | |
| """ | |
| output = copy.deepcopy(self.__dict__) | |
| output["vision_config"] = self.vision_config.to_dict() | |
| output["text_config"] = self.text_config.to_dict() | |
| output["model_type"] = self.__class__.model_type | |
| return output | |