"""simple docstring"""






from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
						from transformers import (
						    TFAutoModel,
						    TFAutoModelForCausalLM,
						    TFAutoModelForMaskedLM,
						    TFAutoModelForPreTraining,
						    TFAutoModelForQuestionAnswering,
						    TFAutoModelForSeqaSeqLM,
						    TFAutoModelForSequenceClassification,
						    TFAutoModelForTableQuestionAnswering,
						    TFAutoModelForTokenClassification,
						    TFAutoModelWithLMHead,
						    TFBertForMaskedLM,
						    TFBertForPreTraining,
						    TFBertForQuestionAnswering,
						    TFBertForSequenceClassification,
						    TFBertModel,
						    TFFunnelBaseModel,
						    TFFunnelModel,
						    TFGPTaLMHeadModel,
						    TFRobertaForMaskedLM,
						    TFTaForConditionalGeneration,
						    TFTapasForQuestionAnswering,
						)
						from transformers.models.auto.modeling_tf_auto import (
						    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
						    TF_MODEL_FOR_MASKED_LM_MAPPING,
						    TF_MODEL_FOR_PRETRAINING_MAPPING,
						    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
						    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
						    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
						    TF_MODEL_MAPPING,
						)
						from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
						from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
						from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST
						from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST
class 				snake_case       ( __UpperCAmelCase				):




					"""simple docstring"""

					snake_case__				    = "new-model"


if is_tf_available():
						class 				snake_case       ( __UpperCAmelCase				):




											"""simple docstring"""

											snake_case__				    = NewModelConfig
@require_tf
class 				snake_case       ( unittest.TestCase				):




					"""simple docstring"""

					@slow
					def 		__lowerCAmelCase						(				self   :	str			):
									UpperCAmelCase__             =							'bert-base-cased'
									UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
									self.assertIsNotNone(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

									UpperCAmelCase__             =							TFAutoModel.from_pretrained(lowerCamelCase__			)
									self.assertIsNotNone(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	Dict			):
									UpperCAmelCase__             =							'bert-base-cased'
									UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
									self.assertIsNotNone(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

									UpperCAmelCase__             =							TFAutoModelForPreTraining.from_pretrained(lowerCamelCase__			)
									self.assertIsNotNone(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	int			):
									for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelForCausalLM.from_pretrained(lowerCamelCase__			)
													UpperCAmelCase__      ,	UpperCAmelCase__             =							TFAutoModelForCausalLM.from_pretrained(lowerCamelCase__    ,output_loading_info=lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	Dict			):
									for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelWithLMHead.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	List[str]			):
									for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase__			)
													UpperCAmelCase__      ,	UpperCAmelCase__             =							TFAutoModelForMaskedLM.from_pretrained(lowerCamelCase__    ,output_loading_info=lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	str			):
									for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase__			)
													UpperCAmelCase__      ,	UpperCAmelCase__             =							TFAutoModelForSeqaSeqLM.from_pretrained(lowerCamelCase__    ,output_loading_info=lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	Dict			):
									# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									for model_name in ["bert-base-uncased"]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelForSequenceClassification.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					def 		__lowerCAmelCase						(				self   :	str			):
									# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									for model_name in ["bert-base-uncased"]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelForQuestionAnswering.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					@slow
					@require_tensorflow_probability
					def 		__lowerCAmelCase						(				self   :	List[Any]			):
									for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
													UpperCAmelCase__             =							AutoConfig.from_pretrained(lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

													UpperCAmelCase__             =							TFAutoModelForTableQuestionAnswering.from_pretrained(lowerCamelCase__			)
													UpperCAmelCase__      ,	UpperCAmelCase__             =							TFAutoModelForTableQuestionAnswering.from_pretrained(
													    lowerCamelCase__    ,output_loading_info=lowerCamelCase__			)
													self.assertIsNotNone(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					def 		__lowerCAmelCase						(				self   :	Dict			):
									UpperCAmelCase__             =							TFAutoModelWithLMHead.from_pretrained(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)
									self.assertEqual(model.num_parameters()    ,14_410			)
									self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase__			)    ,14_410			)







					def 		__lowerCAmelCase						(				self   :	str			):
									UpperCAmelCase__             =							TFAutoModelWithLMHead.from_pretrained(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)
									self.assertEqual(model.num_parameters()    ,14_410			)
									self.assertEqual(model.num_parameters(only_trainable=lowerCamelCase__			)    ,14_410			)







					def 		__lowerCAmelCase						(				self   :	Optional[Any]			):
									# For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
									UpperCAmelCase__             =							TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

									UpperCAmelCase__             =							copy.deepcopy(model.config			)
									UpperCAmelCase__             =							['FunnelBaseModel']
									UpperCAmelCase__             =							TFAutoModel.from_config(lowerCamelCase__			)
									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

									with tempfile.TemporaryDirectory() as tmp_dir:
													model.save_pretrained(lowerCamelCase__			)
													UpperCAmelCase__             =							TFAutoModel.from_pretrained(lowerCamelCase__			)
													self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)







					def 		__lowerCAmelCase						(				self   :	int			):
									try:
													AutoConfig.register('new-model'    ,lowerCamelCase__			)

													UpperCAmelCase__             =							[
													    TFAutoModel,
													    TFAutoModelForCausalLM,
													    TFAutoModelForMaskedLM,
													    TFAutoModelForPreTraining,
													    TFAutoModelForQuestionAnswering,
													    TFAutoModelForSequenceClassification,
													    TFAutoModelForTokenClassification,
													]

													for auto_class in auto_classes:
																	with self.subTest(auto_class.__name__			):
																					# Wrong config class will raise an error
																					with self.assertRaises(lowerCamelCase__			):
																									auto_class.register(lowerCamelCase__    ,lowerCamelCase__			)
																					auto_class.register(lowerCamelCase__    ,lowerCamelCase__			)
																					# Trying to register something existing in the Transformers library will raise an error
																					with self.assertRaises(lowerCamelCase__			):
																									auto_class.register(lowerCamelCase__    ,lowerCamelCase__			)

																					# Now that the config is registered, it can be used as any other config with the auto-API
																					UpperCAmelCase__             =							BertModelTester(self			).get_config()
																					UpperCAmelCase__             =							NewModelConfig(**tiny_config.to_dict()			)
																					UpperCAmelCase__             =							auto_class.from_config(lowerCamelCase__			)
																					self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

																					with tempfile.TemporaryDirectory() as tmp_dir:
																									model.save_pretrained(lowerCamelCase__			)
																									UpperCAmelCase__             =							auto_class.from_pretrained(lowerCamelCase__			)
																									self.assertIsInstance(lowerCamelCase__    ,lowerCamelCase__			)

									finally:
													if "new-model" in CONFIG_MAPPING._extra_content:
																	del CONFIG_MAPPING._extra_content["new-model"]
													for mapping in (
													    TF_MODEL_MAPPING,
													    TF_MODEL_FOR_PRETRAINING_MAPPING,
													    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
													    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
													    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
													    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
													    TF_MODEL_FOR_MASKED_LM_MAPPING,
													):
																	if NewModelConfig in mapping._extra_content:
																					del mapping._extra_content[NewModelConfig]







					def 		__lowerCAmelCase						(				self   :	str			):
									with self.assertRaisesRegex(
									    lowerCamelCase__    ,'bert-base is not a local folder and is not a valid model identifier'			):
													UpperCAmelCase__             =							TFAutoModel.from_pretrained('bert-base'			)







					def 		__lowerCAmelCase						(				self   :	Tuple			):
									with self.assertRaisesRegex(
									    lowerCamelCase__    ,R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'			):
													UpperCAmelCase__             =							TFAutoModel.from_pretrained(lowerCamelCase__    ,revision='aaaaaa'			)







					def 		__lowerCAmelCase						(				self   :	List[str]			):
									with self.assertRaisesRegex(
									    lowerCamelCase__    ,'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'    ,):
													UpperCAmelCase__             =							TFAutoModel.from_pretrained('hf-internal-testing/config-no-model'			)







					def 		__lowerCAmelCase						(				self   :	Optional[Any]			):
									with self.assertRaisesRegex(lowerCamelCase__    ,'Use `from_pt=True` to load this model'			):
													UpperCAmelCase__             =							TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'			)







					def 		__lowerCAmelCase						(				self   :	Union[str, Any]			):
									# Make sure we have cached the model.
									UpperCAmelCase__             =							TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'			)
									with RequestCounter() as counter:
													UpperCAmelCase__             =							TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'			)
													self.assertEqual(counter.get_request_count    ,0			)
													self.assertEqual(counter.head_request_count    ,1			)
													self.assertEqual(counter.other_request_count    ,0			)

									# With a sharded checkpoint
									UpperCAmelCase__             =							TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'			)
									with RequestCounter() as counter:
													UpperCAmelCase__             =							TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'			)
													self.assertEqual(counter.get_request_count    ,0			)
													self.assertEqual(counter.head_request_count    ,1			)
													self.assertEqual(counter.other_request_count    ,0			)




"""simple docstring"""






import numpy as np
from numpy import ndarray
from scipy.optimize import Bounds, LinearConstraint, minimize



def   a_						(					lowerCamelCase       ):
				return np.dot(lowerCamelCase					,			lowerCamelCase       )
class 				snake_case       :




					"""simple docstring"""

					def __init__(				self   :	int    ,*,
					    lowerCamelCase__   :	float = np.inf    ,lowerCamelCase__   :	str = "linear"    ,lowerCamelCase__   :	float = 0.0    ,):
									UpperCAmelCase__             =							regularization
									UpperCAmelCase__             =							gamma
									if kernel == "linear":
													UpperCAmelCase__             =							self.__linear
									elif kernel == "rbf":
													if self.gamma == 0:
																	raise ValueError('rbf kernel requires gamma'			)
													if not isinstance(self.gamma    ,(float, int)			):
																	raise ValueError('gamma must be float or int'			)
													if not self.gamma > 0:
																	raise ValueError('gamma must be > 0'			)
													UpperCAmelCase__             =							self.__rbf
													# in the future, there could be a default value like in sklearn
													# sklear: def_gamma = 1/(n_features * X.var()) (wiki)
													# previously it was 1/(n_features)
									else:
													UpperCAmelCase__             =							f'''Unknown kernel: {kernel}'''
													raise ValueError(lowerCamelCase__			)







					def 		__lowerCAmelCase						(				self   :	List[Any]    ,lowerCamelCase__   :	ndarray    ,lowerCamelCase__   :	ndarray			):
									return np.dot(lowerCamelCase__    ,lowerCamelCase__			)







					def 		__lowerCAmelCase						(				self   :	Any    ,lowerCamelCase__   :	ndarray    ,lowerCamelCase__   :	ndarray			):
									return np.exp(-(self.gamma * norm_squared(vectora - vectora			))			)







					def 		__lowerCAmelCase						(				self   :	Tuple    ,lowerCamelCase__   :	list[ndarray]    ,lowerCamelCase__   :	ndarray			):
									UpperCAmelCase__             =							observations
									UpperCAmelCase__             =							classes

									# using Wolfe's Dual to calculate w.
									# Primal problem: minimize 1/2*norm_squared(w)
									#   constraint: yn(w . xn + b) >= 1
									#
									# With l a vector
									# Dual problem: maximize sum_n(ln) -
									#       1/2 * sum_n(sum_m(ln*lm*yn*ym*xn . xm))
									#   constraint: self.C >= ln >= 0
									#           and sum_n(ln*yn) = 0
									# Then we get w using w = sum_n(ln*yn*xn)
									# At the end we can get b ~= mean(yn - w . xn)
									#
									# Since we use kernels, we only need l_star to calculate b
									# and to classify observations

									((UpperCAmelCase__)      ,	)             =							np.shape(lowerCamelCase__			)

									def to_minimize(lowerCamelCase__   :	ndarray			) -> float:
													UpperCAmelCase__             =							0
													((UpperCAmelCase__)      ,	)             =							np.shape(lowerCamelCase__			)
													for i in range(lowerCamelCase__			):
																	for j in range(lowerCamelCase__			):
																					s += (
																					    candidate[i]
																					    * candidate[j]
																					    * classes[i]
																					    * classes[j]
																					    * self.kernel(observations[i]    ,observations[j]			)
																					)
													return 1 / 2 * s - sum(lowerCamelCase__			)

									UpperCAmelCase__             =							LinearConstraint(lowerCamelCase__    ,0    ,0			)
									UpperCAmelCase__             =							Bounds(0    ,self.regularization			)

									UpperCAmelCase__             =							minimize(
									    lowerCamelCase__    ,np.ones(lowerCamelCase__			)    ,bounds=lowerCamelCase__    ,constraints=[ly_contraint]			).x
									UpperCAmelCase__             =							l_star

									# calculating mean offset of separation plane to points
									UpperCAmelCase__             =							0
									for i in range(lowerCamelCase__			):
													for j in range(lowerCamelCase__			):
																	s += classes[i] - classes[i] * self.optimum[i] * self.kernel(
																	    observations[i]    ,observations[j]			)
									UpperCAmelCase__             =							s / n







					def 		__lowerCAmelCase						(				self   :	int    ,lowerCamelCase__   :	ndarray			):
									UpperCAmelCase__             =							sum(
									    self.optimum[n]
									    * self.classes[n]
									    * self.kernel(self.observations[n]    ,lowerCamelCase__			)
									    for n in range(len(self.classes			)			)			)
									return 1 if s + self.offset >= 0 else -1


if __name__ == "__main__":
						import doctest

						doctest.testmod()



