




from sklearn.metrics import matthews_corrcoef

import datasets


a													=			"\nCompute the Matthews correlation coefficient (MCC)\n\nThe Matthews correlation coefficient is used in machine learning as a\nmeasure of the quality of binary and multiclass classifications. It takes\ninto account true and false positives and negatives and is generally\nregarded as a balanced measure which can be used even if the classes are of\nvery different sizes. The MCC is in essence a correlation coefficient value\nbetween -1 and +1. A coefficient of +1 represents a perfect prediction, 0\nan average random prediction and -1 an inverse prediction.  The statistic\nis also known as the phi coefficient. [source: Wikipedia]\n"

a													=			"\nArgs:\n    predictions (list of int): Predicted labels, as returned by a model.\n    references (list of int): Ground truth labels.\n    sample_weight (list of int, float, or bool): Sample weights. Defaults to `None`.\nReturns:\n    matthews_correlation (dict containing float): Matthews correlation.\nExamples:\n    Example 1, a basic example with only predictions and references as inputs:\n        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")\n        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n        ...                                     predictions=[1, 2, 2, 0, 3, 3])\n        >>> print(round(results['matthews_correlation'], 2))\n        0.54\n\n    Example 2, the same example as above, but also including sample weights:\n        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")\n        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n        ...                                     predictions=[1, 2, 2, 0, 3, 3],\n        ...                                     sample_weight=[0.5, 3, 1, 1, 1, 2])\n        >>> print(round(results['matthews_correlation'], 2))\n        0.1\n\n    Example 3, the same example as above, but with sample weights that cause a negative correlation:\n        >>> matthews_metric = datasets.load_metric(\"matthews_correlation\")\n        >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n        ...                                     predictions=[1, 2, 2, 0, 3, 3],\n        ...                                     sample_weight=[0.5, 1, 0, 0, 0, 1])\n        >>> print(round(results['matthews_correlation'], 2))\n        -0.25\n"

a													=			"\\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"




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






		def 				UpperCAmelCase (    self			):
								return datasets.MetricInfo(
								    description=_DESCRIPTION						,		citation=_CITATION						,		inputs_description=_KWARGS_DESCRIPTION						,		features=datasets.Features(
								        {
								            """predictions""": datasets.Value("""int32"""			),
								            """references""": datasets.Value("""int32"""			),
								        }			)						,		reference_urls=[
								        """https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html"""
								    ]						,		)






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE=None			):
								return {
								    "matthews_correlation": float(matthews_corrcoef(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		sample_weight=_SCREAMING_SNAKE_CASE			)			),
								}





import uuid
from typing import Any, Dict, List, Optional, Union

from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
				import tensorflow as tf

if is_torch_available():
				import torch


a													=			logging.get_logger(__name__)




class       _A				:






		def __init__(    self						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE=None						,		_SCREAMING_SNAKE_CASE=None			):
								if not conversation_id:
														_UpperCAmelCase      =			uuid.uuida()
								if past_user_inputs is None:
														_UpperCAmelCase      =			[]
								if generated_responses is None:
														_UpperCAmelCase      =			[]

								_UpperCAmelCase      =			conversation_id
								_UpperCAmelCase      =			past_user_inputs
								_UpperCAmelCase      =			generated_responses
								_UpperCAmelCase      =			text






		def __eq__(    self						,		_SCREAMING_SNAKE_CASE			):
								if not isinstance(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			):
														return False
								if self.uuid == other.uuid:
														return True
								return (
								    self.new_user_input == other.new_user_input
								    and self.past_user_inputs == other.past_user_inputs
								    and self.generated_responses == other.generated_responses
								)






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE = False			):
								if self.new_user_input:
														if overwrite:
																				logger.warning(
																				    F"User input added while unprocessed input was existing: \"{self.new_user_input}\" was overwritten "
																				    F"with: \"{text}\"."			)
																				_UpperCAmelCase      =			text
														else:
																				logger.warning(
																				    F"User input added while unprocessed input was existing: \"{self.new_user_input}\" new input "
																				    F"ignored: \"{text}\". Set `overwrite` to True to overwrite unprocessed user input"			)
								else:
														_UpperCAmelCase      =			text






		def 				UpperCAmelCase (    self			):
								if self.new_user_input:
														self.past_user_inputs.append(self.new_user_input			)
								_UpperCAmelCase      =			None






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE			):
								self.generated_responses.append(_SCREAMING_SNAKE_CASE			)






		def 				UpperCAmelCase (    self			):
								for user_input, generated_response in zip(self.past_user_inputs						,		self.generated_responses			):
														yield True, user_input
														yield False, generated_response
								if self.new_user_input:
														yield True, self.new_user_input






		def __repr__(    self			):
								_UpperCAmelCase      =			F"Conversation id: {self.uuid} \n"
								for is_user, text in self.iter_texts():
														_UpperCAmelCase      =			"""user""" if is_user else """bot"""
														output += F"{name} >> {text} \n"
								return output




@add_end_docstrings(
    __lowercase       ,     R"""
        min_length_for_response (`int`, *optional*, defaults to 32):
            The minimum length (in number of tokens) for a response.
        minimum_tokens (`int`, *optional*, defaults to 10):
            The minimum length of tokens to leave for a response.
    """       ,     )
class       _A				(		__lowercase     ):






		def __init__(    self						,		*_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE			):
								super().__init__(*_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE			)
								if self.tokenizer.pad_token_id is None:
														_UpperCAmelCase      =			self.tokenizer.eos_token






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE=None						,		_SCREAMING_SNAKE_CASE=None						,		_SCREAMING_SNAKE_CASE=None						,		**_SCREAMING_SNAKE_CASE			):
								_UpperCAmelCase      =			{}
								_UpperCAmelCase      =			{}
								_UpperCAmelCase      =			{}

								if min_length_for_response is not None:
														_UpperCAmelCase      =			min_length_for_response
								if minimum_tokens is not None:
														_UpperCAmelCase      =			minimum_tokens

								if "max_length" in generate_kwargs:
														_UpperCAmelCase      =			generate_kwargs["""max_length"""]
														# self.max_length = generate_kwargs.get("max_length", self.model.config.max_length)
								if clean_up_tokenization_spaces is not None:
														_UpperCAmelCase      =			clean_up_tokenization_spaces

								if generate_kwargs:
														forward_params.update(_SCREAMING_SNAKE_CASE			)
								return preprocess_params, forward_params, postprocess_params






		def __call__(    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE=0						,		**_SCREAMING_SNAKE_CASE			):
								_UpperCAmelCase      =			super().__call__(_SCREAMING_SNAKE_CASE						,		num_workers=_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE			)
								if isinstance(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			) and len(_SCREAMING_SNAKE_CASE			) == 1:
														return outputs[0]
								return outputs






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE=32			):
								if not isinstance(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			):
														raise ValueError("""ConversationalPipeline, expects Conversation as inputs"""			)
								if conversation.new_user_input is None:
														raise ValueError(
														    F"Conversation with UUID {type(conversation.uuid			)} does not contain new user input to process. "
														    """Add user inputs with the conversation's `add_user_input` method"""			)
								if hasattr(self.tokenizer						,		"""_build_conversation_input_ids"""			):
														_UpperCAmelCase      =			self.tokenizer._build_conversation_input_ids(_SCREAMING_SNAKE_CASE			)
								else:
														# If the tokenizer cannot handle conversations, we default to only the old version
														_UpperCAmelCase      =			self._legacy_parse_and_tokenize(_SCREAMING_SNAKE_CASE			)

								if self.framework == "pt":
														_UpperCAmelCase      =			torch.LongTensor([input_ids]			)
								elif self.framework == "tf":
														_UpperCAmelCase      =			tf.constant([input_ids]			)
								return {"input_ids": input_ids, "conversation": conversation}






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE=10						,		**_SCREAMING_SNAKE_CASE			):
								_UpperCAmelCase      =			generate_kwargs.get("""max_length"""						,		self.model.config.max_length			)

								_UpperCAmelCase      =			model_inputs["""input_ids"""].shape[1]
								if max_length - minimum_tokens < n:
														logger.warning(F"Conversation input is to long ({n}), trimming it to ({max_length} - {minimum_tokens})"			)
														_UpperCAmelCase      =			max_length - minimum_tokens
														_UpperCAmelCase      =			model_inputs["""input_ids"""][:, -trim:]
														if "attention_mask" in model_inputs:
																				_UpperCAmelCase      =			model_inputs["""attention_mask"""][:, -trim:]
								_UpperCAmelCase      =			model_inputs.pop("""conversation"""			)
								_UpperCAmelCase      =			max_length
								_UpperCAmelCase      =			self.model.generate(**_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE			)
								if self.model.config.is_encoder_decoder:
														_UpperCAmelCase      =			1
								else:
														_UpperCAmelCase      =			n
								return {"output_ids": output_ids[:, start_position:], "conversation": conversation}






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE=True			):
								_UpperCAmelCase      =			model_outputs["""output_ids"""]
								_UpperCAmelCase      =			self.tokenizer.decode(
								    output_ids[0]						,		skip_special_tokens=_SCREAMING_SNAKE_CASE						,		clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE						,		)
								_UpperCAmelCase      =			model_outputs["""conversation"""]
								conversation.mark_processed()
								conversation.append_response(_SCREAMING_SNAKE_CASE			)
								return conversation






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE			):
								_UpperCAmelCase      =			self.tokenizer.eos_token_id
								_UpperCAmelCase      =			[]
								for is_user, text in conversation.iter_texts():
														if eos_token_id is not None:
																				input_ids.extend(self.tokenizer.encode(_SCREAMING_SNAKE_CASE						,		add_special_tokens=_SCREAMING_SNAKE_CASE			) + [eos_token_id]			)
														else:
																				input_ids.extend(self.tokenizer.encode(_SCREAMING_SNAKE_CASE						,		add_special_tokens=_SCREAMING_SNAKE_CASE			)			)

								if len(_SCREAMING_SNAKE_CASE			) > self.tokenizer.model_max_length:
														_UpperCAmelCase      =			input_ids[-self.tokenizer.model_max_length :]
								return input_ids