


"""simple docstring"""


import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip 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 CLIPImageProcessor, CLIPProcessor
@require_vision
class 						_UpperCamelCase						(     unittest.TestCase	):
							'''simple docstring'''







							def     snake_case       (  self			):
										__lowerCAmelCase       					=    tempfile.mkdtemp()

										# fmt: off
										__lowerCAmelCase       					=    ["l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
										# fmt: on
										__lowerCAmelCase       					=    dict(zip(__a					,     range(len(__a			)			)			)			)
										__lowerCAmelCase       					=    ["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
										__lowerCAmelCase       					=    {"unk_token": "<unk>"}

										__lowerCAmelCase       					=    os.path.join(self.tmpdirname					,     VOCAB_FILES_NAMES["vocab_file"]			)
										__lowerCAmelCase       					=    os.path.join(self.tmpdirname					,     VOCAB_FILES_NAMES["merges_file"]			)
										with open(self.vocab_file					,     "w"					,     encoding="utf-8"			) as fp:
													fp.write(json.dumps(__a			) + "\n"			)
										with open(self.merges_file					,     "w"					,     encoding="utf-8"			) as fp:
													fp.write("\n".join(__a			)			)

										__lowerCAmelCase       					=    {
										    "do_resize": True,
										    "size": 20,
										    "do_center_crop": True,
										    "crop_size": 18,
										    "do_normalize": True,
										    "image_mean": [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
										    "image_std": [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
										}
										__lowerCAmelCase       					=    os.path.join(self.tmpdirname					,     __a			)
										with open(self.image_processor_file					,     "w"					,     encoding="utf-8"			) as fp:
													json.dump(__a					,     __a			)

							def     snake_case       (  self					,     **__a			):
										return CLIPTokenizer.from_pretrained(self.tmpdirname					,     **__a			)

							def     snake_case       (  self					,     **__a			):
										return CLIPTokenizerFast.from_pretrained(self.tmpdirname					,     **__a			)

							def     snake_case       (  self					,     **__a			):
										return CLIPImageProcessor.from_pretrained(self.tmpdirname					,     **__a			)

							def     snake_case       (  self			):
										shutil.rmtree(self.tmpdirname			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    [np.random.randint(2_55					,     size=(3, 30, 4_00)					,     dtype=np.uinta			)]

										__lowerCAmelCase       					=    [Image.fromarray(np.moveaxis(__a					,     0					,     -1			)			) for x in image_inputs]

										return image_inputs

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_tokenizer()
										__lowerCAmelCase       					=    self.get_rust_tokenizer()
										__lowerCAmelCase       					=    self.get_image_processor()

										__lowerCAmelCase       					=    CLIPProcessor(tokenizer=__a					,     image_processor=__a			)
										processor_slow.save_pretrained(self.tmpdirname			)
										__lowerCAmelCase       					=    CLIPProcessor.from_pretrained(self.tmpdirname					,     use_fast=__a			)

										__lowerCAmelCase       					=    CLIPProcessor(tokenizer=__a					,     image_processor=__a			)
										processor_fast.save_pretrained(self.tmpdirname			)
										__lowerCAmelCase       					=    CLIPProcessor.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					,     __a			)
										self.assertIsInstance(processor_fast.tokenizer					,     __a			)

										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					,     __a			)
										self.assertIsInstance(processor_fast.image_processor					,     __a			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    CLIPProcessor(tokenizer=self.get_tokenizer()					,     image_processor=self.get_image_processor()			)
										processor.save_pretrained(self.tmpdirname			)

										__lowerCAmelCase       					=    self.get_tokenizer(bos_token="(BOS)"					,     eos_token="(EOS)"			)
										__lowerCAmelCase       					=    self.get_image_processor(do_normalize=__a					,     padding_value=1.0			)

										__lowerCAmelCase       					=    CLIPProcessor.from_pretrained(
										    self.tmpdirname					,     bos_token="(BOS)"					,     eos_token="(EOS)"					,     do_normalize=__a					,     padding_value=1.0			)

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

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

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    CLIPProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    self.prepare_image_inputs()

										__lowerCAmelCase       					=    image_processor(__a					,     return_tensors="np"			)
										__lowerCAmelCase       					=    processor(images=__a					,     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     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    CLIPProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    "lower newer"

										__lowerCAmelCase       					=    processor(text=__a			)

										__lowerCAmelCase       					=    tokenizer(__a			)

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

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    CLIPProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    "lower newer"
										__lowerCAmelCase       					=    self.prepare_image_inputs()

										__lowerCAmelCase       					=    processor(text=__a					,     images=__a			)

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

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

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    CLIPProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

										__lowerCAmelCase       					=    processor.batch_decode(__a			)
										__lowerCAmelCase       					=    tokenizer.batch_decode(__a			)

										self.assertListEqual(__a					,     __a			)



							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    CLIPProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    "lower newer"
										__lowerCAmelCase       					=    self.prepare_image_inputs()

										__lowerCAmelCase       					=    processor(text=__a					,     images=__a			)

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








"""simple docstring"""


import tensorflow as tf

from ...tf_utils import shape_list
class 						_UpperCamelCase						(     tf.keras.layers.Layer	):
							'''simple docstring'''







							def __init__(  self					,     __a					,     __a					,     __a					,     __a					,     __a=1					,     __a=False					,     **__a			):
										super().__init__(**__a			)

										__lowerCAmelCase       					=    vocab_size
										__lowerCAmelCase       					=    d_embed
										__lowerCAmelCase       					=    d_proj

										__lowerCAmelCase       					=    cutoffs + [vocab_size]
										__lowerCAmelCase       					=    [0] + self.cutoffs
										__lowerCAmelCase       					=    div_val

										__lowerCAmelCase       					=    self.cutoffs[0]
										__lowerCAmelCase       					=    len(self.cutoffs			) - 1
										__lowerCAmelCase       					=    self.shortlist_size + self.n_clusters
										__lowerCAmelCase       					=    keep_order

										__lowerCAmelCase       					=    []
										__lowerCAmelCase       					=    []

							def     snake_case       (  self					,     __a			):
										if self.n_clusters > 0:
													__lowerCAmelCase       					=    self.add_weight(
													    shape=(self.n_clusters, self.d_embed)					,     initializer="zeros"					,     trainable=__a					,     name="cluster_weight"			)
													__lowerCAmelCase       					=    self.add_weight(
													    shape=(self.n_clusters,)					,     initializer="zeros"					,     trainable=__a					,     name="cluster_bias"			)

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

																__lowerCAmelCase       					=    self.add_weight(
																    shape=(d_emb_i, self.d_proj)					,     initializer="zeros"					,     trainable=__a					,     name=f"out_projs_._{i}"			)
																self.out_projs.append(__a			)
																__lowerCAmelCase       					=    self.add_weight(
																    shape=(r_idx - l_idx, d_emb_i)					,     initializer="zeros"					,     trainable=__a					,     name=f"out_layers_._{i}_._weight"					,     )
																__lowerCAmelCase       					=    self.add_weight(
																    shape=(r_idx - l_idx,)					,     initializer="zeros"					,     trainable=__a					,     name=f"out_layers_._{i}_._bias"					,     )
																self.out_layers.append((weight, bias)			)
										super().build(__a			)

							@staticmethod
							def     snake_case       (  __a					,     __a					,     __a					,     __a=None			):
										__lowerCAmelCase       					=    x
										if proj is not None:
													__lowerCAmelCase       					=    tf.einsum("ibd,ed->ibe"					,     __a					,     __a			)
										return tf.einsum("ibd,nd->ibn"					,     __a					,     __a			) + b

							@staticmethod
							def     snake_case       (  __a					,     __a			):
										__lowerCAmelCase       					=    shape_list(__a			)
										__lowerCAmelCase       					=    tf.range(lp_size[0]					,     dtype=target.dtype			)
										__lowerCAmelCase       					=    tf.stack([r, target]					,     1			)
										return tf.gather_nd(__a					,     __a			)



							def     snake_case       (  self					,     __a					,     __a					,     __a=True					,     __a=False			):
										__lowerCAmelCase       					=    0
										if self.n_clusters == 0:
													__lowerCAmelCase       					=    self._logit(__a					,     self.out_layers[0][0]					,     self.out_layers[0][1]					,     self.out_projs[0]			)
													if target is not None:
																__lowerCAmelCase       					=    tf.nn.sparse_softmax_cross_entropy_with_logits(labels=__a					,     logits=__a			)
													__lowerCAmelCase       					=    tf.nn.log_softmax(__a					,     axis=-1			)
										else:
													__lowerCAmelCase       					=    shape_list(__a			)
													__lowerCAmelCase       					=    []
													__lowerCAmelCase       					=    tf.zeros(hidden_sizes[:2]			)
													for i in range(len(self.cutoffs			)			):
																__lowerCAmelCase					,			__lowerCAmelCase       					=    self.cutoff_ends[i], self.cutoff_ends[i + 1]
																if target is not None:
																			__lowerCAmelCase       					=    (target >= l_idx) & (target < r_idx)
																			__lowerCAmelCase       					=    tf.where(__a			)
																			__lowerCAmelCase       					=    tf.boolean_mask(__a					,     __a			) - l_idx

																if self.div_val == 1:
																			__lowerCAmelCase       					=    self.out_layers[0][0][l_idx:r_idx]
																			__lowerCAmelCase       					=    self.out_layers[0][1][l_idx:r_idx]
																else:
																			__lowerCAmelCase       					=    self.out_layers[i][0]
																			__lowerCAmelCase       					=    self.out_layers[i][1]

																if i == 0:
																			__lowerCAmelCase       					=    tf.concat([cur_W, self.cluster_weight]					,     0			)
																			__lowerCAmelCase       					=    tf.concat([cur_b, self.cluster_bias]					,     0			)

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

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

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

										return out




