
'''simple docstring'''


from typing import List

from packaging import version
from sklearn.metrics import fa_score

import datasets
from datasets.config import PY_VERSION


if PY_VERSION < version.parse("3.8"):
	import importlib_metadata
else:
	import importlib.metadata as importlib_metadata


# TODO(Patrick/Anton)
__SCREAMING_SNAKE_CASE						=      "\\n"

__SCREAMING_SNAKE_CASE						=      "\\n    XTREME-S is a benchmark to evaluate universal cross-lingual speech representations in many languages.\n    XTREME-S covers four task families: speech recognition, classification, speech-to-text translation and retrieval.\n"

__SCREAMING_SNAKE_CASE						=      "\nCompute XTREME-S evaluation metric associated to each XTREME-S dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    bleu_kwargs: optional dict of keywords to be passed when computing 'bleu'.\n        Keywords include Dict can be one of 'smooth_method', 'smooth_value', 'force', 'lowercase',\n        'tokenize', 'use_effective_order'.\n    wer_kwargs: optional dict of keywords to be passed when computing 'wer' and 'cer'.\n        Keywords include 'concatenate_texts'.\nReturns: depending on the XTREME-S task, one or several of:\n    \"accuracy\": Accuracy - for 'fleurs-lang_id', 'minds14'\n    \"f1\": F1 score - for 'minds14'\n    \"wer\": Word error rate - for 'mls', 'fleurs-asr', 'voxpopuli', 'babel'\n    \"cer\": Character error rate - for 'mls', 'fleurs-asr', 'voxpopuli', 'babel'\n    \"bleu\": BLEU score according to the `sacrebleu` metric - for 'covost2'\nExamples:\n\n    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'mls')  # 'mls', 'voxpopuli', 'fleurs-asr' or 'babel'\n    >>> references = [\"it is sunny here\", \"paper and pen are essentials\"]\n    >>> predictions = [\"it's sunny\", \"paper pen are essential\"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {'wer': 0.56, 'cer': 0.27}\n\n    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'covost2')\n    >>> references = [\"bonjour paris\", \"il est necessaire de faire du sport de temps en temp\"]\n    >>> predictions = [\"bonjour paris\", \"il est important de faire du sport souvent\"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {'bleu': 31.65}\n\n    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'fleurs-lang_id')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {'accuracy': 0.6}\n\n    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'minds14')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {'f1': 0.58, 'accuracy': 0.6}\n"

__SCREAMING_SNAKE_CASE						=      ["fleurs-asr", "mls", "voxpopuli", "babel", "covost2", "fleurs-lang_id", "minds14"]
__SCREAMING_SNAKE_CASE						=      ""

try:
	from jiwer import transforms as tr

	__SCREAMING_SNAKE_CASE						=      True
except ImportError:
	__SCREAMING_SNAKE_CASE						=      False

if _jiwer_available and version.parse(importlib_metadata.version("jiwer")) < version.parse("2.3.0"):




	class     __snake_case			(    tr.AbstractTransform	):




			def __init__(  self					:Union[str, Any]			,    _SCREAMING_SNAKE_CASE					:str = " ")					->			str:






									'''simple docstring'''






									UpperCamelCase_     :	Any					     =     sentence_delimiter




			def 	_snake_case	(  self					:List[str]			,    _SCREAMING_SNAKE_CASE					:str)					->			Dict:






									'''simple docstring'''






									return list(_SCREAMING_SNAKE_CASE)





			def 	_snake_case	(  self					:List[str]			,    _SCREAMING_SNAKE_CASE					:List[str])					->			int:






									'''simple docstring'''






									UpperCamelCase_     :	Optional[Any]					     =     []
									for sent_idx, sentence in enumerate(_SCREAMING_SNAKE_CASE):
															chars.extend(self.process_string(_SCREAMING_SNAKE_CASE))
															if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(_SCREAMING_SNAKE_CASE) - 1:
																					chars.append(self.sentence_delimiter)
									return chars







	__SCREAMING_SNAKE_CASE						=      tr.Compose(
	    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
	)
elif _jiwer_available:
	__SCREAMING_SNAKE_CASE						=      tr.Compose(
	    [
	        tr.RemoveMultipleSpaces(),
	        tr.Strip(),
	        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
	        tr.ReduceToListOfListOfChars(),
	    ]
	)
else:
	__SCREAMING_SNAKE_CASE						=      None
def 					__magic_name__(       UpperCAmelCase__ :       List[str]							,				UpperCAmelCase__ :       str	):
						return float((preds == labels).mean()	)
def 					__magic_name__(       UpperCAmelCase__ :       Tuple							,				UpperCAmelCase__ :       Union[str, Any]	):
						return {
						    "f1": float(fa_score(y_true=UpperCAmelCase__							,				y_pred=UpperCAmelCase__							,				average="""macro"""	)	),
						    "accuracy": simple_accuracy(UpperCAmelCase__							,				UpperCAmelCase__	),
						}
def 					__magic_name__(       UpperCAmelCase__ :       List[Any]							,				UpperCAmelCase__ :       Dict							,				UpperCAmelCase__ :       Dict="exp"							,				UpperCAmelCase__ :       Tuple=None							,				UpperCAmelCase__ :       Dict=False							,				UpperCAmelCase__ :       Any=False							,				UpperCAmelCase__ :       List[Any]=None							,				UpperCAmelCase__ :       Any=False							,				):
						# xtreme-s can only have one label
						UpperCamelCase_     :	str					     =     [[label] for label in labels]
						UpperCamelCase_     :	str					     =     list(UpperCAmelCase__	)
						try:
												import sacrebleu as scb
						except ImportError:
												raise ValueError(
												    """sacrebleu has to be installed in order to apply the bleu metric for covost2."""
												    """You can install it via `pip install sacrebleu`."""	)

						if version.parse(scb.__version__	) < version.parse("""1.4.12"""	):
												raise ImportWarning(
												    """To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn't match this condition.\n"""
												    """You can install it with `pip install \"sacrebleu>=1.4.12\"`."""	)

						UpperCamelCase_     :	Dict					     =     len(labels[0]	)
						if any(len(UpperCAmelCase__	) != references_per_prediction for refs in labels	):
												raise ValueError("""Sacrebleu requires the same number of references for each prediction"""	)
						UpperCamelCase_     :	Tuple					     =     [[refs[i] for refs in labels] for i in range(UpperCAmelCase__	)]
						UpperCamelCase_     :	Optional[int]					     =     scb.corpus_bleu(
						    UpperCAmelCase__							,				UpperCAmelCase__							,				smooth_method=UpperCAmelCase__							,				smooth_value=UpperCAmelCase__							,				force=UpperCAmelCase__							,				lowercase=UpperCAmelCase__							,				use_effective_order=UpperCAmelCase__							,				**({"""tokenize""": tokenize} if tokenize else {})							,				)
						return {"bleu": output.score}
def 					__magic_name__(       UpperCAmelCase__ :       Union[str, Any]							,				UpperCAmelCase__ :       str							,				UpperCAmelCase__ :       Any							,				UpperCAmelCase__ :       Dict	):
						try:
												from jiwer import compute_measures
						except ImportError:
												raise ValueError(
												    f"""jiwer has to be installed in order to apply the wer metric for {config_name}."""
												    """You can install it via `pip install jiwer`."""	)

						if concatenate_texts:
												UpperCamelCase_     :	Union[str, Any]					     =     compute_measures(UpperCAmelCase__							,				UpperCAmelCase__	)["""wer"""]

												UpperCamelCase_     :	int					     =     compute_measures(UpperCAmelCase__							,				UpperCAmelCase__							,				truth_transform=UpperCAmelCase__							,				hypothesis_transform=UpperCAmelCase__	)["""wer"""]
												return {"wer": wer, "cer": cer}
						else:

												def compute_score(UpperCAmelCase__ :       Any							,				UpperCAmelCase__ :       int							,				UpperCAmelCase__ :       Optional[int]="wer"	):
																		UpperCamelCase_     :	Any					     =     0
																		UpperCamelCase_     :	str					     =     0
																		for prediction, reference in zip(UpperCAmelCase__							,				UpperCAmelCase__	):
																								if score_type == "wer":
																														UpperCamelCase_     :	Optional[int]					     =     compute_measures(UpperCAmelCase__							,				UpperCAmelCase__	)
																								elif score_type == "cer":
																														UpperCamelCase_     :	Optional[Any]					     =     compute_measures(
																														    UpperCAmelCase__							,				UpperCAmelCase__							,				truth_transform=UpperCAmelCase__							,				hypothesis_transform=UpperCAmelCase__	)
																								incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
																								total += measures["substitutions"] + measures["deletions"] + measures["hits"]
																		return incorrect / total

												return {"wer": compute_score(UpperCAmelCase__							,				UpperCAmelCase__							,				"""wer"""	), "cer": compute_score(UpperCAmelCase__							,				UpperCAmelCase__							,				"""cer"""	)}







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




		def 	_snake_case	(  self					:str)					->			Tuple:






								'''simple docstring'''






								if self.config_name not in _CONFIG_NAMES:
														raise KeyError(F"""You should supply a configuration name selected in {_CONFIG_NAMES}""")

								UpperCamelCase_     :	List[Any]					     =     """int64""" if self.config_name in ["""fleurs-lang_id""", """minds14"""] else """string"""

								return datasets.MetricInfo(
								    description=_DESCRIPTION			,    citation=_CITATION			,    inputs_description=_KWARGS_DESCRIPTION			,    features=datasets.Features(
								        {"""predictions""": datasets.Value(_SCREAMING_SNAKE_CASE), """references""": datasets.Value(_SCREAMING_SNAKE_CASE)})			,    codebase_urls=[]			,    reference_urls=[]			,    format="""numpy"""			,    )





		def 	_snake_case	(  self					:Tuple			,    _SCREAMING_SNAKE_CASE					:Dict			,    _SCREAMING_SNAKE_CASE					:Any			,    _SCREAMING_SNAKE_CASE					:List[str]=None			,    _SCREAMING_SNAKE_CASE					:str=None)					->			Optional[int]:






								'''simple docstring'''






								UpperCamelCase_     :	str					     =     bleu_kwargs if bleu_kwargs is not None else {}
								UpperCamelCase_     :	Tuple					     =     wer_kwargs if wer_kwargs is not None else {}

								if self.config_name == "fleurs-lang_id":
														return {"accuracy": simple_accuracy(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE)}
								elif self.config_name == "minds14":
														return fa_and_simple_accuracy(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE)
								elif self.config_name == "covost2":
														UpperCamelCase_     :	Tuple					     =     bleu_kwargs.pop("""smooth_method"""			,    """exp""")
														UpperCamelCase_     :	Tuple					     =     bleu_kwargs.pop("""smooth_value"""			,    _SCREAMING_SNAKE_CASE)
														UpperCamelCase_     :	Dict					     =     bleu_kwargs.pop("""force"""			,    _SCREAMING_SNAKE_CASE)
														UpperCamelCase_     :	List[Any]					     =     bleu_kwargs.pop("""lowercase"""			,    _SCREAMING_SNAKE_CASE)
														UpperCamelCase_     :	Union[str, Any]					     =     bleu_kwargs.pop("""tokenize"""			,    _SCREAMING_SNAKE_CASE)
														UpperCamelCase_     :	str					     =     bleu_kwargs.pop("""use_effective_order"""			,    _SCREAMING_SNAKE_CASE)
														return bleu(
														    preds=_SCREAMING_SNAKE_CASE			,    labels=_SCREAMING_SNAKE_CASE			,    smooth_method=_SCREAMING_SNAKE_CASE			,    smooth_value=_SCREAMING_SNAKE_CASE			,    force=_SCREAMING_SNAKE_CASE			,    lowercase=_SCREAMING_SNAKE_CASE			,    tokenize=_SCREAMING_SNAKE_CASE			,    use_effective_order=_SCREAMING_SNAKE_CASE			,    )
								elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
														UpperCamelCase_     :	Any					     =     wer_kwargs.pop("""concatenate_texts"""			,    _SCREAMING_SNAKE_CASE)
														return wer_and_cer(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE			,    self.config_name)
								else:
														raise KeyError(F"""You should supply a configuration name selected in {_CONFIG_NAMES}""")






'''simple docstring'''


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

import PIL.Image
import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionImgaImgPipeline,
    StableDiffusionInpaintPipelineLegacy,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.configuration_utils import FrozenDict
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.utils import deprecate, logging


__SCREAMING_SNAKE_CASE						=      logging.get_logger(__name__)  # pylint: disable=invalid-name




class     __snake_case			(    _a	):
		a_          =					["safety_checker", "feature_extractor"]




		def __init__(  self					:str			,    _SCREAMING_SNAKE_CASE					:AutoencoderKL			,    _SCREAMING_SNAKE_CASE					:CLIPTextModel			,    _SCREAMING_SNAKE_CASE					:CLIPTokenizer			,    _SCREAMING_SNAKE_CASE					:UNetaDConditionModel			,    _SCREAMING_SNAKE_CASE					:Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]			,    _SCREAMING_SNAKE_CASE					:StableDiffusionSafetyChecker			,    _SCREAMING_SNAKE_CASE					:CLIPImageProcessor			,    _SCREAMING_SNAKE_CASE					:bool = True			,    )					->			int:






								'''simple docstring'''






								super().__init__()
								if hasattr(scheduler.config			,    """steps_offset""") and scheduler.config.steps_offset != 1:
														UpperCamelCase_     :	Optional[Any]					     =     (
														    F"""The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"""
														    F""" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure """
														    """to update the config accordingly as leaving `steps_offset` might led to incorrect results"""
														    """ in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"""
														    """ it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"""
														    """ file"""
														)
														deprecate("""steps_offset!=1"""			,    """1.0.0"""			,    _SCREAMING_SNAKE_CASE			,    standard_warn=_SCREAMING_SNAKE_CASE)
														UpperCamelCase_     :	Union[str, Any]					     =     dict(scheduler.config)
														UpperCamelCase_     :	Optional[Any]					     =     1
														UpperCamelCase_     :	int					     =     FrozenDict(_SCREAMING_SNAKE_CASE)

								self.register_modules(
								    vae=_SCREAMING_SNAKE_CASE			,    text_encoder=_SCREAMING_SNAKE_CASE			,    tokenizer=_SCREAMING_SNAKE_CASE			,    unet=_SCREAMING_SNAKE_CASE			,    scheduler=_SCREAMING_SNAKE_CASE			,    safety_checker=_SCREAMING_SNAKE_CASE			,    feature_extractor=_SCREAMING_SNAKE_CASE			,    )
								self.register_to_config(requires_safety_checker=_SCREAMING_SNAKE_CASE)




		@property
		def 	_snake_case	(  self					:Tuple)					->			Dict[str, Any]:






								'''simple docstring'''






								return {k: getattr(self			,    _SCREAMING_SNAKE_CASE) for k in self.config.keys() if not k.startswith("""_""")}




		def 	_snake_case	(  self					:Optional[int]			,    _SCREAMING_SNAKE_CASE					:Optional[Union[str, int]] = "auto")					->			Union[str, Any]:






								'''simple docstring'''






								if slice_size == "auto":
														# half the attention head size is usually a good trade-off between
														# speed and memory
														UpperCamelCase_     :	int					     =     self.unet.config.attention_head_dim // 2
								self.unet.set_attention_slice(_SCREAMING_SNAKE_CASE)




		def 	_snake_case	(  self					:Union[str, Any])					->			Dict:






								'''simple docstring'''






								self.enable_attention_slicing(_SCREAMING_SNAKE_CASE)




		@torch.no_grad()
		def 	_snake_case	(  self					:Union[str, Any]			,    _SCREAMING_SNAKE_CASE					:Union[str, List[str]]			,    _SCREAMING_SNAKE_CASE					:Union[torch.FloatTensor, PIL.Image.Image]			,    _SCREAMING_SNAKE_CASE					:Union[torch.FloatTensor, PIL.Image.Image]			,    _SCREAMING_SNAKE_CASE					:float = 0.8			,    _SCREAMING_SNAKE_CASE					:Optional[int] = 5_0			,    _SCREAMING_SNAKE_CASE					:Optional[float] = 7.5			,    _SCREAMING_SNAKE_CASE					:Optional[Union[str, List[str]]] = None			,    _SCREAMING_SNAKE_CASE					:Optional[int] = 1			,    _SCREAMING_SNAKE_CASE					:Optional[float] = 0.0			,    _SCREAMING_SNAKE_CASE					:Optional[torch.Generator] = None			,    _SCREAMING_SNAKE_CASE					:Optional[str] = "pil"			,    _SCREAMING_SNAKE_CASE					:bool = True			,    _SCREAMING_SNAKE_CASE					:Optional[Callable[[int, int, torch.FloatTensor], None]] = None			,    _SCREAMING_SNAKE_CASE					:int = 1			,    )					->			List[str]:






								'''simple docstring'''






								return StableDiffusionInpaintPipelineLegacy(**self.components)(
								    prompt=_SCREAMING_SNAKE_CASE			,    image=_SCREAMING_SNAKE_CASE			,    mask_image=_SCREAMING_SNAKE_CASE			,    strength=_SCREAMING_SNAKE_CASE			,    num_inference_steps=_SCREAMING_SNAKE_CASE			,    guidance_scale=_SCREAMING_SNAKE_CASE			,    negative_prompt=_SCREAMING_SNAKE_CASE			,    num_images_per_prompt=_SCREAMING_SNAKE_CASE			,    eta=_SCREAMING_SNAKE_CASE			,    generator=_SCREAMING_SNAKE_CASE			,    output_type=_SCREAMING_SNAKE_CASE			,    return_dict=_SCREAMING_SNAKE_CASE			,    callback=_SCREAMING_SNAKE_CASE			,    )




		@torch.no_grad()
		def 	_snake_case	(  self					:List[str]			,    _SCREAMING_SNAKE_CASE					:Union[str, List[str]]			,    _SCREAMING_SNAKE_CASE					:Union[torch.FloatTensor, PIL.Image.Image]			,    _SCREAMING_SNAKE_CASE					:float = 0.8			,    _SCREAMING_SNAKE_CASE					:Optional[int] = 5_0			,    _SCREAMING_SNAKE_CASE					:Optional[float] = 7.5			,    _SCREAMING_SNAKE_CASE					:Optional[Union[str, List[str]]] = None			,    _SCREAMING_SNAKE_CASE					:Optional[int] = 1			,    _SCREAMING_SNAKE_CASE					:Optional[float] = 0.0			,    _SCREAMING_SNAKE_CASE					:Optional[torch.Generator] = None			,    _SCREAMING_SNAKE_CASE					:Optional[str] = "pil"			,    _SCREAMING_SNAKE_CASE					:bool = True			,    _SCREAMING_SNAKE_CASE					:Optional[Callable[[int, int, torch.FloatTensor], None]] = None			,    _SCREAMING_SNAKE_CASE					:int = 1			,    **_SCREAMING_SNAKE_CASE					:int			,    )					->			Any:






								'''simple docstring'''






								return StableDiffusionImgaImgPipeline(**self.components)(
								    prompt=_SCREAMING_SNAKE_CASE			,    image=_SCREAMING_SNAKE_CASE			,    strength=_SCREAMING_SNAKE_CASE			,    num_inference_steps=_SCREAMING_SNAKE_CASE			,    guidance_scale=_SCREAMING_SNAKE_CASE			,    negative_prompt=_SCREAMING_SNAKE_CASE			,    num_images_per_prompt=_SCREAMING_SNAKE_CASE			,    eta=_SCREAMING_SNAKE_CASE			,    generator=_SCREAMING_SNAKE_CASE			,    output_type=_SCREAMING_SNAKE_CASE			,    return_dict=_SCREAMING_SNAKE_CASE			,    callback=_SCREAMING_SNAKE_CASE			,    callback_steps=_SCREAMING_SNAKE_CASE			,    )





		@torch.no_grad()
		def 	_snake_case	(  self					:Any			,    _SCREAMING_SNAKE_CASE					:Union[str, List[str]]			,    _SCREAMING_SNAKE_CASE					:int = 5_1_2			,    _SCREAMING_SNAKE_CASE					:int = 5_1_2			,    _SCREAMING_SNAKE_CASE					:int = 5_0			,    _SCREAMING_SNAKE_CASE					:float = 7.5			,    _SCREAMING_SNAKE_CASE					:Optional[Union[str, List[str]]] = None			,    _SCREAMING_SNAKE_CASE					:Optional[int] = 1			,    _SCREAMING_SNAKE_CASE					:float = 0.0			,    _SCREAMING_SNAKE_CASE					:Optional[torch.Generator] = None			,    _SCREAMING_SNAKE_CASE					:Optional[torch.FloatTensor] = None			,    _SCREAMING_SNAKE_CASE					:Optional[str] = "pil"			,    _SCREAMING_SNAKE_CASE					:bool = True			,    _SCREAMING_SNAKE_CASE					:Optional[Callable[[int, int, torch.FloatTensor], None]] = None			,    _SCREAMING_SNAKE_CASE					:int = 1			,    )					->			List[Any]:






								'''simple docstring'''






								return StableDiffusionPipeline(**self.components)(
								    prompt=_SCREAMING_SNAKE_CASE			,    height=_SCREAMING_SNAKE_CASE			,    width=_SCREAMING_SNAKE_CASE			,    num_inference_steps=_SCREAMING_SNAKE_CASE			,    guidance_scale=_SCREAMING_SNAKE_CASE			,    negative_prompt=_SCREAMING_SNAKE_CASE			,    num_images_per_prompt=_SCREAMING_SNAKE_CASE			,    eta=_SCREAMING_SNAKE_CASE			,    generator=_SCREAMING_SNAKE_CASE			,    latents=_SCREAMING_SNAKE_CASE			,    output_type=_SCREAMING_SNAKE_CASE			,    return_dict=_SCREAMING_SNAKE_CASE			,    callback=_SCREAMING_SNAKE_CASE			,    callback_steps=_SCREAMING_SNAKE_CASE			,    )




