





'''simple docstring'''

import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


__lowerCAmelCase							:     Optional[int]		     =logging.get_logger(__name__)


__lowerCAmelCase							:     Optional[int]		     ={"vocab_file": "vocab.json", "merges_file": "merges.txt"}

# See all BART models at https://huggingface.co/models?filter=bart
__lowerCAmelCase							:     Dict		     ={
    "vocab_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/vocab.json",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/vocab.json",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json",
    },
    "merges_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/merges.txt",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/merges.txt",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt",
    },
}

__lowerCAmelCase							:     str		     ={
    "facebook/bart-base": 1024,
    "facebook/bart-large": 1024,
    "facebook/bart-large-mnli": 1024,
    "facebook/bart-large-cnn": 1024,
    "facebook/bart-large-xsum": 1024,
    "yjernite/bart_eli5": 1024,
}





@lru_cache()
def 						UpperCamelCase    (							):
    A__    =      (
        list(range(ord("!"	)						,	ord("~"	) + 1	)	) + list(range(ord("¡"	)						,	ord("¬"	) + 1	)	) + list(range(ord("®"	)						,	ord("ÿ"	) + 1	)	)
    )
    A__    =      bs[:]
    A__    =      0
    for b in range(2**8	):
        if b not in bs:
            bs.append(_lowerCamelCase	)
            cs.append(2**8 + n	)
            n += 1
    A__    =      [chr(_lowerCamelCase	) for n in cs]
    return dict(zip(_lowerCamelCase						,	_lowerCamelCase	)	)





def 						UpperCamelCase    (							_lowerCamelCase : List[str]	):
    A__    =      set()
    A__    =      word[0]
    for char in word[1:]:
        pairs.add((prev_char, char)	)
        A__    =      char
    return pairs






class        UpperCAmelCase     (	UpperCamelCase__    ):
 __lowercase       		=    VOCAB_FILES_NAMES
 __lowercase       		=    PRETRAINED_VOCAB_FILES_MAP
 __lowercase       		=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __lowercase       		=    ["""input_ids""", """attention_mask"""]
 def __init__(    self				:str						,	lowercase_				:str						,	lowercase_				:str						,	lowercase_				:Union[str, Any]="replace"						,	lowercase_				:Dict="<s>"						,	lowercase_				:Union[str, Any]="</s>"						,	lowercase_				:List[Any]="</s>"						,	lowercase_				:List[Any]="<s>"						,	lowercase_				:Tuple="<unk>"						,	lowercase_				:Union[str, Any]="<pad>"						,	lowercase_				:Optional[int]="<mask>"						,	lowercase_				:List[str]=False						,	**lowercase_				:Any						,	)->							str:
     A__    =      AddedToken(lowercase_						,	lstrip=lowercase_						,	rstrip=lowercase_							) if isinstance(lowercase_						,	lowercase_							) else bos_token
     A__    =      AddedToken(lowercase_						,	lstrip=lowercase_						,	rstrip=lowercase_							) if isinstance(lowercase_						,	lowercase_							) else eos_token
     A__    =      AddedToken(lowercase_						,	lstrip=lowercase_						,	rstrip=lowercase_							) if isinstance(lowercase_						,	lowercase_							) else sep_token
     A__    =      AddedToken(lowercase_						,	lstrip=lowercase_						,	rstrip=lowercase_							) if isinstance(lowercase_						,	lowercase_							) else cls_token
     A__    =      AddedToken(lowercase_						,	lstrip=lowercase_						,	rstrip=lowercase_							) if isinstance(lowercase_						,	lowercase_							) else unk_token
     A__    =      AddedToken(lowercase_						,	lstrip=lowercase_						,	rstrip=lowercase_							) if isinstance(lowercase_						,	lowercase_							) else pad_token

     # Mask token behave like a normal word, i.e. include the space before it
     A__    =      AddedToken(lowercase_						,	lstrip=lowercase_						,	rstrip=lowercase_							) if isinstance(lowercase_						,	lowercase_							) else mask_token

     super().__init__(
         errors=lowercase_						,	bos_token=lowercase_						,	eos_token=lowercase_						,	unk_token=lowercase_						,	sep_token=lowercase_						,	cls_token=lowercase_						,	pad_token=lowercase_						,	mask_token=lowercase_						,	add_prefix_space=lowercase_						,	**lowercase_						,	)

     with open(lowercase_						,	encoding="utf-8"							) as vocab_handle:
         A__    =      json.load(lowercase_							)
     A__    =      {v: k for k, v in self.encoder.items()}
     A__    =      errors  # how to handle errors in decoding
     A__    =      bytes_to_unicode()
     A__    =      {v: k for k, v in self.byte_encoder.items()}
     with open(lowercase_						,	encoding="utf-8"							) as merges_handle:
         A__    =      merges_handle.read().split("\n"							)[1:-1]
     A__    =      [tuple(merge.split()							) for merge in bpe_merges]
     A__    =      dict(zip(lowercase_						,	range(len(lowercase_							)							)							)							)
     A__    =      {}
     A__    =      add_prefix_space

     # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
     A__    =      re.compile(R"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"							)
 @property
 def 					UpperCAmelCase_							(    self				:List[Any]							)->							int:
     return len(self.encoder							)
 def 					UpperCAmelCase_							(    self				:List[Any]							)->							Optional[int]:
     return dict(self.encoder						,	**self.added_tokens_encoder							)
 def 					UpperCAmelCase_							(    self				:List[Any]						,	lowercase_				:Tuple							)->							Tuple:
     if token in self.cache:
         return self.cache[token]
     A__    =      tuple(lowercase_							)
     A__    =      get_pairs(lowercase_							)

     if not pairs:
         return token

     while True:
         A__    =      min(lowercase_						,	key=lambda lowercase_							: self.bpe_ranks.get(lowercase_						,	float("inf"							)							)							)
         if bigram not in self.bpe_ranks:
             break
         A__,     A__    =      bigram
         A__    =      []
         A__    =      0
         while i < len(lowercase_							):
             try:
                 A__    =      word.index(lowercase_						,	lowercase_							)
             except ValueError:
                 new_word.extend(word[i:]							)
                 break
             else:
                 new_word.extend(word[i:j]							)
                 A__    =      j

             if word[i] == first and i < len(lowercase_							) - 1 and word[i + 1] == second:
                 new_word.append(first + second							)
                 i += 2
             else:
                 new_word.append(word[i]							)
                 i += 1
         A__    =      tuple(lowercase_							)
         A__    =      new_word
         if len(lowercase_							) == 1:
             break
         else:
             A__    =      get_pairs(lowercase_							)
     A__    =      " ".join(lowercase_							)
     A__    =      word
     return word
 def 					UpperCAmelCase_							(    self				:Dict						,	lowercase_				:Dict							)->							Dict:
     A__    =      []
     for token in re.findall(self.pat						,	lowercase_							):
         A__    =      "".join(
             self.byte_encoder[b] for b in token.encode("utf-8"							)							)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
         bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowercase_							).split(" "							)							)
     return bpe_tokens
 def 					UpperCAmelCase_							(    self				:str						,	lowercase_				:List[str]							)->							Dict:
     return self.encoder.get(lowercase_						,	self.encoder.get(self.unk_token							)							)
 def 					UpperCAmelCase_							(    self				:int						,	lowercase_				:List[str]							)->							List[Any]:
     return self.decoder.get(lowercase_							)
 def 					UpperCAmelCase_							(    self				:str						,	lowercase_				:Union[str, Any]							)->							Tuple:
     A__    =      "".join(lowercase_							)
     A__    =      bytearray([self.byte_decoder[c] for c in text]							).decode("utf-8"						,	errors=self.errors							)
     return text
 def 					UpperCAmelCase_							(    self				:Optional[Any]						,	lowercase_				:str						,	lowercase_				:Optional[str] = None							)->							Tuple[str]:
     if not os.path.isdir(lowercase_							):
         logger.error(F"Vocabulary path ({save_directory}) should be a directory"							)
         return
     A__    =      os.path.join(
         lowercase_						,	(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]							)
     A__    =      os.path.join(
         lowercase_						,	(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]							)

     with open(lowercase_						,	"w"						,	encoding="utf-8"							) as f:
         f.write(json.dumps(self.encoder						,	indent=2						,	sort_keys=lowercase_						,	ensure_ascii=lowercase_							) + "\n"							)

     A__    =      0
     with open(lowercase_						,	"w"						,	encoding="utf-8"							) as writer:
         writer.write("#version: 0.2\n"							)
         for bpe_tokens, token_index in sorted(self.bpe_ranks.items()						,	key=lambda lowercase_							: kv[1]							):
             if index != token_index:
                 logger.warning(
                     F"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
                     " Please check that the tokenizer is not corrupted!"							)
                 A__    =      token_index
             writer.write(" ".join(lowercase_							) + "\n"							)
             index += 1

     return vocab_file, merge_file
 def 					UpperCAmelCase_							(    self				:List[Any]						,	lowercase_				:List[int]						,	lowercase_				:Optional[List[int]] = None							)->							List[int]:
     if token_ids_a is None:
         return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
     A__    =      [self.cls_token_id]
     A__    =      [self.sep_token_id]
     return cls + token_ids_a + sep + sep + token_ids_a + sep
 def 					UpperCAmelCase_							(    self				:Optional[int]						,	lowercase_				:List[int]						,	lowercase_				:Optional[List[int]] = None						,	lowercase_				:bool = False							)->							List[int]:
     if already_has_special_tokens:
         return super().get_special_tokens_mask(
             token_ids_a=lowercase_						,	token_ids_a=lowercase_						,	already_has_special_tokens=lowercase_							)

     if token_ids_a is None:
         return [1] + ([0] * len(lowercase_							)) + [1]
     return [1] + ([0] * len(lowercase_							)) + [1, 1] + ([0] * len(lowercase_							)) + [1]
 def 					UpperCAmelCase_							(    self				:Optional[Any]						,	lowercase_				:List[int]						,	lowercase_				:Optional[List[int]] = None							)->							List[int]:
     A__    =      [self.sep_token_id]
     A__    =      [self.cls_token_id]

     if token_ids_a is None:
         return len(cls + token_ids_a + sep							) * [0]
     return len(cls + token_ids_a + sep + sep + token_ids_a + sep							) * [0]



 def 					UpperCAmelCase_							(    self				:List[str]						,	lowercase_				:Optional[Any]						,	lowercase_				:Any=False						,	**lowercase_				:List[Any]							)->							List[Any]:
     A__    =      kwargs.pop("add_prefix_space"						,	self.add_prefix_space							)
     if (is_split_into_words or add_prefix_space) and (len(lowercase_							) > 0 and not text[0].isspace()):
         A__    =      " " + text
     return (text, kwargs)










'''simple docstring'''

import tempfile

import torch

from diffusers import PNDMScheduler

from .test_schedulers import SchedulerCommonTest






class        UpperCAmelCase     (	UpperCamelCase__    ):
 __lowercase       		=    (PNDMScheduler,)
 __lowercase       		=    (("""num_inference_steps""", 50),)
 def 					UpperCAmelCase_							(    self				:List[str]						,	**lowercase_				:Optional[int]							)->							List[str]:
     A__    =      {
         "num_train_timesteps": 10_00,
         "beta_start": 0.0_0_0_1,
         "beta_end": 0.0_2,
         "beta_schedule": "linear",
     }

     config.update(**lowercase_							)
     return config
 def 					UpperCAmelCase_							(    self				:int						,	lowercase_				:Optional[int]=0						,	**lowercase_				:Any							)->							int:
     A__    =      dict(self.forward_default_kwargs							)
     A__    =      kwargs.pop("num_inference_steps"						,	lowercase_							)
     A__    =      self.dummy_sample
     A__    =      0.1 * sample
     A__    =      [residual + 0.2, residual + 0.1_5, residual + 0.1, residual + 0.0_5]

     for scheduler_class in self.scheduler_classes:
         A__    =      self.get_scheduler_config(**lowercase_							)
         A__    =      scheduler_class(**lowercase_							)
         scheduler.set_timesteps(lowercase_							)
         # copy over dummy past residuals
         A__    =      dummy_past_residuals[:]

         with tempfile.TemporaryDirectory() as tmpdirname:
             scheduler.save_config(lowercase_							)
             A__    =      scheduler_class.from_pretrained(lowercase_							)
             new_scheduler.set_timesteps(lowercase_							)
             # copy over dummy past residuals
             A__    =      dummy_past_residuals[:]

         A__    =      scheduler.step_prk(lowercase_						,	lowercase_						,	lowercase_						,	**lowercase_							).prev_sample
         A__    =      new_scheduler.step_prk(lowercase_						,	lowercase_						,	lowercase_						,	**lowercase_							).prev_sample

         assert torch.sum(torch.abs(output - new_output							)							) < 1E-5, "Scheduler outputs are not identical"

         A__    =      scheduler.step_plms(lowercase_						,	lowercase_						,	lowercase_						,	**lowercase_							).prev_sample
         A__    =      new_scheduler.step_plms(lowercase_						,	lowercase_						,	lowercase_						,	**lowercase_							).prev_sample

         assert torch.sum(torch.abs(output - new_output							)							) < 1E-5, "Scheduler outputs are not identical"
 def 					UpperCAmelCase_							(    self				:List[Any]							)->							Tuple:
     pass
 def 					UpperCAmelCase_							(    self				:Optional[Any]						,	lowercase_				:Optional[Any]=0						,	**lowercase_				:List[str]							)->							str:
     A__    =      dict(self.forward_default_kwargs							)
     A__    =      kwargs.pop("num_inference_steps"						,	lowercase_							)
     A__    =      self.dummy_sample
     A__    =      0.1 * sample
     A__    =      [residual + 0.2, residual + 0.1_5, residual + 0.1, residual + 0.0_5]

     for scheduler_class in self.scheduler_classes:
         A__    =      self.get_scheduler_config()
         A__    =      scheduler_class(**lowercase_							)
         scheduler.set_timesteps(lowercase_							)

         # copy over dummy past residuals (must be after setting timesteps)
         A__    =      dummy_past_residuals[:]

         with tempfile.TemporaryDirectory() as tmpdirname:
             scheduler.save_config(lowercase_							)
             A__    =      scheduler_class.from_pretrained(lowercase_							)
             # copy over dummy past residuals
             new_scheduler.set_timesteps(lowercase_							)

             # copy over dummy past residual (must be after setting timesteps)
             A__    =      dummy_past_residuals[:]

         A__    =      scheduler.step_prk(lowercase_						,	lowercase_						,	lowercase_						,	**lowercase_							).prev_sample
         A__    =      new_scheduler.step_prk(lowercase_						,	lowercase_						,	lowercase_						,	**lowercase_							).prev_sample

         assert torch.sum(torch.abs(output - new_output							)							) < 1E-5, "Scheduler outputs are not identical"

         A__    =      scheduler.step_plms(lowercase_						,	lowercase_						,	lowercase_						,	**lowercase_							).prev_sample
         A__    =      new_scheduler.step_plms(lowercase_						,	lowercase_						,	lowercase_						,	**lowercase_							).prev_sample

         assert torch.sum(torch.abs(output - new_output							)							) < 1E-5, "Scheduler outputs are not identical"
 def 					UpperCAmelCase_							(    self				:Optional[int]						,	**lowercase_				:Dict							)->							Optional[int]:
     A__    =      self.scheduler_classes[0]
     A__    =      self.get_scheduler_config(**lowercase_							)
     A__    =      scheduler_class(**lowercase_							)

     A__    =      10
     A__    =      self.dummy_model()
     A__    =      self.dummy_sample_deter
     scheduler.set_timesteps(lowercase_							)

     for i, t in enumerate(scheduler.prk_timesteps							):
         A__    =      model(lowercase_						,	lowercase_							)
         A__    =      scheduler.step_prk(lowercase_						,	lowercase_						,	lowercase_							).prev_sample

     for i, t in enumerate(scheduler.plms_timesteps							):
         A__    =      model(lowercase_						,	lowercase_							)
         A__    =      scheduler.step_plms(lowercase_						,	lowercase_						,	lowercase_							).prev_sample

     return sample
 def 					UpperCAmelCase_							(    self				:int							)->							Union[str, Any]:
     A__    =      dict(self.forward_default_kwargs							)

     A__    =      kwargs.pop("num_inference_steps"						,	lowercase_							)

     for scheduler_class in self.scheduler_classes:
         A__    =      self.get_scheduler_config()
         A__    =      scheduler_class(**lowercase_							)

         A__    =      self.dummy_sample
         A__    =      0.1 * sample

         if num_inference_steps is not None and hasattr(lowercase_						,	"set_timesteps"							):
             scheduler.set_timesteps(lowercase_							)
         elif num_inference_steps is not None and not hasattr(lowercase_						,	"set_timesteps"							):
             A__    =      num_inference_steps

         # copy over dummy past residuals (must be done after set_timesteps)
         A__    =      [residual + 0.2, residual + 0.1_5, residual + 0.1, residual + 0.0_5]
         A__    =      dummy_past_residuals[:]

         A__    =      scheduler.step_prk(lowercase_						,	0						,	lowercase_						,	**lowercase_							).prev_sample
         A__    =      scheduler.step_prk(lowercase_						,	1						,	lowercase_						,	**lowercase_							).prev_sample

         self.assertEqual(output_a.shape						,	sample.shape							)
         self.assertEqual(output_a.shape						,	output_a.shape							)

         A__    =      scheduler.step_plms(lowercase_						,	0						,	lowercase_						,	**lowercase_							).prev_sample
         A__    =      scheduler.step_plms(lowercase_						,	1						,	lowercase_						,	**lowercase_							).prev_sample

         self.assertEqual(output_a.shape						,	sample.shape							)
         self.assertEqual(output_a.shape						,	output_a.shape							)
 def 					UpperCAmelCase_							(    self				:Any							)->							Dict:
     for timesteps in [1_00, 10_00]:
         self.check_over_configs(num_train_timesteps=lowercase_							)
 def 					UpperCAmelCase_							(    self				:List[str]							)->							int:
     for steps_offset in [0, 1]:
         self.check_over_configs(steps_offset=lowercase_							)

     A__    =      self.scheduler_classes[0]
     A__    =      self.get_scheduler_config(steps_offset=1							)
     A__    =      scheduler_class(**lowercase_							)
     scheduler.set_timesteps(10							)
     assert torch.equal(
         scheduler.timesteps						,	torch.LongTensor(
             [9_01, 8_51, 8_51, 8_01, 8_01, 7_51, 7_51, 7_01, 7_01, 6_51, 6_51, 6_01, 6_01, 5_01, 4_01, 3_01, 2_01, 1_01, 1]							)						,	)
 def 					UpperCAmelCase_							(    self				:Optional[Any]							)->							Any:
     for beta_start, beta_end in zip([0.0_0_0_1, 0.0_0_1]						,	[0.0_0_2, 0.0_2]							):
         self.check_over_configs(beta_start=lowercase_						,	beta_end=lowercase_							)
 def 					UpperCAmelCase_							(    self				:Tuple							)->							Tuple:
     for schedule in ["linear", "squaredcos_cap_v2"]:
         self.check_over_configs(beta_schedule=lowercase_							)
 def 					UpperCAmelCase_							(    self				:Optional[Any]							)->							Tuple:
     for prediction_type in ["epsilon", "v_prediction"]:
         self.check_over_configs(prediction_type=lowercase_							)
 def 					UpperCAmelCase_							(    self				:Optional[int]							)->							Tuple:
     for t in [1, 5, 10]:
         self.check_over_forward(time_step=lowercase_							)
 def 					UpperCAmelCase_							(    self				:List[Any]							)->							Optional[int]:
     for t, num_inference_steps in zip([1, 5, 10]						,	[10, 50, 1_00]							):
         self.check_over_forward(num_inference_steps=lowercase_							)
 def 					UpperCAmelCase_							(    self				:List[str]							)->							str:
     # earlier version of set_timesteps() caused an error indexing alpha's with inference steps as power of 3
     A__    =      27

     for scheduler_class in self.scheduler_classes:
         A__    =      self.dummy_sample
         A__    =      0.1 * sample

         A__    =      self.get_scheduler_config()
         A__    =      scheduler_class(**lowercase_							)

         scheduler.set_timesteps(lowercase_							)

         # before power of 3 fix, would error on first step, so we only need to do two
         for i, t in enumerate(scheduler.prk_timesteps[:2]							):
             A__    =      scheduler.step_prk(lowercase_						,	lowercase_						,	lowercase_							).prev_sample
 def 					UpperCAmelCase_							(    self				:List[str]							)->							str:
     with self.assertRaises(lowercase_							):
         A__    =      self.scheduler_classes[0]
         A__    =      self.get_scheduler_config()
         A__    =      scheduler_class(**lowercase_							)

         scheduler.step_plms(self.dummy_sample						,	1						,	self.dummy_sample							).prev_sample
 def 					UpperCAmelCase_							(    self				:int							)->							str:
     A__    =      self.full_loop()
     A__    =      torch.sum(torch.abs(lowercase_							)							)
     A__    =      torch.mean(torch.abs(lowercase_							)							)

     assert abs(result_sum.item() - 1_9_8.1_3_1_8							) < 1E-2
     assert abs(result_mean.item() - 0.2_5_8_0							) < 1E-3
 def 					UpperCAmelCase_							(    self				:Optional[Any]							)->							List[Any]:
     A__    =      self.full_loop(prediction_type="v_prediction"							)
     A__    =      torch.sum(torch.abs(lowercase_							)							)
     A__    =      torch.mean(torch.abs(lowercase_							)							)

     assert abs(result_sum.item() - 6_7.3_9_8_6							) < 1E-2
     assert abs(result_mean.item() - 0.0_8_7_8							) < 1E-3
 def 					UpperCAmelCase_							(    self				:Tuple							)->							Tuple:
     # We specify different beta, so that the first alpha is 0.99
     A__    =      self.full_loop(set_alpha_to_one=lowercase_						,	beta_start=0.0_1							)
     A__    =      torch.sum(torch.abs(lowercase_							)							)
     A__    =      torch.mean(torch.abs(lowercase_							)							)

     assert abs(result_sum.item() - 2_3_0.0_3_9_9							) < 1E-2
     assert abs(result_mean.item() - 0.2_9_9_5							) < 1E-3



 def 					UpperCAmelCase_							(    self				:Dict							)->							Any:
     # We specify different beta, so that the first alpha is 0.99
     A__    =      self.full_loop(set_alpha_to_one=lowercase_						,	beta_start=0.0_1							)
     A__    =      torch.sum(torch.abs(lowercase_							)							)
     A__    =      torch.mean(torch.abs(lowercase_							)							)

     assert abs(result_sum.item() - 1_8_6.9_4_8_2							) < 1E-2
     assert abs(result_mean.item() - 0.2_4_3_4							) < 1E-3



