



"""simple docstring"""






from random import shuffle

import tensorflow as tf
from numpy import array




def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_	)						->				List[Any]:
  _snake_case   	=      int(lowerCAmelCase_	)
  assert noofclusters < len(lowerCAmelCase_	)

  # Find out the dimensionality
  _snake_case   	=      len(vectors[0]	)

  # Will help select random centroids from among the available vectors
  _snake_case   	=      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.

  _snake_case   	=      tf.Graph()

  with graph.as_default():
    # SESSION OF COMPUTATION

    _snake_case   	=      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
    _snake_case   	=      [
        tf.Variable(vectors[vector_indices[i]]	) for i in range(lowerCAmelCase_	)
    ]
    ##These nodes will assign the centroid Variables the appropriate
    ##values
    _snake_case   	=      tf.placeholder('''float64'''  ,						[dim]	)
    _snake_case   	=      []
    for centroid in centroids:
      cent_assigns.append(tf.assign(lowerCAmelCase_  ,						lowerCAmelCase_	)	)

    ##Variables for cluster assignments of individual vectors(initialized
    ##to 0 at first)
    _snake_case   	=      [tf.Variable(0	) for i in range(len(lowerCAmelCase_	)	)]
    ##These nodes will assign an assignment Variable the appropriate
    ##value
    _snake_case   	=      tf.placeholder('''int32'''	)
    _snake_case   	=      []
    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
    _snake_case   	=      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
    _snake_case   	=      tf.reduce_mean(lowerCAmelCase_  ,						0	)

    ##Node for computing Euclidean distances
    # Placeholders for input
    _snake_case   	=      tf.placeholder('''float'''  ,						[dim]	)
    _snake_case   	=      tf.placeholder('''float'''  ,						[dim]	)
    _snake_case   	=      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
    _snake_case   	=      tf.placeholder('''float'''  ,						[noofclusters]	)
    _snake_case   	=      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.
    _snake_case   	=      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.
    _snake_case   	=      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_	)	):
        _snake_case   	=      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.
        _snake_case   	=      [
            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
        _snake_case   	=      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
        _snake_case   	=      [
            vectors[i]
            for i in range(len(lowerCAmelCase_	)	)
            if sess.run(assignments[i]	) == cluster_n
        ]
        # Compute new centroid location
        _snake_case   	=      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
    _snake_case   	=      sess.run(lowerCAmelCase_	)
    _snake_case   	=      sess.run(lowerCAmelCase_	)
    return centroids, assignments










"""simple docstring"""






# 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.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool



class     UpperCAmelCase    (	__SCREAMING_SNAKE_CASE  ):
   A__		:	str           =  '''openai/whisper-base'''
   A__		:	List[Any]           =  (
       '''This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the '''
       '''transcribed text.'''
   )
   A__		:	str           =  '''transcriber'''
   A__		:	List[Any]           =  WhisperProcessor
   A__		:	Optional[int]           =  WhisperForConditionalGeneration

   A__		:	List[str]           =  ['''audio''']
   A__		:	Optional[int]           =  ['''text''']



   def    __UpperCAmelCase    (       self    :	Tuple							,       __lowerCamelCase    :	List[Any]				):



     """simple docstring"""
     return self.pre_processor(__lowerCamelCase							,       return_tensors='''pt'''				).input_features



   def    __UpperCAmelCase    (       self    :	Optional[int]							,       __lowerCamelCase    :	List[str]				):



     """simple docstring"""
     return self.model.generate(inputs=__lowerCamelCase				)





   def    __UpperCAmelCase    (       self    :	List[str]							,       __lowerCamelCase    :	int				):



     """simple docstring"""
     return self.pre_processor.batch_decode(__lowerCamelCase							,       skip_special_tokens=__lowerCamelCase				)[0]





