codingutf8 2022 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 orglicenseslicense2 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 dpt model configuration import copy from configurationutils import pretrainedconfig from utils import logging from auto configurationauto import configmapping from bit import bitconfig logger logging getloggername dptpretrainedconfigarchivemap inteldptlarge https huggingface cointeldptlargeresolvemainconfig json see all dpt models at https huggingface comodels filterdpt class dptconfigpretrainedconfig r this is the configuration class to store the configuration of a dptmodel it is used to instantiate an dpt model according to the specified arguments defining the model architecture instantiating a configuration with the defaults will yield a similar configuration to that of the dpt inteldptlargehttps huggingface cointeldptlarge architecture configuration objects inherit from pretrainedconfig and can be used to control the model outputs read the documentation from pretrainedconfig for more information args hiddensize int optional defaults to 768 dimensionality of the encoder layers and the pooler layer numhiddenlayers int optional defaults to 12 number of hidden layers in the transformer encoder numattentionheads int optional defaults to 12 number of attention heads for each attention layer in the transformer encoder intermediatesize int optional defaults to 3072 dimensionality of the intermediate i e feedforward layer in the transformer encoder hiddenact str or function optional defaults to gelu the nonlinear activation function function or string in the encoder and pooler if string gelu relu selu and gelunew are supported hiddendropoutprob float optional defaults to 0 0 the dropout probabilitiy for all fully connected layers in the embeddings encoder and pooler attentionprobsdropoutprob float optional defaults to 0 0 the dropout ratio for the attention probabilities initializerrange float optional defaults to 0 02 the standard deviation of the truncatednormalinitializer for initializing all weight matrices layernormeps float optional defaults to 1e12 the epsilon used by the layer normalization layers imagesize int optional defaults to 384 the size resolution of each image patchsize int optional defaults to 16 the size resolution of each patch numchannels int optional defaults to 3 the number of input channels ishybrid bool optional defaults to false whether to use a hybrid backbone useful in the context of loading dpthybrid models qkvbias bool optional defaults to true whether to add a bias to the queries keys and values backboneoutindices listint optional defaults to 2 5 8 11 indices of the intermediate hidden states to use from backbone readouttype str optional defaults to project the readout type to use when processing the readout token cls token of the intermediate hidden states of the vit backbone can be one of ignore add project ignore simply ignores the cls token add passes the information from the cls token to all other tokens by adding the representations project passes information to the other tokens by concatenating the readout to all other tokens before projecting the representation to the original feature dimension d using a linear layer followed by a gelu nonlinearity reassemblefactors listint optional defaults to 4 2 1 0 5 the updownsampling factors of the reassemble layers neckhiddensizes liststr optional defaults to 96 192 384 768 the hidden sizes to project to for the feature maps of the backbone fusionhiddensize int optional defaults to 256 the number of channels before fusion headinindex int optional defaults to 1 the index of the features to use in the heads usebatchnorminfusionresidual bool optional defaults to false whether to use batch normalization in the preactivate residual units of the fusion blocks usebiasinfusionresidual bool optional defaults to true whether to use bias in the preactivate residual units of the fusion blocks addprojection bool optional defaults to false whether to add a projection layer before the depth estimation head useauxiliaryhead bool optional defaults to true whether to use an auxiliary head during training auxiliarylossweight float optional defaults to 0 4 weight of the crossentropy loss of the auxiliary head semanticlossignoreindex int optional defaults to 255 the index that is ignored by the loss function of the semantic segmentation model semanticclassifierdropout float optional defaults to 0 1 the dropout ratio for the semantic classification head backbonefeatmapshape listint optional defaults to 1 1024 24 24 used only for the hybrid embedding type the shape of the feature maps of the backbone neckignorestages listint optional defaults to 0 1 used only for the hybrid embedding type the stages of the readout layers to ignore backboneconfig uniondictstr any pretrainedconfig optional the configuration of the backbone model only used in case ishybrid is true or in case you want to leverage the autobackbone api example python from transformers import dptmodel dptconfig initializing a dpt dptlarge style configuration configuration dptconfig initializing a model from the dptlarge style configuration model dptmodelconfiguration accessing the model configuration configuration model config modeltype dpt def init self hiddensize768 numhiddenlayers12 numattentionheads12 intermediatesize3072 hiddenactgelu hiddendropoutprob0 0 attentionprobsdropoutprob0 0 initializerrange0 02 layernormeps1e12 imagesize384 patchsize16 numchannels3 ishybridfalse qkvbiastrue backboneoutindices2 5 8 11 readouttypeproject reassemblefactors4 2 1 0 5 neckhiddensizes96 192 384 768 fusionhiddensize256 headinindex1 usebatchnorminfusionresidualfalse usebiasinfusionresidualnone addprojectionfalse useauxiliaryheadtrue auxiliarylossweight0 4 semanticlossignoreindex255 semanticclassifierdropout0 1 backbonefeatmapshape1 1024 24 24 neckignorestages0 1 backboneconfignone kwargs super initkwargs self hiddensize hiddensize self ishybrid ishybrid useautobackbone false if self ishybrid if backboneconfig is none logger infoinitializing the config with a bit backbone backboneconfig globalpadding same layertype bottleneck depths 3 4 9 outfeatures stage1 stage2 stage3 embeddingdynamicpadding true self backboneconfig bitconfigbackboneconfig elif isinstancebackboneconfig dict logger infoinitializing the config with a bit backbone self backboneconfig bitconfigbackboneconfig elif isinstancebackboneconfig pretrainedconfig self backboneconfig backboneconfig else raise valueerror fbackboneconfig must be a dictionary or a pretrainedconfig got backboneconfig class self backbonefeatmapshape backbonefeatmapshape self neckignorestages neckignorestages if readouttype project raise valueerrorreadout type must be project when using dpthybrid mode elif backboneconfig is not none useautobackbone true if isinstancebackboneconfig dict backbonemodeltype backboneconfig getmodeltype configclass configmappingbackbonemodeltype backboneconfig configclass fromdictbackboneconfig self backboneconfig backboneconfig self backbonefeatmapshape none self neckignorestages else self backboneconfig backboneconfig self backbonefeatmapshape none self neckignorestages self numhiddenlayers none if useautobackbone else numhiddenlayers self numattentionheads none if useautobackbone else numattentionheads self intermediatesize none if useautobackbone else intermediatesize self hiddendropoutprob none if useautobackbone else hiddendropoutprob self attentionprobsdropoutprob none if useautobackbone else attentionprobsdropoutprob self layernormeps none if useautobackbone else layernormeps self imagesize none if useautobackbone else imagesize self patchsize none if useautobackbone else patchsize self numchannels none if useautobackbone else numchannels self qkvbias none if useautobackbone else qkvbias self backboneoutindices none if useautobackbone else backboneoutindices if readouttype not in ignore add project raise valueerrorreadouttype must be one of ignore add project self hiddenact hiddenact self initializerrange initializerrange self readouttype readouttype self reassemblefactors reassemblefactors self neckhiddensizes neckhiddensizes self fusionhiddensize fusionhiddensize self headinindex headinindex self usebatchnorminfusionresidual usebatchnorminfusionresidual self usebiasinfusionresidual usebiasinfusionresidual self addprojection addprojection auxiliary head attributes semantic segmentation self useauxiliaryhead useauxiliaryhead self auxiliarylossweight auxiliarylossweight self semanticlossignoreindex semanticlossignoreindex self semanticclassifierdropout semanticclassifierdropout def todictself output copy deepcopyself dict if outputbackboneconfig is not none outputbackboneconfig self backboneconfig todict outputmodeltype self class modeltype return output coding utf 8 2022 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 dpt model configuration see all dpt models at https huggingface co models filter dpt this is the configuration class to store the configuration of a dptmodel it is used to instantiate an dpt model according to the specified arguments defining the model architecture instantiating a configuration with the defaults will yield a similar configuration to that of the dpt intel dpt large https huggingface co intel dpt large architecture configuration objects inherit from pretrainedconfig and can be used to control the model outputs read the documentation from pretrainedconfig for more information args hidden_size int optional defaults to 768 dimensionality of the encoder layers and the pooler layer num_hidden_layers int optional defaults to 12 number of hidden layers in the transformer encoder num_attention_heads int optional defaults to 12 number of attention heads for each attention layer in the transformer encoder intermediate_size int optional defaults to 3072 dimensionality of the intermediate i e feed forward layer in the transformer encoder hidden_act str or function optional defaults to gelu the non linear activation function function or string in the encoder and pooler if string gelu relu selu and gelu_new are supported hidden_dropout_prob float optional defaults to 0 0 the dropout probabilitiy for all fully connected layers in the embeddings encoder and pooler attention_probs_dropout_prob float optional defaults to 0 0 the dropout ratio for the attention probabilities initializer_range float optional defaults to 0 02 the standard deviation of the truncated_normal_initializer for initializing all weight matrices layer_norm_eps float optional defaults to 1e 12 the epsilon used by the layer normalization layers image_size int optional defaults to 384 the size resolution of each image patch_size int optional defaults to 16 the size resolution of each patch num_channels int optional defaults to 3 the number of input channels is_hybrid bool optional defaults to false whether to use a hybrid backbone useful in the context of loading dpt hybrid models qkv_bias bool optional defaults to true whether to add a bias to the queries keys and values backbone_out_indices list int optional defaults to 2 5 8 11 indices of the intermediate hidden states to use from backbone readout_type str optional defaults to project the readout type to use when processing the readout token cls token of the intermediate hidden states of the vit backbone can be one of ignore add project ignore simply ignores the cls token add passes the information from the cls token to all other tokens by adding the representations project passes information to the other tokens by concatenating the readout to all other tokens before projecting the representation to the original feature dimension d using a linear layer followed by a gelu non linearity reassemble_factors list int optional defaults to 4 2 1 0 5 the up downsampling factors of the reassemble layers neck_hidden_sizes list str optional defaults to 96 192 384 768 the hidden sizes to project to for the feature maps of the backbone fusion_hidden_size int optional defaults to 256 the number of channels before fusion head_in_index int optional defaults to 1 the index of the features to use in the heads use_batch_norm_in_fusion_residual bool optional defaults to false whether to use batch normalization in the pre activate residual units of the fusion blocks use_bias_in_fusion_residual bool optional defaults to true whether to use bias in the pre activate residual units of the fusion blocks add_projection bool optional defaults to false whether to add a projection layer before the depth estimation head use_auxiliary_head bool optional defaults to true whether to use an auxiliary head during training auxiliary_loss_weight float optional defaults to 0 4 weight of the cross entropy loss of the auxiliary head semantic_loss_ignore_index int optional defaults to 255 the index that is ignored by the loss function of the semantic segmentation model semantic_classifier_dropout float optional defaults to 0 1 the dropout ratio for the semantic classification head backbone_featmap_shape list int optional defaults to 1 1024 24 24 used only for the hybrid embedding type the shape of the feature maps of the backbone neck_ignore_stages list int optional defaults to 0 1 used only for the hybrid embedding type the stages of the readout layers to ignore backbone_config union dict str any pretrainedconfig optional the configuration of the backbone model only used in case is_hybrid is true or in case you want to leverage the autobackbone api example python from transformers import dptmodel dptconfig initializing a dpt dpt large style configuration configuration dptconfig initializing a model from the dpt large style configuration model dptmodel configuration accessing the model configuration configuration model config auxiliary head attributes semantic segmentation 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
import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import CONFIG_MAPPING
from ..bit import BitConfig


logger = logging.get_logger(__name__)

DPT_PRETRAINED_CONFIG_ARCHIVE_MAP = {
    "Intel/dpt-large": "https://huggingface.co/Intel/dpt-large/resolve/main/config.json",
    
}


class DPTConfig(PretrainedConfig):
    r

    model_type = "dpt"

    def __init__(
        self,
        hidden_size=768,
        num_hidden_layers=12,
        num_attention_heads=12,
        intermediate_size=3072,
        hidden_act="gelu",
        hidden_dropout_prob=0.0,
        attention_probs_dropout_prob=0.0,
        initializer_range=0.02,
        layer_norm_eps=1e-12,
        image_size=384,
        patch_size=16,
        num_channels=3,
        is_hybrid=False,
        qkv_bias=True,
        backbone_out_indices=[2, 5, 8, 11],
        readout_type="project",
        reassemble_factors=[4, 2, 1, 0.5],
        neck_hidden_sizes=[96, 192, 384, 768],
        fusion_hidden_size=256,
        head_in_index=-1,
        use_batch_norm_in_fusion_residual=False,
        use_bias_in_fusion_residual=None,
        add_projection=False,
        use_auxiliary_head=True,
        auxiliary_loss_weight=0.4,
        semantic_loss_ignore_index=255,
        semantic_classifier_dropout=0.1,
        backbone_featmap_shape=[1, 1024, 24, 24],
        neck_ignore_stages=[0, 1],
        backbone_config=None,
        **kwargs,
    ):
        super().__init__(**kwargs)

        self.hidden_size = hidden_size
        self.is_hybrid = is_hybrid

        use_autobackbone = False
        if self.is_hybrid:
            if backbone_config is None:
                logger.info("Initializing the config with a `BiT` backbone.")
                backbone_config = {
                    "global_padding": "same",
                    "layer_type": "bottleneck",
                    "depths": [3, 4, 9],
                    "out_features": ["stage1", "stage2", "stage3"],
                    "embedding_dynamic_padding": True,
                }
                self.backbone_config = BitConfig(**backbone_config)
            elif isinstance(backbone_config, dict):
                logger.info("Initializing the config with a `BiT` backbone.")
                self.backbone_config = BitConfig(**backbone_config)
            elif isinstance(backbone_config, PretrainedConfig):
                self.backbone_config = backbone_config
            else:
                raise ValueError(
                    f"backbone_config must be a dictionary or a `PretrainedConfig`, got {backbone_config.__class__}."
                )

            self.backbone_featmap_shape = backbone_featmap_shape
            self.neck_ignore_stages = neck_ignore_stages

            if readout_type != "project":
                raise ValueError("Readout type must be 'project' when using `DPT-hybrid` mode.")

        elif backbone_config is not None:
            use_autobackbone = True

            if isinstance(backbone_config, dict):
                backbone_model_type = backbone_config.get("model_type")
                config_class = CONFIG_MAPPING[backbone_model_type]
                backbone_config = config_class.from_dict(backbone_config)

            self.backbone_config = backbone_config
            self.backbone_featmap_shape = None
            self.neck_ignore_stages = []

        else:
            self.backbone_config = backbone_config
            self.backbone_featmap_shape = None
            self.neck_ignore_stages = []

        self.num_hidden_layers = None if use_autobackbone else num_hidden_layers
        self.num_attention_heads = None if use_autobackbone else num_attention_heads
        self.intermediate_size = None if use_autobackbone else intermediate_size
        self.hidden_dropout_prob = None if use_autobackbone else hidden_dropout_prob
        self.attention_probs_dropout_prob = None if use_autobackbone else attention_probs_dropout_prob
        self.layer_norm_eps = None if use_autobackbone else layer_norm_eps
        self.image_size = None if use_autobackbone else image_size
        self.patch_size = None if use_autobackbone else patch_size
        self.num_channels = None if use_autobackbone else num_channels
        self.qkv_bias = None if use_autobackbone else qkv_bias
        self.backbone_out_indices = None if use_autobackbone else backbone_out_indices

        if readout_type not in ["ignore", "add", "project"]:
            raise ValueError("Readout_type must be one of ['ignore', 'add', 'project']")
        self.hidden_act = hidden_act
        self.initializer_range = initializer_range
        self.readout_type = readout_type
        self.reassemble_factors = reassemble_factors
        self.neck_hidden_sizes = neck_hidden_sizes
        self.fusion_hidden_size = fusion_hidden_size
        self.head_in_index = head_in_index
        self.use_batch_norm_in_fusion_residual = use_batch_norm_in_fusion_residual
        self.use_bias_in_fusion_residual = use_bias_in_fusion_residual
        self.add_projection = add_projection

        
        self.use_auxiliary_head = use_auxiliary_head
        self.auxiliary_loss_weight = auxiliary_loss_weight
        self.semantic_loss_ignore_index = semantic_loss_ignore_index
        self.semantic_classifier_dropout = semantic_classifier_dropout

    def to_dict(self):
        
        output = copy.deepcopy(self.__dict__)

        if output["backbone_config"] is not None:
            output["backbone_config"] = self.backbone_config.to_dict()

        output["model_type"] = self.__class__.model_type
        return output