


"""simple docstring"""


import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)
class snake_case      (  unittest.TestCase):







		def  a_ (					self      :       int		)       ->						Dict:





						'''simple docstring'''







						_A					  =			["a", "b", "c"]

						# Defaults to last layer if both are None
						_A  ,		_A					  =			get_aligned_output_features_output_indices(a__    ,   a__    ,   a__		)
						self.assertEqual(a__    ,   ["c"]		)
						self.assertEqual(a__    ,   [2]		)

						# Out indices set to match out features
						_A  ,		_A					  =			get_aligned_output_features_output_indices(["a", "c"]    ,   a__    ,   a__		)
						self.assertEqual(a__    ,   ["a", "c"]		)
						self.assertEqual(a__    ,   [0, 2]		)

						# Out features set to match out indices
						_A  ,		_A					  =			get_aligned_output_features_output_indices(a__    ,   [0, 2]    ,   a__		)
						self.assertEqual(a__    ,   ["a", "c"]		)
						self.assertEqual(a__    ,   [0, 2]		)

						# Out features selected from negative indices
						_A  ,		_A					  =			get_aligned_output_features_output_indices(a__    ,   [-3, -1]    ,   a__		)
						self.assertEqual(a__    ,   ["a", "c"]		)
						self.assertEqual(a__    ,   [-3, -1]		)







		def  a_ (					self      :       List[Any]		)       ->						List[str]:





						'''simple docstring'''







						with self.assertRaises(a__		):
										verify_out_features_out_indices(["a", "b"]    ,   (0, 1)    ,   a__		)

						# Out features must be a list
						with self.assertRaises(a__		):
										verify_out_features_out_indices(("a", "b")    ,   (0, 1)    ,   ["a", "b"]		)

						# Out features must be a subset of stage names
						with self.assertRaises(a__		):
										verify_out_features_out_indices(["a", "b"]    ,   (0, 1)    ,   ["a"]		)

						# Out indices must be a list or tuple
						with self.assertRaises(a__		):
										verify_out_features_out_indices(a__    ,   0    ,   ["a", "b"]		)

						# Out indices must be a subset of stage names
						with self.assertRaises(a__		):
										verify_out_features_out_indices(a__    ,   (0, 1)    ,   ["a"]		)

						# Out features and out indices must be the same length
						with self.assertRaises(a__		):
										verify_out_features_out_indices(["a", "b"]    ,   (0,)    ,   ["a", "b", "c"]		)

						# Out features should match out indices
						with self.assertRaises(a__		):
										verify_out_features_out_indices(["a", "b"]    ,   (0, 2)    ,   ["a", "b", "c"]		)

						# Out features and out indices should be in order
						with self.assertRaises(a__		):
										verify_out_features_out_indices(["b", "a"]    ,   (0, 1)    ,   ["a", "b"]		)

						# Check passes with valid inputs
						verify_out_features_out_indices(["a", "b", "d"]    ,   (0, 1, -1)    ,   ["a", "b", "c", "d"]		)







		def  a_ (					self      :       Union[str, Any]		)       ->						Tuple:





						'''simple docstring'''







						_A					  =			BackboneMixin()

						_A					  =			["a", "b", "c"]
						_A					  =			["a", "c"]
						_A					  =			[0, 2]

						# Check that the output features and indices are set correctly
						self.assertEqual(backbone.out_features    ,   ["a", "c"]		)
						self.assertEqual(backbone.out_indices    ,   [0, 2]		)

						# Check out features and indices are updated correctly
						_A					  =			["a", "b"]
						self.assertEqual(backbone.out_features    ,   ["a", "b"]		)
						self.assertEqual(backbone.out_indices    ,   [0, 1]		)

						_A					  =			[-3, -1]
						self.assertEqual(backbone.out_features    ,   ["a", "c"]		)
						self.assertEqual(backbone.out_indices    ,   [-3, -1]		)



"""simple docstring"""


import numpy as np






def      a__ (				__lowercase     ,			__lowercase   )	->	np.ndarray:
				return np.where(vector > 0     ,			__lowercase     ,			(alpha * (np.exp(__lowercase   ) - 1))   )


if __name__ == "__main__":
		import doctest

		doctest.testmod()