


from sklearn.metrics import mean_squared_error

import datasets


a_ :Tuple  							=			'\\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n'

a_ :Optional[Any]  							=			'\\nMean Squared Error(MSE) is the average of the square of difference between the predicted\nand actual values.\n'


a_ :int  							=			'\nArgs:\n    predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Estimated target values.\n    references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Ground truth (correct) target values.\n    sample_weight: array-like of shape (n_samples,), default=None\n        Sample weights.\n    multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n        Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n        "raw_values" : Returns a full set of errors in case of multioutput input.\n\n        "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\n    squared : bool, default=True\n        If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.\n\nReturns:\n    mse : mean squared error.\nExamples:\n\n    >>> mse_metric = datasets.load_metric("mse")\n    >>> predictions = [2.5, 0.0, 2, 8]\n    >>> references = [3, -0.5, 2, 7]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.375}\n    >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)\n    >>> print(rmse_result)\n    {\'mse\': 0.6123724356957945}\n\n    If you\'re using multi-dimensional lists, then set the config as follows :\n\n    >>> mse_metric = datasets.load_metric("mse", "multilist")\n    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n    >>> references = [[0, 2], [-1, 2], [8, -5]]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.7083333333333334}\n    >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n    >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n    {\'mse\': array([0.41666667, 1. ])}\n'

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







     def 							lowercase__       (						self :						Dict      ):
           return datasets.MetricInfo(
               description=_DESCRIPTION   ,   citation=_CITATION   ,   inputs_description=_KWARGS_DESCRIPTION   ,   features=datasets.Features(self._get_feature_types()      )   ,   reference_urls=[
                   '''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'''
               ]   ,   )







     def 							lowercase__       (						self :						Dict      ):
           if self.config_name == "multilist":
                 return {
                     "predictions": datasets.Sequence(datasets.Value('''float'''      )      ),
                     "references": datasets.Sequence(datasets.Value('''float'''      )      ),
                 }
           else:
                 return {
                     "predictions": datasets.Value('''float'''      ),
                     "references": datasets.Value('''float'''      ),
                 }







     def 							lowercase__       (						self :						str   ,   _lowercase :						str   ,   _lowercase :						int   ,   _lowercase :						int=None   ,   _lowercase :						Dict="uniform_average"   ,   _lowercase :						List[str]=True      ):
           SCREAMING_SNAKE_CASE__       :  str						     =		mean_squared_error(
               _lowercase   ,   _lowercase   ,   sample_weight=_lowercase   ,   multioutput=_lowercase   ,   squared=_lowercase      )

           return {"mse": mse}








# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
import importlib.metadata
import json
import os
from dataclasses import dataclass
from typing import Any, Dict, Union

from packaging import version

from ..utils import is_torch_available, logging


if is_torch_available():
						import torch


_snake_case      :							Optional[Any]     	=    logging.get_logger(__name__)





@dataclass
class   UpperCamelCase_      :







						'''simple docstring'''



						def __init__(			self							:str		,    lowerCAmelCase__							:Any=False		,    lowerCAmelCase__							:Tuple=False		,    lowerCAmelCase__							:List[str]=6.0		,    lowerCAmelCase__							:int=None		,    lowerCAmelCase__							:Optional[Any]=False		,    lowerCAmelCase__							:List[Any]=False		,    lowerCAmelCase__							:int=None		,    lowerCAmelCase__							:Tuple="fp4"		,    lowerCAmelCase__							:Union[str, Any]=False		,    **lowerCAmelCase__							:Optional[Any]		,    )  ->Any:
										lowercase         =      load_in_abit
										lowercase         =      load_in_abit
										lowercase         =      llm_inta_threshold
										lowercase         =      llm_inta_skip_modules
										lowercase         =      llm_inta_enable_fpaa_cpu_offload
										lowercase         =      llm_inta_has_fpaa_weight
										lowercase         =      bnb_abit_quant_type
										lowercase         =      bnb_abit_use_double_quant

										if bnb_abit_compute_dtype is None:
														lowercase         =      torch.floataa
										elif isinstance(lowerCAmelCase__		,    lowerCAmelCase__     ):
														lowercase         =      getattr(lowerCAmelCase__		,    lowerCAmelCase__     )
										elif isinstance(lowerCAmelCase__		,    torch.dtype     ):
														lowercase         =      bnb_abit_compute_dtype
										else:
														raise ValueError("bnb_4bit_compute_dtype must be a string or a torch.dtype"     )

										self.post_init()





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->str:
										if not isinstance(self.llm_inta_threshold		,    lowerCAmelCase__     ):
														raise ValueError("llm_int8_threshold must be a float"     )

										if self.llm_inta_skip_modules is not None and not isinstance(self.llm_inta_skip_modules		,    lowerCAmelCase__     ):
														raise ValueError("llm_int8_skip_modules must be a list of strings"     )
										if not isinstance(self.llm_inta_enable_fpaa_cpu_offload		,    lowerCAmelCase__     ):
														raise ValueError("llm_int8_enable_fp32_cpu_offload must be a boolean"     )

										if not isinstance(self.llm_inta_has_fpaa_weight		,    lowerCAmelCase__     ):
														raise ValueError("llm_int8_has_fp16_weight must be a boolean"     )

										if self.bnb_abit_compute_dtype is not None and not isinstance(self.bnb_abit_compute_dtype		,    torch.dtype     ):
														raise ValueError("bnb_4bit_compute_dtype must be torch.dtype"     )

										if not isinstance(self.bnb_abit_quant_type		,    lowerCAmelCase__     ):
														raise ValueError("bnb_4bit_quant_type must be a string"     )

										if not isinstance(self.bnb_abit_use_double_quant		,    lowerCAmelCase__     ):
														raise ValueError("bnb_4bit_use_double_quant must be a boolean"     )

										if self.load_in_abit and not version.parse(importlib.metadata.version("bitsandbytes"     )     ) >= version.parse(
										    "0.39.0"     ):
														raise ValueError(
														    "4 bit quantization requires bitsandbytes>=0.39.0 - please upgrade your bitsandbytes version"     )





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->Tuple:
										return self.load_in_abit or self.load_in_abit





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->int:
										if self.load_in_abit:
														return "llm_int8"
										elif self.load_in_abit and self.bnb_abit_quant_type == "fp4":
														return "fp4"
										elif self.load_in_abit and self.bnb_abit_quant_type == "nf4":
														return "nf4"
										else:
														return None





						@classmethod
						def        SCREAMING_SNAKE_CASE(			cls							:Union[str, Any]		,    lowerCAmelCase__							:List[Any]		,    lowerCAmelCase__							:Union[str, Any]		,    **lowerCAmelCase__							:Any     )  ->Optional[Any]:
										lowercase         =      cls(**lowerCAmelCase__     )

										lowercase         =      []
										for key, value in kwargs.items():
														if hasattr(lowerCAmelCase__		,    lowerCAmelCase__     ):
																		setattr(lowerCAmelCase__		,    lowerCAmelCase__		,    lowerCAmelCase__     )
																		to_remove.append(lowerCAmelCase__     )
										for key in to_remove:
														kwargs.pop(lowerCAmelCase__		,    lowerCAmelCase__     )

										if return_unused_kwargs:
														return config, kwargs
										else:
														return config





						def        SCREAMING_SNAKE_CASE(			self							:Dict		,    lowerCAmelCase__							:Union[str, os.PathLike]     )  ->Optional[int]:
										with open(lowerCAmelCase__		,    "w"		,    encoding="utf-8"     ) as writer:
														lowercase         =      self.to_dict()
														lowercase         =      json.dumps(lowerCAmelCase__		,    indent=2		,    sort_keys=lowerCAmelCase__     ) + "\n"

														writer.write(lowerCAmelCase__     )





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->Dict[str, Any]:
										lowercase         =      copy.deepcopy(self.__dict__     )
										lowercase         =      str(output["bnb_4bit_compute_dtype"]     ).split("."     )[1]

										return output





						def __repr__(			self							:int     )  ->Optional[Any]:
										return F'''{self.__class__.__name__} {self.to_json_string()}'''





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]		,    lowerCAmelCase__							:bool = True     )  ->str:
										if use_diff is True:
														lowercase         =      self.to_diff_dict()
										else:
														lowercase         =      self.to_dict()
										return json.dumps(lowerCAmelCase__		,    indent=2		,    sort_keys=lowerCAmelCase__     ) + "\n"





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->Dict[str, Any]:
										lowercase         =      self.to_dict()

										# get the default config dict
										lowercase         =      BitsAndBytesConfig().to_dict()

										lowercase         =      {}

										# only serialize values that differ from the default config
										for key, value in config_dict.items():
														if value != default_config_dict[key]:
																		lowercase         =      value

										return serializable_config_dict
