


'''simple docstring'''






import logging
import os
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

from filelock import FileLock

from transformers import PreTrainedTokenizer, is_tf_available, is_torch_available


__A :  int    							=				logging.getLogger(__name__)






@dataclass
class        __snake_case	:







    """simple docstring"""



    lowercase       			= 42
    lowercase       			= 42
    lowercase       			= 42







@dataclass
class        __snake_case	:







    """simple docstring"""



    lowercase       			= 42
    lowercase       			= 42
    lowercase       			= None
    lowercase       			= None







class        __snake_case	(       _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase       			= 'train'
    lowercase       			= 'dev'
    lowercase       			= 'test'







class        __snake_case	:







    """simple docstring"""



    @staticmethod
    def __lowercase       (       lowerCamelCase   :  List[str]   ,						lowerCamelCase   :  Union[Split, str]		)       ->  List[InputExample]:
      raise NotImplementedError

    @staticmethod
    def __lowercase       (       lowerCamelCase   :  str		)       ->  List[str]:
      raise NotImplementedError





    @staticmethod
    def __lowercase       (       lowerCamelCase   :  List[InputExample]   ,						lowerCamelCase   :  List[str]   ,						lowerCamelCase   :  int   ,						lowerCamelCase   :  PreTrainedTokenizer   ,						lowerCamelCase   :  List[str]=False   ,						lowerCamelCase   :  Any="[CLS]"   ,						lowerCamelCase   :  List[str]=1   ,						lowerCamelCase   :  List[str]="[SEP]"   ,						lowerCamelCase   :  Optional[int]=False   ,						lowerCamelCase   :  int=False   ,						lowerCamelCase   :  Tuple=0   ,						lowerCamelCase   :  List[str]=0   ,						lowerCamelCase   :  Tuple=-1_00   ,						lowerCamelCase   :  Dict=0   ,						lowerCamelCase   :  Union[str, Any]=True   ,						)       ->  List[InputFeatures]:
      lowerCAmelCase_      :				Dict      =       {label: i for i, label in enumerate(lowerCamelCase		)}

      lowerCAmelCase_      :				Dict      =       []
      for ex_index, example in enumerate(lowerCamelCase		):
        if ex_index % 1_00_00 == 0:
          logger.info("""Writing example %d of %d"""   ,						lowerCamelCase   ,						len(lowerCamelCase		)		)

        lowerCAmelCase_      :				List[str]      =       []
        lowerCAmelCase_      :				Union[str, Any]      =       []
        for word, label in zip(example.words   ,						example.labels		):
          lowerCAmelCase_      :				str      =       tokenizer.tokenize(lowerCamelCase		)

          # bert-base-multilingual-cased sometimes output "nothing ([]) when calling tokenize with just a space.
          if len(lowerCamelCase		) > 0:
            tokens.extend(lowerCamelCase		)
            # Use the real label id for the first token of the word, and padding ids for the remaining tokens
            label_ids.extend([label_map[label]] + [pad_token_label_id] * (len(lowerCamelCase		) - 1)		)

            # Account for [CLS] and [SEP] with "- 2" and with "- 3" for RoBERTa.
        lowerCAmelCase_      :				Dict      =       tokenizer.num_special_tokens_to_add()
        if len(lowerCamelCase		) > max_seq_length - special_tokens_count:
          lowerCAmelCase_      :				int      =       tokens[: (max_seq_length - special_tokens_count)]
          lowerCAmelCase_      :				List[str]      =       label_ids[: (max_seq_length - special_tokens_count)]

        # The convention in BERT is:
        # (a) For sequence pairs:
        #  tokens:   [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
        #  type_ids:   0   0  0    0    0     0       0   0   1  1  1  1   1   1
        # (b) For single sequences:
        #  tokens:   [CLS] the dog is hairy . [SEP]
        #  type_ids:   0   0   0   0  0     0   0
        #
        # Where "type_ids" are used to indicate whether this is the first
        # sequence or the second sequence. The embedding vectors for `type=0` and
        # `type=1` were learned during pre-training and are added to the wordpiece
        # embedding vector (and position vector). This is not *strictly* necessary
        # since the [SEP] token unambiguously separates the sequences, but it makes
        # it easier for the model to learn the concept of sequences.
        #
        # For classification tasks, the first vector (corresponding to [CLS]) is
        # used as the "sentence vector". Note that this only makes sense because
        # the entire model is fine-tuned.
        tokens += [sep_token]
        label_ids += [pad_token_label_id]
        if sep_token_extra:
          # roberta uses an extra separator b/w pairs of sentences
          tokens += [sep_token]
          label_ids += [pad_token_label_id]
        lowerCAmelCase_      :				Dict      =       [sequence_a_segment_id] * len(lowerCamelCase		)

        if cls_token_at_end:
          tokens += [cls_token]
          label_ids += [pad_token_label_id]
          segment_ids += [cls_token_segment_id]
        else:
          lowerCAmelCase_      :				Union[str, Any]      =       [cls_token] + tokens
          lowerCAmelCase_      :				Union[str, Any]      =       [pad_token_label_id] + label_ids
          lowerCAmelCase_      :				int      =       [cls_token_segment_id] + segment_ids

        lowerCAmelCase_      :				Dict      =       tokenizer.convert_tokens_to_ids(lowerCamelCase		)

        # The mask has 1 for real tokens and 0 for padding tokens. Only real
        # tokens are attended to.
        lowerCAmelCase_      :				Optional[Any]      =       [1 if mask_padding_with_zero else 0] * len(lowerCamelCase		)

        # Zero-pad up to the sequence length.
        lowerCAmelCase_      :				Tuple      =       max_seq_length - len(lowerCamelCase		)
        if pad_on_left:
          lowerCAmelCase_      :				List[str]      =       ([pad_token] * padding_length) + input_ids
          lowerCAmelCase_      :				Tuple      =       ([0 if mask_padding_with_zero else 1] * padding_length) + input_mask
          lowerCAmelCase_      :				Union[str, Any]      =       ([pad_token_segment_id] * padding_length) + segment_ids
          lowerCAmelCase_      :				List[str]      =       ([pad_token_label_id] * padding_length) + label_ids
        else:
          input_ids += [pad_token] * padding_length
          input_mask += [0 if mask_padding_with_zero else 1] * padding_length
          segment_ids += [pad_token_segment_id] * padding_length
          label_ids += [pad_token_label_id] * padding_length

        assert len(lowerCamelCase		) == max_seq_length
        assert len(lowerCamelCase		) == max_seq_length
        assert len(lowerCamelCase		) == max_seq_length
        assert len(lowerCamelCase		) == max_seq_length

        if ex_index < 5:
          logger.info("""*** Example ***"""		)
          logger.info("""guid: %s"""   ,						example.guid		)
          logger.info("""tokens: %s"""   ,						""" """.join([str(lowerCamelCase		) for x in tokens]		)		)
          logger.info("""input_ids: %s"""   ,						""" """.join([str(lowerCamelCase		) for x in input_ids]		)		)
          logger.info("""input_mask: %s"""   ,						""" """.join([str(lowerCamelCase		) for x in input_mask]		)		)
          logger.info("""segment_ids: %s"""   ,						""" """.join([str(lowerCamelCase		) for x in segment_ids]		)		)
          logger.info("""label_ids: %s"""   ,						""" """.join([str(lowerCamelCase		) for x in label_ids]		)		)

        if "token_type_ids" not in tokenizer.model_input_names:
          lowerCAmelCase_      :				int      =       None

        features.append(
            InputFeatures(
                input_ids=lowerCamelCase   ,						attention_mask=lowerCamelCase   ,						token_type_ids=lowerCamelCase   ,						label_ids=lowerCamelCase		)		)
      return features


if is_torch_available():
  import torch
  from torch import nn
  from torch.utils.data import Dataset






  class        __snake_case	(       _SCREAMING_SNAKE_CASE):







      """simple docstring"""



      lowercase       			= 42
      lowercase       			= nn.CrossEntropyLoss().ignore_index

      def __init__(       self   :  List[Any]   ,						lowerCamelCase   :  TokenClassificationTask   ,						lowerCamelCase   :  str   ,						lowerCamelCase   :  PreTrainedTokenizer   ,						lowerCamelCase   :  List[str]   ,						lowerCamelCase   :  str   ,						lowerCamelCase   :  Optional[int] = None   ,						lowerCamelCase   :  List[Any]=False   ,						lowerCamelCase   :  Split = Split.train   ,						)       ->  Union[str, Any]:
        # Load data features from cache or dataset file
        lowerCAmelCase_      :				Optional[int]      =       os.path.join(
            lowerCamelCase   ,						"""cached_{}_{}_{}""".format(mode.value   ,						tokenizer.__class__.__name__   ,						str(lowerCamelCase		)		)   ,						)

        # Make sure only the first process in distributed training processes the dataset,
        # and the others will use the cache.
        lowerCAmelCase_      :				Any      =       cached_features_file + """.lock"""
        with FileLock(lowerCamelCase		):
          if os.path.exists(lowerCamelCase		) and not overwrite_cache:
            logger.info(F'Loading features from cached file {cached_features_file}'		)
            lowerCAmelCase_      :				int      =       torch.load(lowerCamelCase		)
          else:
            logger.info(F'Creating features from dataset file at {data_dir}'		)
            lowerCAmelCase_      :				Optional[Any]      =       token_classification_task.read_examples_from_file(lowerCamelCase   ,						lowerCamelCase		)
            # TODO clean up all this to leverage built-in features of tokenizers
            lowerCAmelCase_      :				str      =       token_classification_task.convert_examples_to_features(
                lowerCamelCase   ,						lowerCamelCase   ,						lowerCamelCase   ,						lowerCamelCase   ,						cls_token_at_end=bool(model_type in ["""xlnet"""]		)   ,						cls_token=tokenizer.cls_token   ,						cls_token_segment_id=2 if model_type in ["""xlnet"""] else 0   ,						sep_token=tokenizer.sep_token   ,						sep_token_extra=lowerCamelCase   ,						pad_on_left=bool(tokenizer.padding_side == """left"""		)   ,						pad_token=tokenizer.pad_token_id   ,						pad_token_segment_id=tokenizer.pad_token_type_id   ,						pad_token_label_id=self.pad_token_label_id   ,						)
            logger.info(F'Saving features into cached file {cached_features_file}'		)
            torch.save(self.features   ,						lowerCamelCase		)

      def __len__(       self   :  Any		)       ->  Dict:
        return len(self.features		)





      def __getitem__(       self   :  Union[str, Any]   ,						lowerCamelCase   :  List[str]		)       ->  InputFeatures:
        return self.features[i]


if is_tf_available():
  import tensorflow as tf






  class        __snake_case	:







      """simple docstring"""



      lowercase       			= 42
      lowercase       			= -1_00

      def __init__(       self   :  Union[str, Any]   ,						lowerCamelCase   :  TokenClassificationTask   ,						lowerCamelCase   :  str   ,						lowerCamelCase   :  PreTrainedTokenizer   ,						lowerCamelCase   :  List[str]   ,						lowerCamelCase   :  str   ,						lowerCamelCase   :  Optional[int] = None   ,						lowerCamelCase   :  str=False   ,						lowerCamelCase   :  Split = Split.train   ,						)       ->  Optional[Any]:
        lowerCAmelCase_      :				Dict      =       token_classification_task.read_examples_from_file(lowerCamelCase   ,						lowerCamelCase		)
        # TODO clean up all this to leverage built-in features of tokenizers
        lowerCAmelCase_      :				str      =       token_classification_task.convert_examples_to_features(
            lowerCamelCase   ,						lowerCamelCase   ,						lowerCamelCase   ,						lowerCamelCase   ,						cls_token_at_end=bool(model_type in ["""xlnet"""]		)   ,						cls_token=tokenizer.cls_token   ,						cls_token_segment_id=2 if model_type in ["""xlnet"""] else 0   ,						sep_token=tokenizer.sep_token   ,						sep_token_extra=lowerCamelCase   ,						pad_on_left=bool(tokenizer.padding_side == """left"""		)   ,						pad_token=tokenizer.pad_token_id   ,						pad_token_segment_id=tokenizer.pad_token_type_id   ,						pad_token_label_id=self.pad_token_label_id   ,						)

        def gen():
          for ex in self.features:
            if ex.token_type_ids is None:
              yield (
                  {"input_ids": ex.input_ids, "attention_mask": ex.attention_mask},
                  ex.label_ids,
              )
            else:
              yield (
                  {
                      "input_ids": ex.input_ids,
                      "attention_mask": ex.attention_mask,
                      "token_type_ids": ex.token_type_ids,
                  },
                  ex.label_ids,
              )

        if "token_type_ids" not in tokenizer.model_input_names:
          lowerCAmelCase_      :				Tuple      =       tf.data.Dataset.from_generator(
              lowerCamelCase   ,						({"""input_ids""": tf.intaa, """attention_mask""": tf.intaa}, tf.intaa)   ,						(
                  {"""input_ids""": tf.TensorShape([None]		), """attention_mask""": tf.TensorShape([None]		)},
                  tf.TensorShape([None]		),
              )   ,						)
        else:
          lowerCAmelCase_      :				str      =       tf.data.Dataset.from_generator(
              lowerCamelCase   ,						({"""input_ids""": tf.intaa, """attention_mask""": tf.intaa, """token_type_ids""": tf.intaa}, tf.intaa)   ,						(
                  {
                      """input_ids""": tf.TensorShape([None]		),
                      """attention_mask""": tf.TensorShape([None]		),
                      """token_type_ids""": tf.TensorShape([None]		),
                  },
                  tf.TensorShape([None]		),
              )   ,						)

      def __lowercase       (       self   :  Tuple		)       ->  str:
        lowerCAmelCase_      :				List[Any]      =       self.dataset.apply(tf.data.experimental.assert_cardinality(len(self.features		)		)		)

        return self.dataset

      def __len__(       self   :  List[Any]		)       ->  int:
        return len(self.features		)





      def __getitem__(       self   :  str   ,						lowerCamelCase   :  Union[str, Any]		)       ->  InputFeatures:
        return self.features[i]







'''simple docstring'''






from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .embeddings import GaussianFourierProjection, TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin
from .unet_ad_blocks import get_down_block, get_mid_block, get_out_block, get_up_block






@dataclass
class        __snake_case	(       _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase       			= 42







class        __snake_case	(       _SCREAMING_SNAKE_CASE     ,_SCREAMING_SNAKE_CASE):







    """simple docstring"""



    @register_to_config
    def __init__(       self   :  Optional[int]   ,						lowerCamelCase   :  int = 6_55_36   ,						lowerCamelCase   :  Optional[int] = None   ,						lowerCamelCase   :  int = 2   ,						lowerCamelCase   :  int = 2   ,						lowerCamelCase   :  int = 0   ,						lowerCamelCase   :  str = "fourier"   ,						lowerCamelCase   :  bool = True   ,						lowerCamelCase   :  bool = False   ,						lowerCamelCase   :  float = 0.0   ,						lowerCamelCase   :  Tuple[str] = ("DownBlock1DNoSkip", "DownBlock1D", "AttnDownBlock1D")   ,						lowerCamelCase   :  Tuple[str] = ("AttnUpBlock1D", "UpBlock1D", "UpBlock1DNoSkip")   ,						lowerCamelCase   :  Tuple[str] = "UNetMidBlock1D"   ,						lowerCamelCase   :  str = None   ,						lowerCamelCase   :  Tuple[int] = (32, 32, 64)   ,						lowerCamelCase   :  str = None   ,						lowerCamelCase   :  int = 8   ,						lowerCamelCase   :  int = 1   ,						lowerCamelCase   :  bool = False   ,						)       ->  List[Any]:
      super().__init__()
      lowerCAmelCase_      :				Optional[Any]      =       sample_size

      # time
      if time_embedding_type == "fourier":
        lowerCAmelCase_      :				int      =       GaussianFourierProjection(
            embedding_size=8   ,						set_W_to_weight=lowerCamelCase   ,						log=lowerCamelCase   ,						flip_sin_to_cos=lowerCamelCase		)
        lowerCAmelCase_      :				List[Any]      =       2 * block_out_channels[0]
      elif time_embedding_type == "positional":
        lowerCAmelCase_      :				Optional[int]      =       Timesteps(
            block_out_channels[0]   ,						flip_sin_to_cos=lowerCamelCase   ,						downscale_freq_shift=lowerCamelCase		)
        lowerCAmelCase_      :				Union[str, Any]      =       block_out_channels[0]

      if use_timestep_embedding:
        lowerCAmelCase_      :				List[str]      =       block_out_channels[0] * 4
        lowerCAmelCase_      :				List[str]      =       TimestepEmbedding(
            in_channels=lowerCamelCase   ,						time_embed_dim=lowerCamelCase   ,						act_fn=lowerCamelCase   ,						out_dim=block_out_channels[0]   ,						)

      lowerCAmelCase_      :				str      =       nn.ModuleList([]		)
      lowerCAmelCase_      :				Tuple      =       None
      lowerCAmelCase_      :				str      =       nn.ModuleList([]		)
      lowerCAmelCase_      :				List[str]      =       None

      # down
      lowerCAmelCase_      :				List[str]      =       in_channels
      for i, down_block_type in enumerate(lowerCamelCase		):
        lowerCAmelCase_      :				Optional[Any]      =       output_channel
        lowerCAmelCase_      :				str      =       block_out_channels[i]

        if i == 0:
          input_channel += extra_in_channels

        lowerCAmelCase_      :				int      =       i == len(lowerCamelCase		) - 1

        lowerCAmelCase_      :				List[str]      =       get_down_block(
            lowerCamelCase   ,						num_layers=lowerCamelCase   ,						in_channels=lowerCamelCase   ,						out_channels=lowerCamelCase   ,						temb_channels=block_out_channels[0]   ,						add_downsample=not is_final_block or downsample_each_block   ,						)
        self.down_blocks.append(lowerCamelCase		)

      # mid
      lowerCAmelCase_      :				Dict      =       get_mid_block(
          lowerCamelCase   ,						in_channels=block_out_channels[-1]   ,						mid_channels=block_out_channels[-1]   ,						out_channels=block_out_channels[-1]   ,						embed_dim=block_out_channels[0]   ,						num_layers=lowerCamelCase   ,						add_downsample=lowerCamelCase   ,						)

      # up
      lowerCAmelCase_      :				List[str]      =       list(reversed(lowerCamelCase		)		)
      lowerCAmelCase_      :				str      =       reversed_block_out_channels[0]
      if out_block_type is None:
        lowerCAmelCase_      :				Optional[int]      =       out_channels
      else:
        lowerCAmelCase_      :				Optional[Any]      =       block_out_channels[0]

      for i, up_block_type in enumerate(lowerCamelCase		):
        lowerCAmelCase_      :				Any      =       output_channel
        lowerCAmelCase_      :				str      =       (
            reversed_block_out_channels[i + 1] if i < len(lowerCamelCase		) - 1 else final_upsample_channels
        )

        lowerCAmelCase_      :				int      =       i == len(lowerCamelCase		) - 1

        lowerCAmelCase_      :				Any      =       get_up_block(
            lowerCamelCase   ,						num_layers=lowerCamelCase   ,						in_channels=lowerCamelCase   ,						out_channels=lowerCamelCase   ,						temb_channels=block_out_channels[0]   ,						add_upsample=not is_final_block   ,						)
        self.up_blocks.append(lowerCamelCase		)
        lowerCAmelCase_      :				Optional[int]      =       output_channel

      # out
      lowerCAmelCase_      :				str      =       norm_num_groups if norm_num_groups is not None else min(block_out_channels[0] // 4   ,						32		)
      lowerCAmelCase_      :				Union[str, Any]      =       get_out_block(
          out_block_type=lowerCamelCase   ,						num_groups_out=lowerCamelCase   ,						embed_dim=block_out_channels[0]   ,						out_channels=lowerCamelCase   ,						act_fn=lowerCamelCase   ,						fc_dim=block_out_channels[-1] // 4   ,						)





    def __lowercase       (       self   :  List[Any]   ,						lowerCamelCase   :  torch.FloatTensor   ,						lowerCamelCase   :  Union[torch.Tensor, float, int]   ,						lowerCamelCase   :  bool = True   ,						)       ->  Union[UNetaDOutput, Tuple]:
      lowerCAmelCase_      :				Optional[Any]      =       timestep
      if not torch.is_tensor(lowerCamelCase		):
        lowerCAmelCase_      :				Any      =       torch.tensor([timesteps]   ,						dtype=torch.long   ,						device=sample.device		)
      elif torch.is_tensor(lowerCamelCase		) and len(timesteps.shape		) == 0:
        lowerCAmelCase_      :				Dict      =       timesteps[None].to(sample.device		)

      lowerCAmelCase_      :				int      =       self.time_proj(lowerCamelCase		)
      if self.config.use_timestep_embedding:
        lowerCAmelCase_      :				int      =       self.time_mlp(lowerCamelCase		)
      else:
        lowerCAmelCase_      :				Tuple      =       timestep_embed[..., None]
        lowerCAmelCase_      :				Dict      =       timestep_embed.repeat([1, 1, sample.shape[2]]		).to(sample.dtype		)
        lowerCAmelCase_      :				Union[str, Any]      =       timestep_embed.broadcast_to((sample.shape[:1] + timestep_embed.shape[1:])		)

      # 2. down
      lowerCAmelCase_      :				Optional[Any]      =       ()
      for downsample_block in self.down_blocks:
        lowerCAmelCase_,							lowerCAmelCase_      :				Any      =       downsample_block(hidden_states=lowerCamelCase   ,						temb=lowerCamelCase		)
        down_block_res_samples += res_samples

      # 3. mid
      if self.mid_block:
        lowerCAmelCase_      :				int      =       self.mid_block(lowerCamelCase   ,						lowerCamelCase		)

      # 4. up
      for i, upsample_block in enumerate(self.up_blocks		):
        lowerCAmelCase_      :				str      =       down_block_res_samples[-1:]
        lowerCAmelCase_      :				Union[str, Any]      =       down_block_res_samples[:-1]
        lowerCAmelCase_      :				List[str]      =       upsample_block(lowerCamelCase   ,						res_hidden_states_tuple=lowerCamelCase   ,						temb=lowerCamelCase		)

      # 5. post-process
      if self.out_block:
        lowerCAmelCase_      :				Union[str, Any]      =       self.out_block(lowerCamelCase   ,						lowerCamelCase		)

      if not return_dict:
        return (sample,)

      return UNetaDOutput(sample=lowerCamelCase		)



