






from dataclasses import dataclass
from typing import Optional, Tuple, Union

import torch
import torch.nn as nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .embeddings import GaussianFourierProjection, TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin
from .unet_ad_blocks import get_down_block, get_mid_block, get_out_block, get_up_block

@dataclass
class 		_snake_case  (  A__					):
			_lowercase		:    torch.FloatTensor



class 		_snake_case  (  A__   ,    A__					):






			@register_to_config
			def __init__(       self		,					a = 6_5536		,					a = None		,					a = 2		,					a = 2		,					a = 0		,					a = "fourier"		,					a = True		,					a = False		,					a = 0.0		,					a = ("DownBlock1DNoSkip", "DownBlock1D", "AttnDownBlock1D")		,					a = ("AttnUpBlock1D", "UpBlock1D", "UpBlock1DNoSkip")		,					a = "UNetMidBlock1D"		,					a = None		,					a = (32, 32, 64)		,					a = None		,					a = 8		,					a = 1		,					a = False		,					)      ->       Any:
						super().__init__()
						SCREAMING_SNAKE_CASE						= sample_size

						# time
						if time_embedding_type == "fourier":
									SCREAMING_SNAKE_CASE						= GaussianFourierProjection(
									    embedding_size=8		,					set_W_to_weight=a		,					log=a		,					flip_sin_to_cos=a)
									SCREAMING_SNAKE_CASE						= 2 * block_out_channels[0]
						elif time_embedding_type == "positional":
									SCREAMING_SNAKE_CASE						= Timesteps(
									    block_out_channels[0]		,					flip_sin_to_cos=a		,					downscale_freq_shift=a)
									SCREAMING_SNAKE_CASE						= block_out_channels[0]

						if use_timestep_embedding:
									SCREAMING_SNAKE_CASE						= block_out_channels[0] * 4
									SCREAMING_SNAKE_CASE						= TimestepEmbedding(
									    in_channels=a		,					time_embed_dim=a		,					act_fn=a		,					out_dim=block_out_channels[0]		,					)

						SCREAMING_SNAKE_CASE						= nn.ModuleList([])
						SCREAMING_SNAKE_CASE						= None
						SCREAMING_SNAKE_CASE						= nn.ModuleList([])
						SCREAMING_SNAKE_CASE						= None

						# down
						SCREAMING_SNAKE_CASE						= in_channels
						for i, down_block_type in enumerate(a):
									SCREAMING_SNAKE_CASE						= output_channel
									SCREAMING_SNAKE_CASE						= block_out_channels[i]

									if i == 0:
												input_channel += extra_in_channels

									SCREAMING_SNAKE_CASE						= i == len(a) - 1

									SCREAMING_SNAKE_CASE						= get_down_block(
									    a		,					num_layers=a		,					in_channels=a		,					out_channels=a		,					temb_channels=block_out_channels[0]		,					add_downsample=not is_final_block or downsample_each_block		,					)
									self.down_blocks.append(a)

						# mid
						SCREAMING_SNAKE_CASE						= get_mid_block(
						    a		,					in_channels=block_out_channels[-1]		,					mid_channels=block_out_channels[-1]		,					out_channels=block_out_channels[-1]		,					embed_dim=block_out_channels[0]		,					num_layers=a		,					add_downsample=a		,					)

						# up
						SCREAMING_SNAKE_CASE						= list(reversed(a))
						SCREAMING_SNAKE_CASE						= reversed_block_out_channels[0]
						if out_block_type is None:
									SCREAMING_SNAKE_CASE						= out_channels
						else:
									SCREAMING_SNAKE_CASE						= block_out_channels[0]

						for i, up_block_type in enumerate(a):
									SCREAMING_SNAKE_CASE						= output_channel
									SCREAMING_SNAKE_CASE						= (
									    reversed_block_out_channels[i + 1] if i < len(a) - 1 else final_upsample_channels
									)

									SCREAMING_SNAKE_CASE						= i == len(a) - 1

									SCREAMING_SNAKE_CASE						= get_up_block(
									    a		,					num_layers=a		,					in_channels=a		,					out_channels=a		,					temb_channels=block_out_channels[0]		,					add_upsample=not is_final_block		,					)
									self.up_blocks.append(a)
									SCREAMING_SNAKE_CASE						= output_channel

						# out
						SCREAMING_SNAKE_CASE						= norm_num_groups if norm_num_groups is not None else min(block_out_channels[0] // 4		,					32)
						SCREAMING_SNAKE_CASE						= get_out_block(
						    out_block_type=a		,					num_groups_out=a		,					embed_dim=block_out_channels[0]		,					out_channels=a		,					act_fn=a		,					fc_dim=block_out_channels[-1] // 4		,					)







			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a = True		,					)      ->       Union[UNetaDOutput, Tuple]:
						SCREAMING_SNAKE_CASE						= timestep
						if not torch.is_tensor(a):
									SCREAMING_SNAKE_CASE						= torch.tensor([timesteps]		,					dtype=torch.long		,					device=sample.device)
						elif torch.is_tensor(a) and len(timesteps.shape) == 0:
									SCREAMING_SNAKE_CASE						= timesteps[None].to(sample.device)

						SCREAMING_SNAKE_CASE						= self.time_proj(a)
						if self.config.use_timestep_embedding:
									SCREAMING_SNAKE_CASE						= self.time_mlp(a)
						else:
									SCREAMING_SNAKE_CASE						= timestep_embed[..., None]
									SCREAMING_SNAKE_CASE						= timestep_embed.repeat([1, 1, sample.shape[2]]).to(sample.dtype)
									SCREAMING_SNAKE_CASE						= timestep_embed.broadcast_to((sample.shape[:1] + timestep_embed.shape[1:]))

						# 2. down
						SCREAMING_SNAKE_CASE						= ()
						for downsample_block in self.down_blocks:
									SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						= downsample_block(hidden_states=a		,					temb=a)
									down_block_res_samples += res_samples

						# 3. mid
						if self.mid_block:
									SCREAMING_SNAKE_CASE						= self.mid_block(a		,					a)

						# 4. up
						for i, upsample_block in enumerate(self.up_blocks):
									SCREAMING_SNAKE_CASE						= down_block_res_samples[-1:]
									SCREAMING_SNAKE_CASE						= down_block_res_samples[:-1]
									SCREAMING_SNAKE_CASE						= upsample_block(a		,					res_hidden_states_tuple=a		,					temb=a)

						# 5. post-process
						if self.out_block:
									SCREAMING_SNAKE_CASE						= self.out_block(a		,					a)

						if not return_dict:
									return (sample,)

						return UNetaDOutput(sample=a)












import numpy as np
from scipy.spatial.distance import cdist
from sklearn.metrics import fa_score

import datasets


a_		:						Optional[int]             =    '\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n'

a_		:						Tuple             =    '\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n'

a_		:						Optional[Any]             =    '\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for \'cvit-mkb-clsr\' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for \'cvit-mkb-clsr\' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    "accuracy": Accuracy\n    "f1": F1 score\n    "precision": Precision@10\nExamples:\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wnli\')  # \'wnli\' or any of ["copa", "sna", "csqa", "wstp", "inltkh", "bbca", "iitp-mr", "iitp-pr", "actsa-sc", "md"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wiki-ner\')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0, \'f1\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'cvit-mkb-clsr\')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'precision@10\': 1.0}\n\n'






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			return float((preds == labels).mean())






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= simple_accuracy(_UpperCAmelCase							,       _UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= float(fa_score(y_true=_UpperCAmelCase							,       y_pred=_UpperCAmelCase))
			return {
			    "accuracy": acc,
			    "f1": fa,
			}






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= np.array(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= np.array(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= en_sentvecs.shape[0]

			# mean centering
			SCREAMING_SNAKE_CASE						= en_sentvecs - np.mean(_UpperCAmelCase							,       axis=0)
			SCREAMING_SNAKE_CASE						= in_sentvecs - np.mean(_UpperCAmelCase							,       axis=0)

			SCREAMING_SNAKE_CASE						= cdist(_UpperCAmelCase							,       _UpperCAmelCase							,       'cosine')
			SCREAMING_SNAKE_CASE						= np.array(range(_UpperCAmelCase))
			SCREAMING_SNAKE_CASE						= sim.argsort(axis=1)[:, :10]
			SCREAMING_SNAKE_CASE						= np.any(preds == actual[:, None]							,       axis=1)
			return float(matches.mean())







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






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Dict:
						if self.config_name not in [
						    "wnli",
						    "copa",
						    "sna",
						    "csqa",
						    "wstp",
						    "inltkh",
						    "bbca",
						    "cvit-mkb-clsr",
						    "iitp-mr",
						    "iitp-pr",
						    "actsa-sc",
						    "md",
						    "wiki-ner",
						]:
									raise KeyError(
									    'You should supply a configuration name selected in '
									    '["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '
									    '"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '
									    '"wiki-ner"]')
						return datasets.MetricInfo(
						    description=_DESCRIPTION		,					citation=_CITATION		,					inputs_description=_KWARGS_DESCRIPTION		,					features=datasets.Features(
						        {
						            'predictions': datasets.Value('int64')
						            if self.config_name != 'cvit-mkb-clsr'
						            else datasets.Sequence(datasets.Value('float32')),
						            'references': datasets.Value('int64')
						            if self.config_name != 'cvit-mkb-clsr'
						            else datasets.Sequence(datasets.Value('float32')),
						        })		,					codebase_urls=[]		,					reference_urls=[]		,					format='numpy' if self.config_name != 'cvit-mkb-clsr' else None		,					)







			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a)      ->       List[Any]:
						if self.config_name == "cvit-mkb-clsr":
									return {"precision@10": precision_at_aa(a		,					a)}
						elif self.config_name in ["wiki-ner"]:
									return acc_and_fa(a		,					a)
						elif self.config_name in [
						    "wnli",
						    "copa",
						    "sna",
						    "csqa",
						    "wstp",
						    "inltkh",
						    "bbca",
						    "iitp-mr",
						    "iitp-pr",
						    "actsa-sc",
						    "md",
						]:
									return {"accuracy": simple_accuracy(a		,					a)}
						else:
									raise KeyError(
									    'You should supply a configuration name selected in '
									    '["wnli", "copa", "sna", "csqa", "wstp", "inltkh", "bbca", '
									    '"cvit-mkb-clsr", "iitp-mr", "iitp-pr", "actsa-sc", "md", '
									    '"wiki-ner"]')




