





import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import ChineseCLIPImageProcessor



class    A__  (			unittest.TestCase     ):





      def __init__(					self			,				A_			,				A_=7			,				A_=3			,				A_=18			,				A_=30			,				A_=400			,				A_=True			,				A_=None			,				A_=True			,				A_=None			,				A_=True			,				A_=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]			,				A_=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]			,				A_=True			,				):
       '''simple docstring'''




       UpperCamelCase      :   List[str]			      =  size if size is not None else {"height": 224, "width": 224}
       UpperCamelCase      :   Optional[int]			      =  crop_size if crop_size is not None else {"height": 18, "width": 18}
       UpperCamelCase      :   str			      =  parent
       UpperCamelCase      :   List[str]			      =  batch_size
       UpperCamelCase      :   Tuple			      =  num_channels
       UpperCamelCase      :   List[str]			      =  image_size
       UpperCamelCase      :   Optional[int]			      =  min_resolution
       UpperCamelCase      :   int			      =  max_resolution
       UpperCamelCase      :   str			      =  do_resize
       UpperCamelCase      :   Optional[int]			      =  size
       UpperCamelCase      :   List[str]			      =  do_center_crop
       UpperCamelCase      :   str			      =  crop_size
       UpperCamelCase      :   Dict			      =  do_normalize
       UpperCamelCase      :   str			      =  image_mean
       UpperCamelCase      :   int			      =  image_std
       UpperCamelCase      :   Any			      =  do_convert_rgb





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return {
           "do_resize": self.do_resize,
           "size": self.size,
           "do_center_crop": self.do_center_crop,
           "crop_size": self.crop_size,
           "do_normalize": self.do_normalize,
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_convert_rgb": self.do_convert_rgb,
       }





      def 			__UpperCamelCase(					self			,				A_=False			,				A_=False			,				A_=False  ):
       '''simple docstring'''




       assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

       if equal_resolution:
        UpperCamelCase      :   int			      =  []
        for i in range(self.batch_size  ):
         image_inputs.append(
             np.random.randint(
                 255			,				size=(self.num_channels, self.max_resolution, self.max_resolution)			,				dtype=np.uinta  )  )
       else:
        UpperCamelCase      :   Union[str, Any]			      =  []
        for i in range(self.batch_size  ):
         UpperCamelCase      ,       UpperCamelCase      :   Optional[int]			      =  np.random.choice(np.arange(self.min_resolution			,				self.max_resolution  )			,				2  )
         image_inputs.append(np.random.randint(255			,				size=(self.num_channels, width, height)			,				dtype=np.uinta  )  )

       if not numpify and not torchify:
        # PIL expects the channel dimension as last dimension
        UpperCamelCase      :   List[Any]			      =  [Image.fromarray(np.moveaxis(A_			,				0			,				-1  )  ) for x in image_inputs]

       if torchify:
        UpperCamelCase      :   str			      =  [torch.from_numpy(A_  ) for x in image_inputs]

       return image_inputs



@require_torch
@require_vision
class    A__  (			__snake_case			,  unittest.TestCase     ):
      _UpperCAmelCase      :List[Any]		       =  ChineseCLIPImageProcessor if is_vision_available() else None





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   int			      =  ChineseCLIPImageProcessingTester(self			,				do_center_crop=A_  )





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return self.image_processor_tester.prepare_image_processor_dict()





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[Any]			      =  self.image_processing_class(**self.image_processor_dict  )
       self.assertTrue(hasattr(A_			,				"do_resize"  )  )
       self.assertTrue(hasattr(A_			,				"size"  )  )
       self.assertTrue(hasattr(A_			,				"do_center_crop"  )  )
       self.assertTrue(hasattr(A_			,				"center_crop"  )  )
       self.assertTrue(hasattr(A_			,				"do_normalize"  )  )
       self.assertTrue(hasattr(A_			,				"image_mean"  )  )
       self.assertTrue(hasattr(A_			,				"image_std"  )  )
       self.assertTrue(hasattr(A_			,				"do_convert_rgb"  )  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  self.image_processing_class.from_dict(self.image_processor_dict  )
       self.assertEqual(image_processor.size			,				{"height": 224, "width": 224}  )
       self.assertEqual(image_processor.crop_size			,				{"height": 18, "width": 18}  )

       UpperCamelCase      :   int			      =  self.image_processing_class.from_dict(self.image_processor_dict			,				size=42			,				crop_size=84  )
       self.assertEqual(image_processor.size			,				{"shortest_edge": 42}  )
       self.assertEqual(image_processor.crop_size			,				{"height": 84, "width": 84}  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       pass





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[Any]			      =  self.image_processing_class(**self.image_processor_dict  )
       # create random PIL images
       UpperCamelCase      :   List[Any]			      =  self.image_processor_tester.prepare_inputs(equal_resolution=A_  )
       for image in image_inputs:
        self.assertIsInstance(A_			,				Image.Image  )

       # Test not batched input
       UpperCamelCase      :   List[str]			      =  image_processing(image_inputs[0]			,				return_tensors="pt"  ).pixel_values
       self.assertEqual(
           encoded_images.shape			,				(
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )			,				)

       # Test batched
       UpperCamelCase      :   Tuple			      =  image_processing(A_			,				return_tensors="pt"  ).pixel_values
       self.assertEqual(
           encoded_images.shape			,				(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   int			      =  self.image_processing_class(**self.image_processor_dict  )
       # create random numpy tensors
       UpperCamelCase      :   int			      =  self.image_processor_tester.prepare_inputs(equal_resolution=A_			,				numpify=A_  )
       for image in image_inputs:
        self.assertIsInstance(A_			,				np.ndarray  )

       # Test not batched input
       UpperCamelCase      :   Tuple			      =  image_processing(image_inputs[0]			,				return_tensors="pt"  ).pixel_values
       self.assertEqual(
           encoded_images.shape			,				(
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )			,				)

       # Test batched
       UpperCamelCase      :   Tuple			      =  image_processing(A_			,				return_tensors="pt"  ).pixel_values
       self.assertEqual(
           encoded_images.shape			,				(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  self.image_processing_class(**self.image_processor_dict  )
       # create random PyTorch tensors
       UpperCamelCase      :   Optional[int]			      =  self.image_processor_tester.prepare_inputs(equal_resolution=A_			,				torchify=A_  )
       for image in image_inputs:
        self.assertIsInstance(A_			,				torch.Tensor  )

       # Test not batched input
       UpperCamelCase      :   Any			      =  image_processing(image_inputs[0]			,				return_tensors="pt"  ).pixel_values
       self.assertEqual(
           encoded_images.shape			,				(
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )			,				)

       # Test batched
       UpperCamelCase      :   Optional[int]			      =  image_processing(A_			,				return_tensors="pt"  ).pixel_values
       self.assertEqual(
           encoded_images.shape			,				(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )			,				)



@require_torch
@require_vision
class    A__  (			__snake_case			,  unittest.TestCase     ):
      _UpperCAmelCase      :Tuple		       =  ChineseCLIPImageProcessor if is_vision_available() else None





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  ChineseCLIPImageProcessingTester(self			,				num_channels=4			,				do_center_crop=A_  )
       UpperCamelCase      :   Dict			      =  3





      @property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return self.image_processor_tester.prepare_image_processor_dict()





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Tuple			      =  self.image_processing_class(**self.image_processor_dict  )
       self.assertTrue(hasattr(A_			,				"do_resize"  )  )
       self.assertTrue(hasattr(A_			,				"size"  )  )
       self.assertTrue(hasattr(A_			,				"do_center_crop"  )  )
       self.assertTrue(hasattr(A_			,				"center_crop"  )  )
       self.assertTrue(hasattr(A_			,				"do_normalize"  )  )
       self.assertTrue(hasattr(A_			,				"image_mean"  )  )
       self.assertTrue(hasattr(A_			,				"image_std"  )  )
       self.assertTrue(hasattr(A_			,				"do_convert_rgb"  )  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       pass





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[Any]			      =  self.image_processing_class(**self.image_processor_dict  )
       # create random PIL images
       UpperCamelCase      :   Dict			      =  self.image_processor_tester.prepare_inputs(equal_resolution=A_  )
       for image in image_inputs:
        self.assertIsInstance(A_			,				Image.Image  )

       # Test not batched input
       UpperCamelCase      :   Optional[int]			      =  image_processing(image_inputs[0]			,				return_tensors="pt"  ).pixel_values
       self.assertEqual(
           encoded_images.shape			,				(
               1,
               self.expected_encoded_image_num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )			,				)

       # Test batched
       UpperCamelCase      :   Optional[int]			      =  image_processing(A_			,				return_tensors="pt"  ).pixel_values
       self.assertEqual(
           encoded_images.shape			,				(
               self.image_processor_tester.batch_size,
               self.expected_encoded_image_num_channels,
               self.image_processor_tester.crop_size["height"],
               self.image_processor_tester.crop_size["width"],
           )			,				)







from random import shuffle

import tensorflow as tf
from numpy import array



def 						A_							(	_lowerCAmelCase				,  _lowerCAmelCase	)		->					Optional[Any]:
 UpperCamelCase      :   List[Any]			      =  int(_lowerCAmelCase	)
 assert noofclusters < len(_lowerCAmelCase	)

 # Find out the dimensionality
 UpperCamelCase      :   str			      =  len(vectors[0]	)

 # Will help select random centroids from among the available vectors
 UpperCamelCase      :   List[str]			      =  list(range(len(_lowerCAmelCase	)	)	)
 shuffle(_lowerCAmelCase	)

 # GRAPH OF COMPUTATION
 # We initialize a new graph and set it as the default during each run
 # of this algorithm. This ensures that as this function is called
 # multiple times, the default graph doesn't keep getting crowded with
 # unused ops and Variables from previous function calls.

 UpperCamelCase      :   Any			      =  tf.Graph()

 with graph.as_default():
  # SESSION OF COMPUTATION

  UpperCamelCase      :   Union[str, Any]			      =  tf.Session()

  ##CONSTRUCTING THE ELEMENTS OF COMPUTATION

  ##First lets ensure we have a Variable vector for each centroid,
  ##initialized to one of the vectors from the available data points
  UpperCamelCase      :   Optional[int]			      =  [
      tf.Variable(vectors[vector_indices[i]]	) for i in range(_lowerCAmelCase	)
  ]
  ##These nodes will assign the centroid Variables the appropriate
  ##values
  UpperCamelCase      :   Tuple			      =  tf.placeholder("float64"				,  [dim]	)
  UpperCamelCase      :   str			      =  []
  for centroid in centroids:
   cent_assigns.append(tf.assign(_lowerCAmelCase				,  _lowerCAmelCase	)	)

  ##Variables for cluster assignments of individual vectors(initialized
  ##to 0 at first)
  UpperCamelCase      :   List[str]			      =  [tf.Variable(0	) for i in range(len(_lowerCAmelCase	)	)]
  ##These nodes will assign an assignment Variable the appropriate
  ##value
  UpperCamelCase      :   Any			      =  tf.placeholder("int32"	)
  UpperCamelCase      :   Optional[int]			      =  []
  for assignment in assignments:
   cluster_assigns.append(tf.assign(_lowerCAmelCase				,  _lowerCAmelCase	)	)

  ##Now lets construct the node that will compute the mean
  # The placeholder for the input
  UpperCamelCase      :   Tuple			      =  tf.placeholder("float"				,  [None, dim]	)
  # The Node/op takes the input and computes a mean along the 0th
  # dimension, i.e. the list of input vectors
  UpperCamelCase      :   List[str]			      =  tf.reduce_mean(_lowerCAmelCase				,  0	)

  ##Node for computing Euclidean distances
  # Placeholders for input
  UpperCamelCase      :   Optional[int]			      =  tf.placeholder("float"				,  [dim]	)
  UpperCamelCase      :   Any			      =  tf.placeholder("float"				,  [dim]	)
  UpperCamelCase      :   List[str]			      =  tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(_lowerCAmelCase				,  _lowerCAmelCase	)				,  2	)	)	)

  ##This node will figure out which cluster to assign a vector to,
  ##based on Euclidean distances of the vector from the centroids.
  # Placeholder for input
  UpperCamelCase      :   Tuple			      =  tf.placeholder("float"				,  [noofclusters]	)
  UpperCamelCase      :   str			      =  tf.argmin(_lowerCAmelCase				,  0	)

  ##INITIALIZING STATE VARIABLES

  ##This will help initialization of all Variables defined with respect
  ##to the graph. The Variable-initializer should be defined after
  ##all the Variables have been constructed, so that each of them
  ##will be included in the initialization.
  UpperCamelCase      :   Optional[Any]			      =  tf.initialize_all_variables()

  # Initialize all variables
  sess.run(_lowerCAmelCase	)

  ##CLUSTERING ITERATIONS

  # Now perform the Expectation-Maximization steps of K-Means clustering
  # iterations. To keep things simple, we will only do a set number of
  # iterations, instead of using a Stopping Criterion.
  UpperCamelCase      :   Any			      =  100
  for _ in range(_lowerCAmelCase	):
   ##EXPECTATION STEP
   ##Based on the centroid locations till last iteration, compute
   ##the _expected_ centroid assignments.
   # Iterate over each vector
   for vector_n in range(len(_lowerCAmelCase	)	):
    UpperCamelCase      :   Dict			      =  vectors[vector_n]
    # Compute Euclidean distance between this vector and each
    # centroid. Remember that this list cannot be named
    #'centroid_distances', since that is the input to the
    # cluster assignment node.
    UpperCamelCase      :   Optional[Any]			      =  [
        sess.run(_lowerCAmelCase				,  feed_dict={va: vect, va: sess.run(_lowerCAmelCase	)}	)
        for centroid in centroids
    ]
    # Now use the cluster assignment node, with the distances
    # as the input
    UpperCamelCase      :   Tuple			      =  sess.run(
        _lowerCAmelCase				,  feed_dict={centroid_distances: distances}	)
    # Now assign the value to the appropriate state variable
    sess.run(
        cluster_assigns[vector_n]				,  feed_dict={assignment_value: assignment}	)

   ##MAXIMIZATION STEP
   # Based on the expected state computed from the Expectation Step,
   # compute the locations of the centroids so as to maximize the
   # overall objective of minimizing within-cluster Sum-of-Squares
   for cluster_n in range(_lowerCAmelCase	):
    # Collect all the vectors assigned to this cluster
    UpperCamelCase      :   str			      =  [
        vectors[i]
        for i in range(len(_lowerCAmelCase	)	)
        if sess.run(assignments[i]	) == cluster_n
    ]
    # Compute new centroid location
    UpperCamelCase      :   Optional[int]			      =  sess.run(
        _lowerCAmelCase				,  feed_dict={mean_input: array(_lowerCAmelCase	)}	)
    # Assign value to appropriate variable
    sess.run(
        cent_assigns[cluster_n]				,  feed_dict={centroid_value: new_location}	)

        # Return centroids and assignments
  UpperCamelCase      :   Union[str, Any]			      =  sess.run(_lowerCAmelCase	)
  UpperCamelCase      :   Tuple			      =  sess.run(_lowerCAmelCase	)
  return centroids, assignments
