
'''simple docstring'''

from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


UpperCAmelCase__ :			Optional[int]											=		logging.get_logger(__name__)







def 	A  (   UpperCamelCase_       :  Union[tf.Tensor, np.ndarray]   )       ->							List[int]:







			'''simple docstring'''



			if isinstance(UpperCamelCase_    ,						np.ndarray   ):
						return list(tensor.shape   )

			lowerCAmelCase__										=				tf.shape(UpperCamelCase_   )

			if tensor.shape == tf.TensorShape(UpperCamelCase_   ):
						return dynamic

			lowerCAmelCase__										=				tensor.shape.as_list()

			return [dynamic[i] if s is None else s for i, s in enumerate(UpperCamelCase_   )]







def 	A  (   UpperCamelCase_       :  tf.Tensor    ,						UpperCamelCase_       :  Optional[int] = None    ,						UpperCamelCase_       :  Optional[str] = None   )       ->							tf.Tensor:







			'''simple docstring'''



			return tf.nn.softmax(logits=logits + 1E-9    ,						axis=UpperCamelCase_    ,						name=UpperCamelCase_   )







def 	A  (   UpperCamelCase_       :  int    ,						UpperCamelCase_       :  int    ,						UpperCamelCase_       :  List[Any]    ,						UpperCamelCase_       :  str=1E-5    ,						UpperCamelCase_       :  Dict=-1   )       ->							int:







			'''simple docstring'''



			if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(UpperCamelCase_    ,						UpperCamelCase_   ):
						raise NotImplementedError("Only 1D weight and bias tensors are supported for now, with only a single axis."   )

			# Get mean and variance on the axis to be normalized
			lowerCAmelCase__						,lowerCAmelCase__										=				tf.nn.moments(UpperCamelCase_    ,						axes=[axis]    ,						keepdims=UpperCamelCase_   )

			if axis != -1:
						# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
						# on every dimension except axis
						lowerCAmelCase__										=				[1] * inputs.shape.rank
						lowerCAmelCase__										=				shape_list(UpperCamelCase_   )[axis]
						lowerCAmelCase__										=				tf.reshape(UpperCamelCase_    ,						UpperCamelCase_   )
						lowerCAmelCase__										=				tf.reshape(UpperCamelCase_    ,						UpperCamelCase_   )

			# Compute layer normalization using the batch_normalization
			# function.
			lowerCAmelCase__										=				tf.nn.batch_normalization(
			    UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_    ,						offset=UpperCamelCase_    ,						scale=UpperCamelCase_    ,						variance_epsilon=UpperCamelCase_    ,						)
			return outputs







def 	A  (   UpperCamelCase_       :  int    ,						UpperCamelCase_       :  List[str]=0    ,						UpperCamelCase_       :  str=-1   )       ->							Union[str, Any]:







			'''simple docstring'''



			if end_dim < 0:
						end_dim += input.shape.rank
			if start_dim < 0:
						start_dim += input.shape.rank

			if start_dim == end_dim:
						return input

			lowerCAmelCase__										=				tf.shape(UpperCamelCase_   )
			lowerCAmelCase__										=				tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]   )
			lowerCAmelCase__										=				tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]    ,						axis=0   )
			return tf.reshape(UpperCamelCase_    ,						UpperCamelCase_   )







def 	A  (   UpperCamelCase_       :  tf.Tensor   )       ->							tf.Tensor:







			'''simple docstring'''



			if not isinstance(UpperCamelCase_    ,						tf.Tensor   ):
						lowerCAmelCase__										=				tf.convert_to_tensor(UpperCamelCase_   )  # Catches stray NumPy inputs
			if encoder_attention_mask.shape.rank == 3:
						lowerCAmelCase__										=				encoder_attention_mask[:, None, :, :]
			if encoder_attention_mask.shape.rank == 2:
						lowerCAmelCase__										=				encoder_attention_mask[:, None, None, :]
			# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
			# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
			# /transformer/transformer_layers.py#L270
			# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
			# encoder_extended_attention_mask.transpose(-1, -2))
			lowerCAmelCase__										=				(
			    tf.cast(1    ,						encoder_attention_mask.dtype   ) - encoder_extended_attention_mask
			) * encoder_extended_attention_mask.dtype.min

			return encoder_extended_attention_mask







def 	A  (   UpperCamelCase_       :  tf.Tensor    ,						UpperCamelCase_       :  int    ,						UpperCamelCase_       :  str = "input_ids"   )       ->							None:







			'''simple docstring'''



			tf.debugging.assert_less(
			    UpperCamelCase_    ,						tf.cast(UpperCamelCase_    ,						dtype=tensor.dtype   )    ,						message=(
			        F"""The maximum value of {tensor_name} ({tf.math.reduce_max(UpperCamelCase_   )}) must be smaller than the embedding """
			        F"""layer's input dimension ({embed_dim}). The likely cause is some problem at tokenization time."""
			    )    ,						)







def 	A  (   UpperCamelCase_       :  Any    ,						UpperCamelCase_       :  List[Any]    ,						UpperCamelCase_       :  List[Any]   )       ->							List[Any]:







			'''simple docstring'''



			lowerCAmelCase__										=				6_45_12
			# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
			# because in that case even chunking the array would not make the saving
			# possible.
			lowerCAmelCase__										=				[x for x in data if len(UpperCamelCase_   ) > HDF5_OBJECT_HEADER_LIMIT]

			# Expecting this to never be true.
			if bad_attributes:
						raise RuntimeError(
						    "The following attributes cannot be saved to HDF5 file because "
						    F"""they are larger than {HDF5_OBJECT_HEADER_LIMIT} """
						    F"""bytes: {bad_attributes}"""   )

			lowerCAmelCase__										=				np.asarray(UpperCamelCase_   )

			lowerCAmelCase__										=				1
			lowerCAmelCase__										=				np.array_split(UpperCamelCase_    ,						UpperCamelCase_   )

			# This will never loop forever thanks to the test above.
			while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data   ):
						num_chunks += 1
						lowerCAmelCase__										=				np.array_split(UpperCamelCase_    ,						UpperCamelCase_   )

			if num_chunks > 1:
						for chunk_id, chunk_data in enumerate(UpperCamelCase_   ):
									lowerCAmelCase__										=				chunk_data
			else:
						lowerCAmelCase__										=				data







def 	A  (   UpperCamelCase_       :  str    ,						UpperCamelCase_       :  int   )       ->							Optional[Any]:







			'''simple docstring'''



			if name in group.attrs:
						lowerCAmelCase__										=				[n.decode("utf8"   ) if hasattr(UpperCamelCase_    ,						"decode"   ) else n for n in group.attrs[name]]
			else:
						lowerCAmelCase__										=				[]
						lowerCAmelCase__										=				0
						while "%s%d" % (name, chunk_id) in group.attrs:
									data.extend(
									    [n.decode("utf8"   ) if hasattr(UpperCamelCase_    ,						"decode"   ) else n for n in group.attrs["%s%d" % (name, chunk_id)]]   )
									chunk_id += 1
			return data







def 	A  (   UpperCamelCase_       :  Dict   )       ->							List[str]:







			'''simple docstring'''



			def _expand_single_ad_tensor(UpperCamelCase_       :  Optional[Any]   ):
						if isinstance(UpperCamelCase_    ,						tf.Tensor   ) and t.shape.rank == 1:
									return tf.expand_dims(UpperCamelCase_    ,						axis=-1   )
						return t

			return tf.nest.map_structure(_expand_single_ad_tensor    ,						UpperCamelCase_   )











# Copyright 2023 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.
import numpy as np
import torch

from ..models.clipseg import CLIPSegForImageSegmentation
from ..utils import is_vision_available, requires_backends
from .base import PipelineTool


if is_vision_available():
     from PIL import Image

class     __a(	_a  ):






    """simple docstring"""





    lowerCAmelCase         = (
        '''This is a tool that creates a segmentation mask of an image according to a label. It cannot create an image.'''
        '''It takes two arguments named `image` which should be the original image, and `label` which should be a text '''
        '''describing the elements what should be identified in the segmentation mask. The tool returns the mask.'''
    )
    lowerCAmelCase         = '''CIDAS/clipseg-rd64-refined'''
    lowerCAmelCase         = '''image_segmenter'''
    lowerCAmelCase         = CLIPSegForImageSegmentation

    lowerCAmelCase         = ['''image''', '''text''']
    lowerCAmelCase         = ['''image''']





    def __init__( self  ,*_SCREAMING_SNAKE_CASE  ,**_SCREAMING_SNAKE_CASE    )					->						Dict:
         requires_backends(self  ,['''vision''']    )
         super().__init__(*_SCREAMING_SNAKE_CASE  ,**_SCREAMING_SNAKE_CASE    )





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE  ,_SCREAMING_SNAKE_CASE    )					->						Tuple:
         return self.pre_processor(text=[label]  ,images=[image]  ,padding=_SCREAMING_SNAKE_CASE  ,return_tensors='''pt'''    )





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						str:
         with torch.no_grad():
              UpperCAmelCase_     :				Dict  =     self.model(**_SCREAMING_SNAKE_CASE    ).logits
         return logits





    def 				a__ ( self  ,_SCREAMING_SNAKE_CASE    )					->						Dict:
         UpperCAmelCase_     :				Dict  =     outputs.cpu().detach().numpy()
         UpperCAmelCase_     :				Any  =     0
         UpperCAmelCase_     :				List[Any]  =     1
         return Image.fromarray((array * 255).astype(np.uinta    )    )