




import numpy as np

import datasets


SCREAMING_SNAKE_CASE__       :      List[str]  =   '\nCompute the Mahalanobis Distance\n\nMahalonobis distance is the distance between a point and a distribution.\nAnd not between two distinct points. It is effectively a multivariate equivalent of the Euclidean distance.\nIt was introduced by Prof. P. C. Mahalanobis in 1936\nand has been used in various statistical applications ever since\n[source: https://www.machinelearningplus.com/statistics/mahalanobis-distance/]\n'

SCREAMING_SNAKE_CASE__       :      Union[str, Any]  =   '\\n@article{de2000mahalanobis,\n  title={The mahalanobis distance},\n  author={De Maesschalck, Roy and Jouan-Rimbaud, Delphine and Massart, D{\'e}sir{\'e} L},\n  journal={Chemometrics and intelligent laboratory systems},\n  volume={50},\n  number={1},\n  pages={1--18},\n  year={2000},\n  publisher={Elsevier}\n}\n'

SCREAMING_SNAKE_CASE__       :      int  =   '\nArgs:\n    X: List of datapoints to be compared with the `reference_distribution`.\n    reference_distribution: List of datapoints from the reference distribution we want to compare to.\nReturns:\n    mahalanobis: The Mahalonobis distance for each datapoint in `X`.\nExamples:\n\n    >>> mahalanobis_metric = datasets.load_metric("mahalanobis")\n    >>> results = mahalanobis_metric.compute(reference_distribution=[[0, 1], [1, 0]], X=[[0, 1]])\n    >>> print(results)\n    {\'mahalanobis\': array([0.5])}\n'




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,				_KWARGS_DESCRIPTION     )
class 		UpperCamelCase__	(datasets.Metric     ):

    '''simple docstring'''



    def     _lowercase     (    self     )     ->      List[str]:
           return datasets.MetricInfo(
               description=_DESCRIPTION     ,  citation=_CITATION     ,  inputs_description=_KWARGS_DESCRIPTION     ,  features=datasets.Features(
                   {
                       "X": datasets.Sequence(datasets.Value("float"     ,  id="sequence"     )     ,  id="X"     ),
                   }     )     ,  )







    def     _lowercase     (    self     ,  UpperCamelCase__     ,  UpperCamelCase__     )     ->      List[Any]:
           # convert to numpy arrays
           lowerCamelCase   :      Tuple			 =					np.array(UpperCamelCase__     )
           lowerCamelCase   :      Tuple			 =					np.array(UpperCamelCase__     )

           # Assert that arrays are 2D
           if len(X.shape     ) != 2:
                  raise ValueError("Expected `X` to be a 2D vector"     )
           if len(reference_distribution.shape     ) != 2:
                  raise ValueError("Expected `reference_distribution` to be a 2D vector"     )
           if reference_distribution.shape[0] < 2:
                  raise ValueError(
                      "Expected `reference_distribution` to be a 2D vector with more than one element in the first dimension"     )

           # Get mahalanobis distance for each prediction
           lowerCamelCase   :      List[Any]			 =					X - np.mean(UpperCamelCase__     )
           lowerCamelCase   :      Dict			 =					np.cov(reference_distribution.T     )
           try:
                  lowerCamelCase   :      str			 =					np.linalg.inv(UpperCamelCase__     )
           except np.linalg.LinAlgError:
                  lowerCamelCase   :      Any			 =					np.linalg.pinv(UpperCamelCase__     )
           lowerCamelCase   :      Optional[int]			 =					np.dot(UpperCamelCase__     ,  UpperCamelCase__     )
           lowerCamelCase   :      int			 =					np.dot(UpperCamelCase__     ,  X_minus_mu.T     ).diagonal()

           return {"mahalanobis": mahal_dist}












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      (      _SCREAMING_SNAKE_CASE    )	-> tuple:
       return (data["data"], data["target"])

def      A      (      _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )	-> np.ndarray:
       lowerCamelCase   :      List[str]			 =					XGBRegressor(verbosity=0 ,random_state=42    )
       xgb.fit(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )
       # Predict target for test data
       lowerCamelCase   :      List[Any]			 =					xgb.predict(_SCREAMING_SNAKE_CASE    )
       lowerCamelCase   :      Tuple			 =					predictions.reshape(len(_SCREAMING_SNAKE_CASE    ) ,1    )
       return predictions

def      A      (      )	-> None:
       lowerCamelCase   :      Dict			 =					fetch_california_housing()
       lowerCamelCase ,      lowerCamelCase   :      Tuple			 =					data_handling(_SCREAMING_SNAKE_CASE    )
       lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase   :      Optional[Any]			 =					train_test_split(
           _SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,test_size=0.25 ,random_state=1    )
       lowerCamelCase   :      Any			 =					xgboost(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )
       # Error printing
       print(f'''Mean Absolute Error : {mean_absolute_error(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )}'''    )
       print(f'''Mean Square Error  : {mean_squared_error(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE    )}'''    )


if __name__ == "__main__":
       import doctest

       doctest.testmod(verbose=True)
       main()






