



"""simple docstring"""







import pandas as pd
from matplotlib import pyplot as plt
from sklearn.linear_model import LinearRegression

# Splitting the dataset into the Training set and Test set
from sklearn.model_selection import train_test_split

# Fitting Polynomial Regression to the dataset
from sklearn.preprocessing import PolynomialFeatures

# Importing the dataset
lowerCAmelCase_   						=   pd.read_csv(
    'https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/'
    'position_salaries.csv'
)
lowerCAmelCase_   						=   dataset.iloc[:, 1:2].values
lowerCAmelCase_   						=   dataset.iloc[:, 2].values


lowerCAmelCase_						,lowerCAmelCase_						,lowerCAmelCase_						,lowerCAmelCase_   						=   train_test_split(X, y, test_size=0.2, random_state=0)


lowerCAmelCase_   						=   PolynomialFeatures(degree=4)
lowerCAmelCase_   						=   poly_reg.fit_transform(X)
lowerCAmelCase_   						=   LinearRegression()
pol_reg.fit(X_poly, y)



def      __UpperCAmelCase      (    )							->      Tuple:
		plt.scatter(__lowerCamelCase						,     __lowerCamelCase						,     color='''red'''	)
		plt.plot(__lowerCamelCase						,     pol_reg.predict(poly_reg.fit_transform(__lowerCamelCase	)	)						,     color='''blue'''	)
		plt.title('''Truth or Bluff (Linear Regression)'''	)
		plt.xlabel('''Position level'''	)
		plt.ylabel('''Salary'''	)
		plt.show()


if __name__ == "__main__":
							viz_polymonial()

							# Predicting a new result with Polymonial Regression
							pol_reg.predict(poly_reg.fit_transform([[5.5]]))
							# output should be 132148.43750003





"""simple docstring"""







from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
							from transformers import (
							    AutoConfig,
							    BertConfig,
							    GPTaConfig,
							    TaConfig,
							    TFAutoModel,
							    TFAutoModelForCausalLM,
							    TFAutoModelForMaskedLM,
							    TFAutoModelForPreTraining,
							    TFAutoModelForQuestionAnswering,
							    TFAutoModelForSeqaSeqLM,
							    TFAutoModelForSequenceClassification,
							    TFAutoModelWithLMHead,
							    TFBertForMaskedLM,
							    TFBertForPreTraining,
							    TFBertForQuestionAnswering,
							    TFBertForSequenceClassification,
							    TFBertModel,
							    TFGPTaLMHeadModel,
							    TFRobertaForMaskedLM,
							    TFTaForConditionalGeneration,
							)
							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

if is_torch_available():
							from transformers import (
							    AutoModel,
							    AutoModelForCausalLM,
							    AutoModelForMaskedLM,
							    AutoModelForPreTraining,
							    AutoModelForQuestionAnswering,
							    AutoModelForSeqaSeqLM,
							    AutoModelForSequenceClassification,
							    AutoModelWithLMHead,
							    BertForMaskedLM,
							    BertForPreTraining,
							    BertForQuestionAnswering,
							    BertForSequenceClassification,
							    BertModel,
							    GPTaLMHeadModel,
							    RobertaForMaskedLM,
							    TaForConditionalGeneration,
							)
@is_pt_tf_cross_test
class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		@slow
		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		Union[str, Any]:






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    Tuple				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Dict				=			TFAutoModel.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			AutoModel.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Tuple:






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    Dict				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    str				=			TFAutoModelForPreTraining.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Optional[Any]				=			AutoModelForPreTraining.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Dict:






				"""simple docstring"""



				for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Any				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			TFAutoModelForCausalLM.from_pretrained(_snake_case			,from_pt=_snake_case						)
						lowercase__		,			lowercase__   :    Optional[Any]				=			TFAutoModelForCausalLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Union[str, Any]				=			AutoModelForCausalLM.from_pretrained(_snake_case			,from_tf=_snake_case						)
						lowercase__		,			lowercase__   :    Optional[Any]				=			AutoModelForCausalLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Any						)					->		Tuple:






				"""simple docstring"""



				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Any				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Optional[Any]				=			TFAutoModelWithLMHead.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			AutoModelWithLMHead.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Optional[Any]:






				"""simple docstring"""



				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    str				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Union[str, Any]				=			TFAutoModelForMaskedLM.from_pretrained(_snake_case			,from_pt=_snake_case						)
						lowercase__		,			lowercase__   :    str				=			TFAutoModelForMaskedLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			AutoModelForMaskedLM.from_pretrained(_snake_case			,from_tf=_snake_case						)
						lowercase__		,			lowercase__   :    Any				=			AutoModelForMaskedLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		Dict:






				"""simple docstring"""



				for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Union[str, Any]				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    List[str]				=			TFAutoModelForSeqaSeqLM.from_pretrained(_snake_case			,from_pt=_snake_case						)
						lowercase__		,			lowercase__   :    List[str]				=			TFAutoModelForSeqaSeqLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			AutoModelForSeqaSeqLM.from_pretrained(_snake_case			,from_tf=_snake_case						)
						lowercase__		,			lowercase__   :    Optional[int]				=			AutoModelForSeqaSeqLM.from_pretrained(
						    _snake_case			,output_loading_info=_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		Union[str, Any]:






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    Tuple				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			TFAutoModelForSequenceClassification.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Union[str, Any]				=			AutoModelForSequenceClassification.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Optional[Any]:






				"""simple docstring"""



				for model_name in ["bert-base-uncased"]:
						lowercase__   :    List[Any]				=			AutoConfig.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    str				=			TFAutoModelForQuestionAnswering.from_pretrained(_snake_case			,from_pt=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)

						lowercase__   :    Any				=			AutoModelForQuestionAnswering.from_pretrained(_snake_case			,from_tf=_snake_case						)
						self.assertIsNotNone(_snake_case						)
						self.assertIsInstance(_snake_case			,_snake_case						)







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			TFAutoModelWithLMHead.from_pretrained(_snake_case			,from_pt=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)

				lowercase__   :    Union[str, Any]				=			AutoModelWithLMHead.from_pretrained(_snake_case			,from_tf=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)







		def 					UpperCAmelCase    (	self						:  int						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			TFAutoModelWithLMHead.from_pretrained(_snake_case			,from_pt=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)

				lowercase__   :    int				=			AutoModelWithLMHead.from_pretrained(_snake_case			,from_tf=_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)
				self.assertEqual(model.num_parameters()			,14_410						)
				self.assertEqual(model.num_parameters(only_trainable=_snake_case						)			,14_410						)
