






"""simple docstring"""


import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
           MODEL_FOR_QUESTION_ANSWERING_MAPPING,
           MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
           MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
           LayoutLMvaConfig,
           LayoutLMvaForQuestionAnswering,
           LayoutLMvaForSequenceClassification,
           LayoutLMvaForTokenClassification,
           LayoutLMvaModel,
       )
       from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
       from PIL import Image

       from transformers import LayoutLMvaImageProcessor


class 					snake_case		:


   '''simple docstring'''

   def __init__(	self :     Any,       _lowerCamelCase :     Dict,       _lowerCamelCase :     Tuple=2,       _lowerCamelCase :     str=3,       _lowerCamelCase :     int=4,       _lowerCamelCase :     List[Any]=2,       _lowerCamelCase :     Optional[Any]=7,       _lowerCamelCase :     Dict=True,       _lowerCamelCase :     str=True,       _lowerCamelCase :     Tuple=True,       _lowerCamelCase :     Any=True,       _lowerCamelCase :     int=99,       _lowerCamelCase :     Any=36,       _lowerCamelCase :     Tuple=3,       _lowerCamelCase :     int=4,       _lowerCamelCase :     Tuple=37,       _lowerCamelCase :     Union[str, Any]="gelu",       _lowerCamelCase :     List[str]=0.1,       _lowerCamelCase :     Optional[int]=0.1,       _lowerCamelCase :     Any=5_12,       _lowerCamelCase :     List[str]=16,       _lowerCamelCase :     List[str]=2,       _lowerCamelCase :     List[Any]=0.02,       _lowerCamelCase :     List[str]=6,       _lowerCamelCase :     Union[str, Any]=6,       _lowerCamelCase :     Optional[int]=3,       _lowerCamelCase :     Optional[Any]=4,       _lowerCamelCase :     List[str]=None,       _lowerCamelCase :     Tuple=10_00,       ):

     '''simple docstring'''
     __A									= parent
     __A									= batch_size
     __A									= num_channels
     __A									= image_size
     __A									= patch_size
     __A									= text_seq_length
     __A									= is_training
     __A									= use_input_mask
     __A									= use_token_type_ids
     __A									= use_labels
     __A									= vocab_size
     __A									= hidden_size
     __A									= num_hidden_layers
     __A									= num_attention_heads
     __A									= intermediate_size
     __A									= hidden_act
     __A									= hidden_dropout_prob
     __A									= attention_probs_dropout_prob
     __A									= max_position_embeddings
     __A									= type_vocab_size
     __A									= type_sequence_label_size
     __A									= initializer_range
     __A									= coordinate_size
     __A									= shape_size
     __A									= num_labels
     __A									= num_choices
     __A									= scope
     __A									= range_bbox

     # LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
     __A									= text_seq_length
     __A									= (image_size // patch_size) ** 2 + 1
     __A									= self.text_seq_length + self.image_seq_length


   def 				_SCREAMING_SNAKE_CASE				(	self :     Tuple  ):

     '''simple docstring'''
     __A									= ids_tensor([self.batch_size, self.text_seq_length],       self.vocab_size  )

     __A									= ids_tensor([self.batch_size, self.text_seq_length, 4],       self.range_bbox  )
     # Ensure that bbox is legal
     for i in range(bbox.shape[0]  ):
       for j in range(bbox.shape[1]  ):
         if bbox[i, j, 3] < bbox[i, j, 1]:
           __A									= bbox[i, j, 3]
           __A									= bbox[i, j, 1]
           __A									= t
         if bbox[i, j, 2] < bbox[i, j, 0]:
           __A									= bbox[i, j, 2]
           __A									= bbox[i, j, 0]
           __A									= t

     __A									= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

     __A									= None
     if self.use_input_mask:
       __A									= random_attention_mask([self.batch_size, self.text_seq_length]  )

     __A									= None
     if self.use_token_type_ids:
       __A									= ids_tensor([self.batch_size, self.text_seq_length],       self.type_vocab_size  )

     __A									= None
     __A									= None
     if self.use_labels:
       __A									= ids_tensor([self.batch_size],       self.type_sequence_label_size  )
       __A									= ids_tensor([self.batch_size, self.text_seq_length],       self.num_labels  )

     __A									= LayoutLMvaConfig(
         vocab_size=self.vocab_size,       hidden_size=self.hidden_size,       num_hidden_layers=self.num_hidden_layers,       num_attention_heads=self.num_attention_heads,       intermediate_size=self.intermediate_size,       hidden_act=self.hidden_act,       hidden_dropout_prob=self.hidden_dropout_prob,       attention_probs_dropout_prob=self.attention_probs_dropout_prob,       max_position_embeddings=self.max_position_embeddings,       type_vocab_size=self.type_vocab_size,       initializer_range=self.initializer_range,       coordinate_size=self.coordinate_size,       shape_size=self.shape_size,       input_size=self.image_size,       patch_size=self.patch_size,       )

     return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int],       _lowerCamelCase :     Union[str, Any],       _lowerCamelCase :     List[str],       _lowerCamelCase :     Any,       _lowerCamelCase :     List[str],       _lowerCamelCase :     str,       _lowerCamelCase :     List[str],       _lowerCamelCase :     Tuple,       _lowerCamelCase :     Optional[Any]  ):

     '''simple docstring'''
     __A									= LayoutLMvaModel(config=_lowerCamelCase  )
     model.to(_lowerCamelCase  )
     model.eval()

     # text + image
     __A									= model(_lowerCamelCase,       pixel_values=_lowerCamelCase  )
     __A									= model(
         _lowerCamelCase,       bbox=_lowerCamelCase,       pixel_values=_lowerCamelCase,       attention_mask=_lowerCamelCase,       token_type_ids=_lowerCamelCase  )
     __A									= model(_lowerCamelCase,       bbox=_lowerCamelCase,       pixel_values=_lowerCamelCase,       token_type_ids=_lowerCamelCase  )
     __A									= model(_lowerCamelCase,       bbox=_lowerCamelCase,       pixel_values=_lowerCamelCase  )

     self.parent.assertEqual(result.last_hidden_state.shape,       (self.batch_size, self.seq_length, self.hidden_size)  )

     # text only
     __A									= model(_lowerCamelCase  )
     self.parent.assertEqual(
         result.last_hidden_state.shape,       (self.batch_size, self.text_seq_length, self.hidden_size)  )

     # image only
     __A									= model(pixel_values=_lowerCamelCase  )
     self.parent.assertEqual(
         result.last_hidden_state.shape,       (self.batch_size, self.image_seq_length, self.hidden_size)  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     Any,       _lowerCamelCase :     Tuple,       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     str,       _lowerCamelCase :     Dict,       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     int  ):

     '''simple docstring'''
     __A									= self.num_labels
     __A									= LayoutLMvaForSequenceClassification(_lowerCamelCase  )
     model.to(_lowerCamelCase  )
     model.eval()
     __A									= model(
         _lowerCamelCase,       bbox=_lowerCamelCase,       pixel_values=_lowerCamelCase,       attention_mask=_lowerCamelCase,       token_type_ids=_lowerCamelCase,       labels=_lowerCamelCase,       )
     self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.num_labels)  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any],       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     List[Any],       _lowerCamelCase :     str,       _lowerCamelCase :     List[str],       _lowerCamelCase :     List[Any],       _lowerCamelCase :     List[str],       _lowerCamelCase :     Optional[int]  ):

     '''simple docstring'''
     __A									= self.num_labels
     __A									= LayoutLMvaForTokenClassification(config=_lowerCamelCase  )
     model.to(_lowerCamelCase  )
     model.eval()
     __A									= model(
         _lowerCamelCase,       bbox=_lowerCamelCase,       pixel_values=_lowerCamelCase,       attention_mask=_lowerCamelCase,       token_type_ids=_lowerCamelCase,       labels=_lowerCamelCase,       )
     self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.text_seq_length, self.num_labels)  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     int,       _lowerCamelCase :     Union[str, Any],       _lowerCamelCase :     List[str],       _lowerCamelCase :     int,       _lowerCamelCase :     Tuple,       _lowerCamelCase :     int,       _lowerCamelCase :     Any,       _lowerCamelCase :     Optional[Any],       _lowerCamelCase :     List[str]  ):

     '''simple docstring'''
     __A									= LayoutLMvaForQuestionAnswering(config=_lowerCamelCase  )
     model.to(_lowerCamelCase  )
     model.eval()
     __A									= model(
         _lowerCamelCase,       bbox=_lowerCamelCase,       pixel_values=_lowerCamelCase,       attention_mask=_lowerCamelCase,       token_type_ids=_lowerCamelCase,       start_positions=_lowerCamelCase,       end_positions=_lowerCamelCase,       )
     self.parent.assertEqual(result.start_logits.shape,       (self.batch_size, self.seq_length)  )
     self.parent.assertEqual(result.end_logits.shape,       (self.batch_size, self.seq_length)  )






   def 				_SCREAMING_SNAKE_CASE				(	self :     List[str]  ):

     '''simple docstring'''
     __A									= self.prepare_config_and_inputs()
     (
         (
         __A
     )			,    (
         __A
     )			,    (
         __A
     )			,    (
         __A
     )			,    (
         __A
     )			,    (
         __A
     )			,    (
         __A
     )			,    (
         __A
     )			,    
     )									= config_and_inputs
     __A									= {
         '''input_ids''': input_ids,
         '''bbox''': bbox,
         '''pixel_values''': pixel_values,
         '''token_type_ids''': token_type_ids,
         '''attention_mask''': input_mask,
     }
     return config, inputs_dict





@require_torch
class 					snake_case		(							_lowerCAmelCase   ,	_lowerCAmelCase   ,	unittest.TestCase						):


   '''simple docstring'''

   A_						:	Any						 = False
   A_						:	List[str]						 = False
   A_						:	int						 = False

   A_						:	Any						 = (
       (
           LayoutLMvaModel,
           LayoutLMvaForSequenceClassification,
           LayoutLMvaForTokenClassification,
           LayoutLMvaForQuestionAnswering,
       )
       if is_torch_available()
       else ()
   )
   A_						:	str						 = (
       {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
       if is_torch_available()
       else {}
   )


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int],       _lowerCamelCase :     Optional[Any],       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     Optional[Any],       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     List[Any]  ):

     '''simple docstring'''
     # `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
     # embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
     # the sequence dimension of the text embedding only.
     # (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
     return True


   def 				_SCREAMING_SNAKE_CASE				(	self :     Any  ):

     '''simple docstring'''
     __A									= LayoutLMvaModelTester(self  )
     __A									= ConfigTester(self,       config_class=_lowerCamelCase,       hidden_size=37  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any],       _lowerCamelCase :     Union[str, Any],       _lowerCamelCase :     List[str],       _lowerCamelCase :     int=False  ):

     '''simple docstring'''
     __A									= copy.deepcopy(_lowerCamelCase  )
     if model_class in get_values(_lowerCamelCase  ):
       __A									= {
           k: v.unsqueeze(1  ).expand(-1,       self.model_tester.num_choices,       -1  ).contiguous()
           if isinstance(_lowerCamelCase,       torch.Tensor  ) and v.ndim > 1
           else v
           for k, v in inputs_dict.items()
       }
     if return_labels:
       if model_class in get_values(_lowerCamelCase  ):
         __A									= torch.ones(self.model_tester.batch_size,       dtype=torch.long,       device=_lowerCamelCase  )
       elif model_class in get_values(_lowerCamelCase  ):
         __A									= torch.zeros(
             self.model_tester.batch_size,       dtype=torch.long,       device=_lowerCamelCase  )
         __A									= torch.zeros(
             self.model_tester.batch_size,       dtype=torch.long,       device=_lowerCamelCase  )
       elif model_class in [
           *get_values(_lowerCamelCase  ),
       ]:
         __A									= torch.zeros(
             self.model_tester.batch_size,       dtype=torch.long,       device=_lowerCamelCase  )
       elif model_class in [
           *get_values(_lowerCamelCase  ),
       ]:
         __A									= torch.zeros(
             (self.model_tester.batch_size, self.model_tester.text_seq_length),       dtype=torch.long,       device=_lowerCamelCase,       )

     return inputs_dict


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int]  ):

     '''simple docstring'''
     self.config_tester.run_common_tests()


   def 				_SCREAMING_SNAKE_CASE				(	self :     str  ):

     '''simple docstring'''
     __A									= self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowerCamelCase  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[Any]  ):

     '''simple docstring'''
     __A									= self.model_tester.prepare_config_and_inputs()
     for type in ["absolute", "relative_key", "relative_key_query"]:
       __A									= type
       self.model_tester.create_and_check_model(*_lowerCamelCase  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any]  ):

     '''simple docstring'''
     __A									= self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(*_lowerCamelCase  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[str]  ):

     '''simple docstring'''
     __A									= self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*_lowerCamelCase  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any]  ):

     '''simple docstring'''
     __A									= self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*_lowerCamelCase  )






   @slow
   def 				_SCREAMING_SNAKE_CASE				(	self :     List[str]  ):

     '''simple docstring'''
     for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __A									= LayoutLMvaModel.from_pretrained(_lowerCamelCase  )
       self.assertIsNotNone(_lowerCamelCase  )





def 					lowerCAmelCase				(    ):




  """simple docstring"""







  __A									= Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
  return image





@require_torch
class 					snake_case		(							unittest.TestCase						):


   '''simple docstring'''

   @cached_property
   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any]  ):

     '''simple docstring'''
     return LayoutLMvaImageProcessor(apply_ocr=_lowerCamelCase  ) if is_vision_available() else None






   @slow
   def 				_SCREAMING_SNAKE_CASE				(	self :     Tuple  ):

     '''simple docstring'''
     __A									= LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''  ).to(_lowerCamelCase  )

     __A									= self.default_image_processor
     __A									= prepare_img()
     __A									= image_processor(images=_lowerCamelCase,       return_tensors='''pt'''  ).pixel_values.to(_lowerCamelCase  )

     __A									= torch.tensor([[1, 2]]  )
     __A									= torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]  ).unsqueeze(0  )

     # forward pass
     __A									= model(
         input_ids=input_ids.to(_lowerCamelCase  ),       bbox=bbox.to(_lowerCamelCase  ),       pixel_values=pixel_values.to(_lowerCamelCase  ),       )

     # verify the logits
     __A									= torch.Size((1, 1_99, 7_68)  )
     self.assertEqual(outputs.last_hidden_state.shape,       _lowerCamelCase  )

     __A									= torch.tensor(
         [[-0.05_29, 0.36_18, 0.16_32], [-0.15_87, -0.16_67, -0.04_00], [-0.15_57, -0.16_71, -0.05_05]]  ).to(_lowerCamelCase  )

     self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3],       _lowerCamelCase,       atol=1e-4  )  )












"""simple docstring"""


from typing import Dict, List

from nltk.translate import gleu_score

import datasets
from datasets import MetricInfo


lowercase_				     =     '\\n@misc{wu2016googles,\n      title={Google\'s Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},\n      author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey\n              and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin\n              Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto\n              Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and\n              Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes\n              and Jeffrey Dean},\n      year={2016},\n      eprint={1609.08144},\n      archivePrefix={arXiv},\n      primaryClass={cs.CL}\n}\n'

lowercase_				     =     '\\nThe BLEU score has some undesirable properties when used for single\nsentences, as it was designed to be a corpus measure. We therefore\nuse a slightly different score for our RL experiments which we call\nthe \'GLEU score\'. For the GLEU score, we record all sub-sequences of\n1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then\ncompute a recall, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the target (ground truth) sequence,\nand a precision, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the generated output sequence. Then\nGLEU score is simply the minimum of recall and precision. This GLEU\nscore\'s range is always between 0 (no matches) and 1 (all match) and\nit is symmetrical when switching output and target. According to\nour experiments, GLEU score correlates quite well with the BLEU\nmetric on a corpus level but does not have its drawbacks for our per\nsentence reward objective.\n'

lowercase_				     =     '\\nComputes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.\nInstead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching\ntokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.\n\nArgs:\n    predictions (list of str): list of translations to score.\n        Each translation should be tokenized into a list of tokens.\n    references (list of list of str): list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.\n    max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.\n\nReturns:\n    \'google_bleu\': google_bleu score\n\nExamples:\n    Example 1:\n        >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',\n        ...         \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',\n        ...         \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']\n        >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',\n        ...          \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',\n        ...          \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']\n\n        >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',\n        ...         \'interested\', \'in\', \'world\', \'history\']\n        >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',\n        ...          \'because\', \'he\', \'read\', \'the\', \'book\']\n\n        >>> list_of_references = [[ref1a], [ref2a]]\n        >>> hypotheses = [hyp1, hyp2]\n        >>> google_bleu = datasets.load_metric("google_bleu")\n        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n        >>> print(round(results["google_bleu"], 2))\n        0.44\n\n    Example 2:\n        >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',\n        ...         \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',\n        ...         \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']\n        >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',\n        ...          \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',\n        ...          \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']\n        >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\',\n        ...          \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\',\n        ...          \'heed\', \'the\', \'cat\', \'commands\']\n        >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\',\n        ...          \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\',\n        ...          \'of\', \'the\', \'cat\']\n\n        >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',\n        ...         \'interested\', \'in\', \'world\', \'history\']\n        >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',\n        ...          \'because\', \'he\', \'read\', \'the\', \'book\']\n\n        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n        >>> hypotheses = [hyp1, hyp2]\n        >>> google_bleu = datasets.load_metric("google_bleu")\n        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n        >>> print(round(results["google_bleu"], 2))\n        0.61\n\n    Example 3:\n        >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',\n        ...         \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',\n        ...         \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']\n        >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',\n        ...          \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',\n        ...          \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']\n        >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\',\n        ...          \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\',\n        ...          \'heed\', \'the\', \'cat\', \'commands\']\n        >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\',\n        ...          \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\',\n        ...          \'of\', \'the\', \'cat\']\n\n        >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',\n        ...         \'interested\', \'in\', \'world\', \'history\']\n        >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',\n        ...          \'because\', \'he\', \'read\', \'the\', \'book\']\n\n        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n        >>> hypotheses = [hyp1, hyp2]\n        >>> google_bleu = datasets.load_metric("google_bleu")\n        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2)\n        >>> print(round(results["google_bleu"], 2))\n        0.53\n\n    Example 4:\n        >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',\n        ...         \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',\n        ...         \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']\n        >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',\n        ...          \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',\n        ...          \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']\n        >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\',\n        ...          \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\',\n        ...          \'heed\', \'the\', \'cat\', \'commands\']\n        >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\',\n        ...          \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\',\n        ...          \'of\', \'the\', \'cat\']\n\n        >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',\n        ...         \'interested\', \'in\', \'world\', \'history\']\n        >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',\n        ...          \'because\', \'he\', \'read\', \'the\', \'book\']\n\n        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n        >>> hypotheses = [hyp1, hyp2]\n        >>> google_bleu = datasets.load_metric("google_bleu")\n        >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6)\n        >>> print(round(results["google_bleu"], 2))\n        0.4\n'


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


   '''simple docstring'''

   def 				_SCREAMING_SNAKE_CASE				(	self :     Union[str, Any]  ):

     '''simple docstring'''
     return datasets.MetricInfo(
         description=_DESCRIPTION,       citation=_CITATION,       inputs_description=_KWARGS_DESCRIPTION,       features=datasets.Features(
             {
                 '''predictions''': datasets.Sequence(datasets.Value('''string''',       id='''token'''  ),       id='''sequence'''  ),
                 '''references''': datasets.Sequence(
                     datasets.Sequence(datasets.Value('''string''',       id='''token'''  ),       id='''sequence'''  ),       id='''references'''  ),
             }  ),       )






   def 				_SCREAMING_SNAKE_CASE				(	self :     str,       _lowerCamelCase :     List[List[List[str]]],       _lowerCamelCase :     List[List[str]],       _lowerCamelCase :     int = 1,       _lowerCamelCase :     int = 4,       ):

     '''simple docstring'''
     return {
         "google_bleu": gleu_score.corpus_gleu(
             list_of_references=_lowerCamelCase,       hypotheses=_lowerCamelCase,       min_len=_lowerCamelCase,       max_len=_lowerCamelCase  )
     }




