



'''simple docstring'''
import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor






def A__       (	UpperCAmelCase_				):
						return (data["data"], data["target"])






def A__       (	UpperCAmelCase_    ,    UpperCAmelCase_    ,    UpperCAmelCase_				):
						_UpperCamelCase   :						Tuple												=  XGBRegressor(verbosity=0    ,    random_state=4_2				)
						xgb.fit(UpperCAmelCase_    ,    UpperCAmelCase_				)
						# Predict target for test data
						_UpperCamelCase   :						Tuple												=  xgb.predict(UpperCAmelCase_				)
						_UpperCamelCase   :						Union[str, Any]												=  predictions.reshape(len(UpperCAmelCase_				)    ,    1				)
						return predictions






def A__       (	):
						_UpperCamelCase   :						List[str]												=  fetch_california_housing()
						_UpperCamelCase							,     _UpperCamelCase   :						Union[str, Any]												=  data_handling(UpperCAmelCase_				)
						_UpperCamelCase							,     _UpperCamelCase							,     _UpperCamelCase							,     _UpperCamelCase   :						Optional[Any]												=  train_test_split(
						    UpperCAmelCase_    ,    UpperCAmelCase_    ,    test_size=0.25    ,    random_state=1				)
						_UpperCamelCase   :						str												=  xgboost(UpperCAmelCase_    ,    UpperCAmelCase_    ,    UpperCAmelCase_				)
						# Error printing
						print(f'Mean Absolute Error : {mean_absolute_error(UpperCAmelCase_    ,    UpperCAmelCase_				)}'				)
						print(f'Mean Square Error  : {mean_squared_error(UpperCAmelCase_    ,    UpperCAmelCase_				)}'				)


if __name__ == "__main__":
					import doctest

					doctest.testmod(verbose=True)
					main()







'''simple docstring'''
import os
import tempfile
import unittest
import uuid
from pathlib import Path

from transformers.testing_utils import get_tests_dir, require_soundfile, require_torch, require_vision
from transformers.tools.agent_types import AgentAudio, AgentImage, AgentText
from transformers.utils import is_soundfile_availble, is_torch_available, is_vision_available


if is_torch_available():
					import torch

if is_soundfile_availble():
					import soundfile as sf

if is_vision_available():
					from PIL import Image






def A__       (	UpperCAmelCase_=""				):
						_UpperCamelCase   :						Any												=  tempfile.mkdtemp()
						return os.path.join(UpperCAmelCase_    ,    str(uuid.uuida()				) + suffix				)






@require_soundfile
@require_torch
class 				lowercase__      (				unittest.TestCase  ):





	def       UpperCamelCase_    (					self   :							int					):







							'''simple docstring'''
							_UpperCamelCase   :						List[str]												=  torch.rand(12					,dtype=torch.floataa					) - 0.5
							_UpperCamelCase   :						Optional[int]												=  AgentAudio(lowerCamelCase__					)
							_UpperCamelCase   :						List[str]												=  str(agent_type.to_string()					)

							# Ensure that the tensor and the agent_type's tensor are the same
							self.assertTrue(torch.allclose(lowerCamelCase__					,agent_type.to_raw()					,atol=1E-4					)					)

							del agent_type

							# Ensure the path remains even after the object deletion
							self.assertTrue(os.path.exists(lowerCamelCase__					)					)

							# Ensure that the file contains the same value as the original tensor
							_UpperCamelCase							,     _UpperCamelCase   :						Union[str, Any]												=  sf.read(lowerCamelCase__					)
							self.assertTrue(torch.allclose(lowerCamelCase__					,torch.tensor(lowerCamelCase__					)					,atol=1E-4					)					)





	def       UpperCamelCase_    (					self   :							Dict					):







							'''simple docstring'''
							_UpperCamelCase   :						Optional[Any]												=  torch.rand(12					,dtype=torch.floataa					) - 0.5
							_UpperCamelCase   :						Any												=  get_new_path(suffix='.wav'					)
							sf.write(lowerCamelCase__					,lowerCamelCase__					,16000					)

							_UpperCamelCase   :						List[Any]												=  AgentAudio(lowerCamelCase__					)

							self.assertTrue(torch.allclose(lowerCamelCase__					,agent_type.to_raw()					,atol=1E-4					)					)
							self.assertEqual(agent_type.to_string()					,lowerCamelCase__					)






@require_vision
@require_torch
class 				lowercase__      (				unittest.TestCase  ):





	def       UpperCamelCase_    (					self   :							List[Any]					):







							'''simple docstring'''
							_UpperCamelCase   :						int												=  torch.randint(0					,256					,(64, 64, 3)					)
							_UpperCamelCase   :						Optional[Any]												=  AgentImage(lowerCamelCase__					)
							_UpperCamelCase   :						List[Any]												=  str(agent_type.to_string()					)

							# Ensure that the tensor and the agent_type's tensor are the same
							self.assertTrue(torch.allclose(lowerCamelCase__					,agent_type._tensor					,atol=1E-4					)					)

							self.assertIsInstance(agent_type.to_raw()					,Image.Image					)

							# Ensure the path remains even after the object deletion
							del agent_type
							self.assertTrue(os.path.exists(lowerCamelCase__					)					)





	def       UpperCamelCase_    (					self   :							Dict					):







							'''simple docstring'''
							_UpperCamelCase   :						str												=  Path(get_tests_dir('fixtures/tests_samples/COCO'					)					) / '000000039769.png'
							_UpperCamelCase   :						Tuple												=  Image.open(lowerCamelCase__					)
							_UpperCamelCase   :						Optional[Any]												=  AgentImage(lowerCamelCase__					)

							self.assertTrue(path.samefile(agent_type.to_string()					)					)
							self.assertTrue(image == agent_type.to_raw()					)

							# Ensure the path remains even after the object deletion
							del agent_type
							self.assertTrue(os.path.exists(lowerCamelCase__					)					)





	def       UpperCamelCase_    (					self   :							Optional[int]					):







							'''simple docstring'''
							_UpperCamelCase   :						List[Any]												=  Path(get_tests_dir('fixtures/tests_samples/COCO'					)					) / '000000039769.png'
							_UpperCamelCase   :						Union[str, Any]												=  Image.open(lowerCamelCase__					)
							_UpperCamelCase   :						List[Any]												=  AgentImage(lowerCamelCase__					)

							self.assertFalse(path.samefile(agent_type.to_string()					)					)
							self.assertTrue(image == agent_type.to_raw()					)

							# Ensure the path remains even after the object deletion
							del agent_type
							self.assertTrue(os.path.exists(lowerCamelCase__					)					)






class 				lowercase__      (				unittest.TestCase  ):





	def       UpperCamelCase_    (					self   :							Any					):







							'''simple docstring'''
							_UpperCamelCase   :						List[Any]												=  'Hey!'
							_UpperCamelCase   :						Optional[int]												=  AgentText(lowerCamelCase__					)

							self.assertEqual(lowerCamelCase__					,agent_type.to_string()					)
							self.assertEqual(lowerCamelCase__					,agent_type.to_raw()					)
							self.assertEqual(lowerCamelCase__					,lowerCamelCase__					)


