


from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig


lowerCAmelCase	=							logging.get_logger(__name__)

# General docstring
lowerCAmelCase	=							'RegNetConfig'

# Base docstring
lowerCAmelCase	=							'facebook/regnet-y-040'
lowerCAmelCase	=							[1, 1088, 7, 7]

# Image classification docstring
lowerCAmelCase	=							'facebook/regnet-y-040'
lowerCAmelCase	=							'tabby, tabby cat'

lowerCAmelCase	=							[
    'facebook/regnet-y-040',
    # See all regnet models at https://huggingface.co/models?filter=regnet
]


class 	_a							(      nn.Module      ):

							def __init__(							self:     List[Any]   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int = 3   ,						UpperCamelCase_:     int = 1   ,						UpperCamelCase_:     int = 1   ,						UpperCamelCase_:     Optional[str] = "relu"   ,						)      ->       List[str]:





									"""simple docstring"""







									super().__init__()
									lowercase__						=				nn.Convad(
									    UpperCamelCase_   ,						UpperCamelCase_   ,						kernel_size=UpperCamelCase_   ,						stride=UpperCamelCase_   ,						padding=kernel_size // 2   ,						groups=UpperCamelCase_   ,						bias=UpperCamelCase_   ,						)
									lowercase__						=				nn.BatchNormad(UpperCamelCase_							)
									lowercase__						=				ACTaFN[activation] if activation is not None else nn.Identity()


							def 				lowerCamelCase_			(							self:     Union[str, Any]   ,						UpperCamelCase_:     List[str]							)      ->       Tuple:





									"""simple docstring"""







									lowercase__						=				self.convolution(UpperCamelCase_							)
									lowercase__						=				self.normalization(UpperCamelCase_							)
									lowercase__						=				self.activation(UpperCamelCase_							)
									return hidden_state


class 	_a							(      nn.Module      ):

							def __init__(							self:     Union[str, Any]   ,						UpperCamelCase_:     RegNetConfig							)      ->       Optional[Any]:





									"""simple docstring"""







									super().__init__()
									lowercase__						=				RegNetConvLayer(
									    config.num_channels   ,						config.embedding_size   ,						kernel_size=3   ,						stride=2   ,						activation=config.hidden_act							)
									lowercase__						=				config.num_channels


							def 				lowerCamelCase_			(							self:     List[str]   ,						UpperCamelCase_:     str							)      ->       Union[str, Any]:





									"""simple docstring"""







									lowercase__						=				pixel_values.shape[1]
									if num_channels != self.num_channels:
											raise ValueError(
											    '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.'''							)
									lowercase__						=				self.embedder(UpperCamelCase_							)
									return hidden_state


class 	_a							(      nn.Module      ):

							def __init__(							self:     List[Any]   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int = 2							)      ->       List[Any]:





									"""simple docstring"""







									super().__init__()
									lowercase__						=				nn.Convad(UpperCamelCase_   ,						UpperCamelCase_   ,						kernel_size=1   ,						stride=UpperCamelCase_   ,						bias=UpperCamelCase_							)
									lowercase__						=				nn.BatchNormad(UpperCamelCase_							)


							def 				lowerCamelCase_			(							self:     str   ,						UpperCamelCase_:     Tensor							)      ->       Tensor:





									"""simple docstring"""







									lowercase__						=				self.convolution(UpperCamelCase_							)
									lowercase__						=				self.normalization(UpperCamelCase_							)
									return hidden_state


class 	_a							(      nn.Module      ):

							def __init__(							self:     Tuple   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int							)      ->       List[Any]:





									"""simple docstring"""







									super().__init__()

									lowercase__						=				nn.AdaptiveAvgPoolad((1, 1)							)
									lowercase__						=				nn.Sequential(
									    nn.Convad(UpperCamelCase_   ,						UpperCamelCase_   ,						kernel_size=1							)   ,						nn.ReLU()   ,						nn.Convad(UpperCamelCase_   ,						UpperCamelCase_   ,						kernel_size=1							)   ,						nn.Sigmoid()   ,						)


							def 				lowerCamelCase_			(							self:     int   ,						UpperCamelCase_:     int							)      ->       Any:





									"""simple docstring"""







									lowercase__						=				self.pooler(UpperCamelCase_							)
									lowercase__						=				self.attention(UpperCamelCase_							)
									lowercase__						=				hidden_state * attention
									return hidden_state


class 	_a							(      nn.Module      ):

							def __init__(							self:     Tuple   ,						UpperCamelCase_:     RegNetConfig   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int = 1							)      ->       str:





									"""simple docstring"""







									super().__init__()
									lowercase__						=				in_channels != out_channels or stride != 1
									lowercase__						=				max(1   ,						out_channels // config.groups_width							)
									lowercase__						=				(
									    RegNetShortCut(UpperCamelCase_   ,						UpperCamelCase_   ,						stride=UpperCamelCase_							) if should_apply_shortcut else nn.Identity()
									)
									lowercase__						=				nn.Sequential(
									    RegNetConvLayer(UpperCamelCase_   ,						UpperCamelCase_   ,						kernel_size=1   ,						activation=config.hidden_act							)   ,						RegNetConvLayer(UpperCamelCase_   ,						UpperCamelCase_   ,						stride=UpperCamelCase_   ,						groups=UpperCamelCase_   ,						activation=config.hidden_act							)   ,						RegNetConvLayer(UpperCamelCase_   ,						UpperCamelCase_   ,						kernel_size=1   ,						activation=UpperCamelCase_							)   ,						)
									lowercase__						=				ACTaFN[config.hidden_act]


							def 				lowerCamelCase_			(							self:     Any   ,						UpperCamelCase_:     Union[str, Any]							)      ->       str:





									"""simple docstring"""







									lowercase__						=				hidden_state
									lowercase__						=				self.layer(UpperCamelCase_							)
									lowercase__						=				self.shortcut(UpperCamelCase_							)
									hidden_state += residual
									lowercase__						=				self.activation(UpperCamelCase_							)
									return hidden_state


class 	_a							(      nn.Module      ):

							def __init__(							self:     Optional[Any]   ,						UpperCamelCase_:     RegNetConfig   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int = 1							)      ->       Tuple:





									"""simple docstring"""







									super().__init__()
									lowercase__						=				in_channels != out_channels or stride != 1
									lowercase__						=				max(1   ,						out_channels // config.groups_width							)
									lowercase__						=				(
									    RegNetShortCut(UpperCamelCase_   ,						UpperCamelCase_   ,						stride=UpperCamelCase_							) if should_apply_shortcut else nn.Identity()
									)
									lowercase__						=				nn.Sequential(
									    RegNetConvLayer(UpperCamelCase_   ,						UpperCamelCase_   ,						kernel_size=1   ,						activation=config.hidden_act							)   ,						RegNetConvLayer(UpperCamelCase_   ,						UpperCamelCase_   ,						stride=UpperCamelCase_   ,						groups=UpperCamelCase_   ,						activation=config.hidden_act							)   ,						RegNetSELayer(UpperCamelCase_   ,						reduced_channels=int(round(in_channels / 4							)							)							)   ,						RegNetConvLayer(UpperCamelCase_   ,						UpperCamelCase_   ,						kernel_size=1   ,						activation=UpperCamelCase_							)   ,						)
									lowercase__						=				ACTaFN[config.hidden_act]


							def 				lowerCamelCase_			(							self:     str   ,						UpperCamelCase_:     List[str]							)      ->       int:





									"""simple docstring"""







									lowercase__						=				hidden_state
									lowercase__						=				self.layer(UpperCamelCase_							)
									lowercase__						=				self.shortcut(UpperCamelCase_							)
									hidden_state += residual
									lowercase__						=				self.activation(UpperCamelCase_							)
									return hidden_state


class 	_a							(      nn.Module      ):

							def __init__(							self:     Union[str, Any]   ,						UpperCamelCase_:     RegNetConfig   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     int = 2   ,						UpperCamelCase_:     int = 2   ,						)      ->       Dict:





									"""simple docstring"""







									super().__init__()

									lowercase__						=				RegNetXLayer if config.layer_type == '''x''' else RegNetYLayer

									lowercase__						=				nn.Sequential(
									    # downsampling is done in the first layer with stride of 2
									    layer(
									        UpperCamelCase_   ,						UpperCamelCase_   ,						UpperCamelCase_   ,						stride=UpperCamelCase_   ,						)   ,						*[layer(UpperCamelCase_   ,						UpperCamelCase_   ,						UpperCamelCase_							) for _ in range(depth - 1							)]   ,						)


							def 				lowerCamelCase_			(							self:     Union[str, Any]   ,						UpperCamelCase_:     List[Any]							)      ->       Union[str, Any]:





									"""simple docstring"""







									lowercase__						=				self.layers(UpperCamelCase_							)
									return hidden_state


class 	_a							(      nn.Module      ):

							def __init__(							self:     Dict   ,						UpperCamelCase_:     RegNetConfig							)      ->       str:





									"""simple docstring"""







									super().__init__()
									lowercase__						=				nn.ModuleList([]							)
									# based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
									self.stages.append(
									    RegNetStage(
									        UpperCamelCase_   ,						config.embedding_size   ,						config.hidden_sizes[0]   ,						stride=2 if config.downsample_in_first_stage else 1   ,						depth=config.depths[0]   ,						)							)
									lowercase__						=				zip(config.hidden_sizes   ,						config.hidden_sizes[1:]							)
									for (in_channels, out_channels), depth in zip(UpperCamelCase_   ,						config.depths[1:]							):
											self.stages.append(RegNetStage(UpperCamelCase_   ,						UpperCamelCase_   ,						UpperCamelCase_   ,						depth=UpperCamelCase_							)							)


							def 				lowerCamelCase_			(							self:     Tuple   ,						UpperCamelCase_:     Tensor   ,						UpperCamelCase_:     bool = False   ,						UpperCamelCase_:     bool = True							)      ->       BaseModelOutputWithNoAttention:





									"""simple docstring"""







									lowercase__						=				() if output_hidden_states else None

									for stage_module in self.stages:
											if output_hidden_states:
													lowercase__						=				hidden_states + (hidden_state,)

											lowercase__						=				stage_module(UpperCamelCase_							)

									if output_hidden_states:
											lowercase__						=				hidden_states + (hidden_state,)

									if not return_dict:
											return tuple(v for v in [hidden_state, hidden_states] if v is not None							)

									return BaseModelOutputWithNoAttention(last_hidden_state=UpperCamelCase_   ,						hidden_states=UpperCamelCase_							)


class 	_a							(      UpperCamelCase__      ):
							_lowercase     :      Tuple  				=			RegNetConfig
							_lowercase     :      str  				=			'''regnet'''
							_lowercase     :      Tuple  				=			'''pixel_values'''
							_lowercase     :      Dict  				=			True

							def 				lowerCamelCase_			(							self:     int   ,						UpperCamelCase_:     Optional[Any]							)      ->       str:





									"""simple docstring"""







									if isinstance(UpperCamelCase_   ,						nn.Convad							):
											nn.init.kaiming_normal_(module.weight   ,						mode='''fan_out'''   ,						nonlinearity='''relu'''							)
									elif isinstance(UpperCamelCase_   ,						(nn.BatchNormad, nn.GroupNorm)							):
											nn.init.constant_(module.weight   ,						1							)
											nn.init.constant_(module.bias   ,						0							)


							def 				lowerCamelCase_			(							self:     Any   ,						UpperCamelCase_:     List[Any]   ,						UpperCamelCase_:     Tuple=False							)      ->       Optional[int]:





									"""simple docstring"""







									if isinstance(UpperCamelCase_   ,						UpperCamelCase_							):
											lowercase__						=				value
lowerCAmelCase	=							R'\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n'

lowerCAmelCase	=							R'\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.\n'


@add_start_docstrings(
    '''The bare RegNet model outputting raw features without any specific head on top.'''					,     UpperCamelCase__					,     )
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class 	_a							(      UpperCamelCase__      ):

							def __init__(							self:     List[str]   ,						UpperCamelCase_:     List[Any]							)      ->       Any:





									"""simple docstring"""







									super().__init__(UpperCamelCase_							)
									lowercase__						=				config
									lowercase__						=				RegNetEmbeddings(UpperCamelCase_							)
									lowercase__						=				RegNetEncoder(UpperCamelCase_							)
									lowercase__						=				nn.AdaptiveAvgPoolad((1, 1)							)
									# Initialize weights and apply final processing
									self.post_init()


							@add_start_docstrings_to_model_forward(UpperCamelCase_							)
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC   ,						output_type=UpperCamelCase_   ,						config_class=_CONFIG_FOR_DOC   ,						modality='''vision'''   ,						expected_output=_EXPECTED_OUTPUT_SHAPE   ,						)
							def 				lowerCamelCase_			(							self:     Optional[Any]   ,						UpperCamelCase_:     Tensor   ,						UpperCamelCase_:     Optional[bool] = None   ,						UpperCamelCase_:     Optional[bool] = None							)      ->       BaseModelOutputWithPoolingAndNoAttention:





									"""simple docstring"""







									lowercase__						=				(
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									lowercase__						=				return_dict if return_dict is not None else self.config.use_return_dict

									lowercase__						=				self.embedder(UpperCamelCase_							)

									lowercase__						=				self.encoder(
									    UpperCamelCase_   ,						output_hidden_states=UpperCamelCase_   ,						return_dict=UpperCamelCase_							)

									lowercase__						=				encoder_outputs[0]

									lowercase__						=				self.pooler(UpperCamelCase_							)

									if not return_dict:
											return (last_hidden_state, pooled_output) + encoder_outputs[1:]

									return BaseModelOutputWithPoolingAndNoAttention(
									    last_hidden_state=UpperCamelCase_   ,						pooler_output=UpperCamelCase_   ,						hidden_states=encoder_outputs.hidden_states   ,						)


@add_start_docstrings(
    '''
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''					,     UpperCamelCase__					,     )
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class 	_a							(      UpperCamelCase__      ):

							def __init__(							self:     Union[str, Any]   ,						UpperCamelCase_:     List[str]							)      ->       Optional[Any]:





									"""simple docstring"""







									super().__init__(UpperCamelCase_							)
									lowercase__						=				config.num_labels
									lowercase__						=				RegNetModel(UpperCamelCase_							)
									# classification head
									lowercase__						=				nn.Sequential(
									    nn.Flatten()   ,						nn.Linear(config.hidden_sizes[-1]   ,						config.num_labels							) if config.num_labels > 0 else nn.Identity()   ,						)
									# initialize weights and apply final processing
									self.post_init()


							@add_start_docstrings_to_model_forward(UpperCamelCase_							)
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT   ,						output_type=UpperCamelCase_   ,						config_class=_CONFIG_FOR_DOC   ,						expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT   ,						)
							def 				lowerCamelCase_			(							self:     Tuple   ,						UpperCamelCase_:     Optional[torch.FloatTensor] = None   ,						UpperCamelCase_:     Optional[torch.LongTensor] = None   ,						UpperCamelCase_:     Optional[bool] = None   ,						UpperCamelCase_:     Optional[bool] = None   ,						)      ->       ImageClassifierOutputWithNoAttention:





									"""simple docstring"""







									lowercase__						=				return_dict if return_dict is not None else self.config.use_return_dict

									lowercase__						=				self.regnet(UpperCamelCase_   ,						output_hidden_states=UpperCamelCase_   ,						return_dict=UpperCamelCase_							)

									lowercase__						=				outputs.pooler_output if return_dict else outputs[1]

									lowercase__						=				self.classifier(UpperCamelCase_							)

									lowercase__						=				None

									if labels is not None:
											if self.config.problem_type is None:
													if self.num_labels == 1:
															lowercase__						=				'''regression'''
													elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
															lowercase__						=				'''single_label_classification'''
													else:
															lowercase__						=				'''multi_label_classification'''
											if self.config.problem_type == "regression":
													lowercase__						=				MSELoss()
													if self.num_labels == 1:
															lowercase__						=				loss_fct(logits.squeeze()   ,						labels.squeeze()							)
													else:
															lowercase__						=				loss_fct(UpperCamelCase_   ,						UpperCamelCase_							)
											elif self.config.problem_type == "single_label_classification":
													lowercase__						=				CrossEntropyLoss()
													lowercase__						=				loss_fct(logits.view(-1   ,						self.num_labels							)   ,						labels.view(-1							)							)
											elif self.config.problem_type == "multi_label_classification":
													lowercase__						=				BCEWithLogitsLoss()
													lowercase__						=				loss_fct(UpperCamelCase_   ,						UpperCamelCase_							)

									if not return_dict:
											lowercase__						=				(logits,) + outputs[2:]
											return (loss,) + output if loss is not None else output

									return ImageClassifierOutputWithNoAttention(loss=UpperCamelCase_   ,						logits=UpperCamelCase_   ,						hidden_states=outputs.hidden_states							)






import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


lowerCAmelCase	=							version.parse(importlib_metadata.version('nltk'))
if NLTK_VERSION >= version.Version('3.6.4'):
			from nltk import word_tokenize


lowerCAmelCase	=							'\\n@inproceedings{banarjee2005,\n  title     = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n  author    = {Banerjee, Satanjeev  and Lavie, Alon},\n  booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n  month     = jun,\n  year      = {2005},\n  address   = {Ann Arbor, Michigan},\n  publisher = {Association for Computational Linguistics},\n  url       = {https://www.aclweb.org/anthology/W05-0909},\n  pages     = {65--72},\n}\n'

lowerCAmelCase	=							'\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n'

lowerCAmelCase	=							'\nComputes METEOR score of translated segments against one or more references.\nArgs:\n    predictions: list of predictions to score. Each prediction\n        should be a string with tokens separated by spaces.\n    references: list of reference for each prediction. Each\n        reference should be a string with tokens separated by spaces.\n    alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n    beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n    gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n    \'meteor\': meteor score.\nExamples:\n\n    >>> meteor = datasets.load_metric(\'meteor\')\n    >>> predictions = ["It is a guide to action which ensures that the military always obeys the commands of the party"]\n    >>> references = ["It is a guide to action that ensures that the military will forever heed Party commands"]\n    >>> results = meteor.compute(predictions=predictions, references=references)\n    >>> print(round(results["meteor"], 4))\n    0.6944\n'


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

							def 				lowerCamelCase_			(							self:     Optional[Any]							)      ->       Union[str, Any]:





									"""simple docstring"""







									return datasets.MetricInfo(
									    description=_DESCRIPTION   ,						citation=_CITATION   ,						inputs_description=_KWARGS_DESCRIPTION   ,						features=datasets.Features(
									        {
									            '''predictions''': datasets.Value('''string'''   ,						id='''sequence'''							),
									            '''references''': datasets.Value('''string'''   ,						id='''sequence'''							),
									        }							)   ,						codebase_urls=['''https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py''']   ,						reference_urls=[
									        '''https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score''',
									        '''https://en.wikipedia.org/wiki/METEOR''',
									    ]   ,						)

							def 				lowerCamelCase_			(							self:     Union[str, Any]   ,						UpperCamelCase_:     List[str]							)      ->       Union[str, Any]:





									"""simple docstring"""







									import nltk

									nltk.download('''wordnet'''							)
									if NLTK_VERSION >= version.Version('''3.6.5'''							):
											nltk.download('''punkt'''							)
									if NLTK_VERSION >= version.Version('''3.6.6'''							):
											nltk.download('''omw-1.4'''							)


							def 				lowerCamelCase_			(							self:     Any   ,						UpperCamelCase_:     Union[str, Any]   ,						UpperCamelCase_:     Tuple   ,						UpperCamelCase_:     Dict=0.9   ,						UpperCamelCase_:     Union[str, Any]=3   ,						UpperCamelCase_:     Optional[int]=0.5							)      ->       Dict:





									"""simple docstring"""







									if NLTK_VERSION >= version.Version('''3.6.5'''							):
											lowercase__						=				[
											    meteor_score.single_meteor_score(
											        word_tokenize(UpperCamelCase_							)   ,						word_tokenize(UpperCamelCase_							)   ,						alpha=UpperCamelCase_   ,						beta=UpperCamelCase_   ,						gamma=UpperCamelCase_							)
											    for ref, pred in zip(UpperCamelCase_   ,						UpperCamelCase_							)
											]
									else:
											lowercase__						=				[
											    meteor_score.single_meteor_score(UpperCamelCase_   ,						UpperCamelCase_   ,						alpha=UpperCamelCase_   ,						beta=UpperCamelCase_   ,						gamma=UpperCamelCase_							)
											    for ref, pred in zip(UpperCamelCase_   ,						UpperCamelCase_							)
											]

									return {"meteor": np.mean(UpperCamelCase_							)}


