


'''simple docstring'''


import tensorflow as tf

from ...tf_utils import shape_list







class 							__magic_name__	(       tf.keras.layers.Layer ):

     """simple docstring"""






     def __init__(   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=1			,     lowerCamelCase=False			,     **lowerCamelCase		):


          '''simple docstring'''





          super().__init__(**lowerCamelCase		)

          __A	:       Optional[int]      =							vocab_size
          __A	:       Dict      =							d_embed
          __A	:       Tuple      =							d_proj

          __A	:       Union[str, Any]      =							cutoffs + [vocab_size]
          __A	:       Any      =							[0] + self.cutoffs
          __A	:       Tuple      =							div_val

          __A	:       Any      =							self.cutoffs[0]
          __A	:       Union[str, Any]      =							len(self.cutoffs		) - 1
          __A	:       Optional[Any]      =							self.shortlist_size + self.n_clusters
          __A	:       Union[str, Any]      =							keep_order

          __A	:       List[Any]      =							[]
          __A	:       Union[str, Any]      =							[]


     def lowerCAmelCase__  (   self			,     lowerCamelCase		):


          '''simple docstring'''





          if self.n_clusters > 0:
               __A	:       str      =							self.add_weight(
                   shape=(self.n_clusters, self.d_embed)			,     initializer="zeros"			,     trainable=lowerCamelCase			,     name="cluster_weight"		)
               __A	:       Optional[int]      =							self.add_weight(
                   shape=(self.n_clusters,)			,     initializer="zeros"			,     trainable=lowerCamelCase			,     name="cluster_bias"		)

          if self.div_val == 1:
               for i in range(len(self.cutoffs		)		):
                    if self.d_proj != self.d_embed:
                         __A	:       Any      =							self.add_weight(
                             shape=(self.d_embed, self.d_proj)			,     initializer="zeros"			,     trainable=lowerCamelCase			,     name=f"out_projs_._{i}"			,     )
                         self.out_projs.append(lowerCamelCase		)
                    else:
                         self.out_projs.append(lowerCamelCase		)
                    __A	:       int      =							self.add_weight(
                        shape=(self.vocab_size, self.d_embed)			,     initializer="zeros"			,     trainable=lowerCamelCase			,     name=f"out_layers_._{i}_._weight"			,     )
                    __A	:       Union[str, Any]      =							self.add_weight(
                        shape=(self.vocab_size,)			,     initializer="zeros"			,     trainable=lowerCamelCase			,     name=f"out_layers_._{i}_._bias"			,     )
                    self.out_layers.append((weight, bias)		)
          else:
               for i in range(len(self.cutoffs		)		):
                    __A  ,__A	:       Optional[Any]      =							self.cutoff_ends[i], self.cutoff_ends[i + 1]
                    __A	:       Optional[int]      =							self.d_embed // (self.div_val**i)

                    __A	:       int      =							self.add_weight(
                        shape=(d_emb_i, self.d_proj)			,     initializer="zeros"			,     trainable=lowerCamelCase			,     name=f"out_projs_._{i}"		)
                    self.out_projs.append(lowerCamelCase		)
                    __A	:       Optional[int]      =							self.add_weight(
                        shape=(r_idx - l_idx, d_emb_i)			,     initializer="zeros"			,     trainable=lowerCamelCase			,     name=f"out_layers_._{i}_._weight"			,     )
                    __A	:       Optional[int]      =							self.add_weight(
                        shape=(r_idx - l_idx,)			,     initializer="zeros"			,     trainable=lowerCamelCase			,     name=f"out_layers_._{i}_._bias"			,     )
                    self.out_layers.append((weight, bias)		)
          super().build(lowerCamelCase		)


     @staticmethod
     def lowerCAmelCase__  (   lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=None		):


          '''simple docstring'''





          __A	:       List[Any]      =							x
          if proj is not None:
               __A	:       Union[str, Any]      =							tf.einsum("ibd,ed->ibe"			,     lowerCamelCase			,     lowerCamelCase		)
          return tf.einsum("ibd,nd->ibn"			,     lowerCamelCase			,     lowerCamelCase		) + b


     @staticmethod
     def lowerCAmelCase__  (   lowerCamelCase			,     lowerCamelCase		):


          '''simple docstring'''





          __A	:       List[str]      =							shape_list(lowerCamelCase		)
          __A	:       Any      =							tf.range(lp_size[0]			,     dtype=target.dtype		)
          __A	:       int      =							tf.stack([r, target]			,     1		)
          return tf.gather_nd(lowerCamelCase			,     lowerCamelCase		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=True			,     lowerCamelCase=False		):


          '''simple docstring'''





          __A	:       Optional[int]      =							0
          if self.n_clusters == 0:
               __A	:       Dict      =							self._logit(lowerCamelCase			,     self.out_layers[0][0]			,     self.out_layers[0][1]			,     self.out_projs[0]		)
               if target is not None:
                    __A	:       Dict      =							tf.nn.sparse_softmax_cross_entropy_with_logits(labels=lowerCamelCase			,     logits=lowerCamelCase		)
               __A	:       Dict      =							tf.nn.log_softmax(lowerCamelCase			,     axis=-1		)
          else:
               __A	:       Optional[Any]      =							shape_list(lowerCamelCase		)
               __A	:       Optional[int]      =							[]
               __A	:       List[Any]      =							tf.zeros(hidden_sizes[:2]		)
               for i in range(len(self.cutoffs		)		):
                    __A  ,__A	:       Tuple      =							self.cutoff_ends[i], self.cutoff_ends[i + 1]
                    if target is not None:
                         __A	:       Tuple      =							(target >= l_idx) & (target < r_idx)
                         __A	:       Union[str, Any]      =							tf.where(lowerCamelCase		)
                         __A	:       Any      =							tf.boolean_mask(lowerCamelCase			,     lowerCamelCase		) - l_idx

                    if self.div_val == 1:
                         __A	:       List[str]      =							self.out_layers[0][0][l_idx:r_idx]
                         __A	:       str      =							self.out_layers[0][1][l_idx:r_idx]
                    else:
                         __A	:       Union[str, Any]      =							self.out_layers[i][0]
                         __A	:       Tuple      =							self.out_layers[i][1]

                    if i == 0:
                         __A	:       Optional[int]      =							tf.concat([cur_W, self.cluster_weight]			,     0		)
                         __A	:       Tuple      =							tf.concat([cur_b, self.cluster_bias]			,     0		)

                         __A	:       Dict      =							self._logit(lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     self.out_projs[0]		)
                         __A	:       Tuple      =							tf.nn.log_softmax(lowerCamelCase		)
                         out.append(head_logprob[..., : self.cutoffs[0]]		)
                         if target is not None:
                              __A	:       Union[str, Any]      =							tf.boolean_mask(lowerCamelCase			,     lowerCamelCase		)
                              __A	:       List[str]      =							self._gather_logprob(lowerCamelCase			,     lowerCamelCase		)
                    else:
                         __A	:       List[str]      =							self._logit(lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     self.out_projs[i]		)
                         __A	:       Any      =							tf.nn.log_softmax(lowerCamelCase		)
                         __A	:       List[Any]      =							self.cutoffs[0] + i - 1  # No probability for the head cluster
                         __A	:       Union[str, Any]      =							head_logprob[..., cluster_prob_idx, None] + tail_logprob
                         out.append(lowerCamelCase		)
                         if target is not None:
                              __A	:       Optional[Any]      =							tf.boolean_mask(lowerCamelCase			,     lowerCamelCase		)
                              __A	:       Dict      =							tf.boolean_mask(lowerCamelCase			,     lowerCamelCase		)
                              __A	:       Optional[Any]      =							self._gather_logprob(lowerCamelCase			,     lowerCamelCase		)
                              cur_logprob += cur_head_logprob[:, self.cutoff_ends[1] + i - 1]
                    if target is not None:
                         loss += tf.scatter_nd(lowerCamelCase			,     -cur_logprob			,     shape_list(lowerCamelCase		)		)
               __A	:       Union[str, Any]      =							tf.concat(lowerCamelCase			,     axis=-1		)

          if target is not None:
               if return_mean:
                    __A	:       Dict      =							tf.reduce_mean(lowerCamelCase		)
               # Add the training-time loss value to the layer using `self.add_loss()`.
               self.add_loss(lowerCamelCase		)

               # Log the loss as a metric (we could log arbitrary metrics,
               # including different metrics for training and inference.
               self.add_metric(lowerCamelCase			,     name=self.name			,     aggregation="mean" if return_mean else ""		)

          return out





'''simple docstring'''


import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
      from PIL import Image

      from transformers import AlignProcessor, EfficientNetImageProcessor







@require_vision
class 							__magic_name__	(       unittest.TestCase ):

     """simple docstring"""






     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       int      =							tempfile.mkdtemp()

          __A	:       List[Any]      =							[
              "[UNK]",
              "[CLS]",
              "[SEP]",
              "[PAD]",
              "[MASK]",
              "want",
              "##want",
              "##ed",
              "wa",
              "un",
              "runn",
              "##ing",
              ",",
              "low",
              "lowest",
          ]
          __A	:       Tuple      =							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]		)		)

          __A	:       List[str]      =							{
              "do_resize": True,
              "size": 20,
              "do_center_crop": True,
              "crop_size": 18,
              "do_normalize": True,
              "image_mean": [0.4814_5466, 0.457_8275, 0.4082_1073],
              "image_std": [0.2686_2954, 0.2613_0258, 0.2757_7711],
          }
          __A	:       Union[str, Any]      =							os.path.join(self.tmpdirname			,     lowerCamelCase		)
          with open(self.image_processor_file			,     "w"			,     encoding="utf-8"		) as fp:
               json.dump(lowerCamelCase			,     lowerCamelCase		)


     def lowerCAmelCase__  (   self			,     **lowerCamelCase		):


          '''simple docstring'''





          return BertTokenizer.from_pretrained(self.tmpdirname			,     **lowerCamelCase		)


     def lowerCAmelCase__  (   self			,     **lowerCamelCase		):


          '''simple docstring'''





          return BertTokenizerFast.from_pretrained(self.tmpdirname			,     **lowerCamelCase		)


     def lowerCAmelCase__  (   self			,     **lowerCamelCase		):


          '''simple docstring'''





          return EfficientNetImageProcessor.from_pretrained(self.tmpdirname			,     **lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          shutil.rmtree(self.tmpdirname		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       int      =							[np.random.randint(255			,     size=(3, 30, 400)			,     dtype=np.uinta		)]
          __A	:       int      =							[Image.fromarray(np.moveaxis(lowerCamelCase			,     0			,     -1		)		) for x in image_inputs]
          return image_inputs


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Union[str, Any]      =							self.get_tokenizer()
          __A	:       int      =							self.get_rust_tokenizer()
          __A	:       List[str]      =							self.get_image_processor()

          __A	:       List[Any]      =							AlignProcessor(tokenizer=lowerCamelCase			,     image_processor=lowerCamelCase		)
          processor_slow.save_pretrained(self.tmpdirname		)
          __A	:       List[Any]      =							AlignProcessor.from_pretrained(self.tmpdirname			,     use_fast=lowerCamelCase		)

          __A	:       int      =							AlignProcessor(tokenizer=lowerCamelCase			,     image_processor=lowerCamelCase		)
          processor_fast.save_pretrained(self.tmpdirname		)
          __A	:       List[str]      =							AlignProcessor.from_pretrained(self.tmpdirname		)

          self.assertEqual(processor_slow.tokenizer.get_vocab()			,     tokenizer_slow.get_vocab()		)
          self.assertEqual(processor_fast.tokenizer.get_vocab()			,     tokenizer_fast.get_vocab()		)
          self.assertEqual(tokenizer_slow.get_vocab()			,     tokenizer_fast.get_vocab()		)
          self.assertIsInstance(processor_slow.tokenizer			,     lowerCamelCase		)
          self.assertIsInstance(processor_fast.tokenizer			,     lowerCamelCase		)

          self.assertEqual(processor_slow.image_processor.to_json_string()			,     image_processor.to_json_string()		)
          self.assertEqual(processor_fast.image_processor.to_json_string()			,     image_processor.to_json_string()		)
          self.assertIsInstance(processor_slow.image_processor			,     lowerCamelCase		)
          self.assertIsInstance(processor_fast.image_processor			,     lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       List[Any]      =							AlignProcessor(tokenizer=self.get_tokenizer()			,     image_processor=self.get_image_processor()		)
          processor.save_pretrained(self.tmpdirname		)

          __A	:       List[str]      =							self.get_tokenizer(bos_token="(BOS)"			,     eos_token="(EOS)"		)
          __A	:       int      =							self.get_image_processor(do_normalize=lowerCamelCase			,     padding_value=1.0		)

          __A	:       Optional[int]      =							AlignProcessor.from_pretrained(
              self.tmpdirname			,     bos_token="(BOS)"			,     eos_token="(EOS)"			,     do_normalize=lowerCamelCase			,     padding_value=1.0		)

          self.assertEqual(processor.tokenizer.get_vocab()			,     tokenizer_add_kwargs.get_vocab()		)
          self.assertIsInstance(processor.tokenizer			,     lowerCamelCase		)

          self.assertEqual(processor.image_processor.to_json_string()			,     image_processor_add_kwargs.to_json_string()		)
          self.assertIsInstance(processor.image_processor			,     lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[Any]      =							self.get_image_processor()
          __A	:       Optional[Any]      =							self.get_tokenizer()

          __A	:       List[str]      =							AlignProcessor(tokenizer=lowerCamelCase			,     image_processor=lowerCamelCase		)

          __A	:       int      =							self.prepare_image_inputs()

          __A	:       Optional[int]      =							image_processor(lowerCamelCase			,     return_tensors="np"		)
          __A	:       Dict      =							processor(images=lowerCamelCase			,     return_tensors="np"		)

          for key in input_image_proc.keys():
               self.assertAlmostEqual(input_image_proc[key].sum()			,     input_processor[key].sum()			,     delta=1E-2		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       str      =							self.get_image_processor()
          __A	:       int      =							self.get_tokenizer()

          __A	:       Optional[int]      =							AlignProcessor(tokenizer=lowerCamelCase			,     image_processor=lowerCamelCase		)

          __A	:       Optional[Any]      =							"lower newer"

          __A	:       Union[str, Any]      =							processor(text=lowerCamelCase		)

          __A	:       int      =							tokenizer(lowerCamelCase			,     padding="max_length"			,     max_length=64		)

          for key in encoded_tok.keys():
               self.assertListEqual(encoded_tok[key]			,     encoded_processor[key]		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							self.get_image_processor()
          __A	:       Optional[Any]      =							self.get_tokenizer()

          __A	:       int      =							AlignProcessor(tokenizer=lowerCamelCase			,     image_processor=lowerCamelCase		)

          __A	:       Tuple      =							"lower newer"
          __A	:       int      =							self.prepare_image_inputs()

          __A	:       str      =							processor(text=lowerCamelCase			,     images=lowerCamelCase		)

          self.assertListEqual(list(inputs.keys()		)			,     ["input_ids", "token_type_ids", "attention_mask", "pixel_values"]		)

          # test if it raises when no input is passed
          with pytest.raises(lowerCamelCase		):
               processor()


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Dict      =							self.get_image_processor()
          __A	:       Tuple      =							self.get_tokenizer()

          __A	:       Dict      =							AlignProcessor(tokenizer=lowerCamelCase			,     image_processor=lowerCamelCase		)

          __A	:       Optional[int]      =							[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

          __A	:       Optional[int]      =							processor.batch_decode(lowerCamelCase		)
          __A	:       Optional[int]      =							tokenizer.batch_decode(lowerCamelCase		)

          self.assertListEqual(lowerCamelCase			,     lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       str      =							self.get_image_processor()
          __A	:       Union[str, Any]      =							self.get_tokenizer()

          __A	:       Union[str, Any]      =							AlignProcessor(tokenizer=lowerCamelCase			,     image_processor=lowerCamelCase		)

          __A	:       int      =							"lower newer"
          __A	:       str      =							self.prepare_image_inputs()

          __A	:       Tuple      =							processor(text=lowerCamelCase			,     images=lowerCamelCase		)

          self.assertListEqual(list(inputs.keys()		)			,     processor.model_input_names		)

