




"""simple docstring"""






import warnings

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase__			=		logging.get_logger(__name__)

lowercase__			=		{
    '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/config.json''',
    '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/config.json''',
}






class lowerCAmelCase__      (	_a		):






			'''simple docstring'''



			lowerCamelCase__ =     '''xlnet'''
			lowerCamelCase__ =     ['''mems''']
			lowerCamelCase__ =     {
			    '''n_token''': '''vocab_size''',  # Backward compatibility
			    '''hidden_size''': '''d_model''',
			    '''num_attention_heads''': '''n_head''',
			    '''num_hidden_layers''': '''n_layer''',
			}
			def __init__(    self    , lowercase=32000    , lowercase=1024    , lowercase=24    , lowercase=16    , lowercase=4096    , lowercase="gelu"    , lowercase=True    , lowercase="bi"    , lowercase=0.02    , lowercase=1E-12    , lowercase=0.1    , lowercase=512    , lowercase=None    , lowercase=True    , lowercase=False    , lowercase=False    , lowercase=-1    , lowercase=False    , lowercase="last"    , lowercase=True    , lowercase="tanh"    , lowercase=0.1    , lowercase=5    , lowercase=5    , lowercase=5    , lowercase=1    , lowercase=2    , **lowercase    , ):
							_lowerCamelCase	:     Optional[int]       =       vocab_size
							_lowerCamelCase	:     int       =       d_model
							_lowerCamelCase	:     Any       =       n_layer
							_lowerCamelCase	:     Optional[Any]       =       n_head
							if d_model % n_head != 0:
											raise ValueError(F'''\'d_model % n_head\' ({d_model % n_head}) should be equal to 0'''    )
							if "d_head" in kwargs:
											if kwargs["d_head"] != d_model // n_head:
															raise ValueError(
															    F'''`d_head` ({kwargs['d_head']}) should be equal to `d_model // n_head` ({d_model // n_head})'''    )
							_lowerCamelCase	:     Dict       =       d_model // n_head
							_lowerCamelCase	:     List[Any]       =       ff_activation
							_lowerCamelCase	:     Optional[Any]       =       d_inner
							_lowerCamelCase	:     Optional[Any]       =       untie_r
							_lowerCamelCase	:     List[str]       =       attn_type

							_lowerCamelCase	:     List[str]       =       initializer_range
							_lowerCamelCase	:     List[str]       =       layer_norm_eps

							_lowerCamelCase	:     str       =       dropout
							_lowerCamelCase	:     List[str]       =       mem_len
							_lowerCamelCase	:     str       =       reuse_len
							_lowerCamelCase	:     List[str]       =       bi_data
							_lowerCamelCase	:     Optional[int]       =       clamp_len
							_lowerCamelCase	:     Tuple       =       same_length

							_lowerCamelCase	:     Tuple       =       summary_type
							_lowerCamelCase	:     Union[str, Any]       =       summary_use_proj
							_lowerCamelCase	:     Dict       =       summary_activation
							_lowerCamelCase	:     List[str]       =       summary_last_dropout
							_lowerCamelCase	:     str       =       start_n_top
							_lowerCamelCase	:     List[str]       =       end_n_top

							_lowerCamelCase	:     Optional[int]       =       bos_token_id
							_lowerCamelCase	:     Union[str, Any]       =       pad_token_id
							_lowerCamelCase	:     Dict       =       eos_token_id

							if "use_cache" in kwargs:
											warnings.warn(
											    'The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`'
											    ' instead.'    , __UpperCamelCase    , )
											_lowerCamelCase	:     List[Any]       =       kwargs['use_cache']

							_lowerCamelCase	:     str       =       use_mems_eval
							_lowerCamelCase	:     Union[str, Any]       =       use_mems_train
							super().__init__(pad_token_id=__UpperCamelCase    , bos_token_id=__UpperCamelCase    , eos_token_id=__UpperCamelCase    , **__UpperCamelCase    )
			@property
			def    A_       (    self    ):
							logger.info(F'''The model {self.model_type} is one of the few models that has no sequence length limit.'''    )
							return -1






			@max_position_embeddings.setter
			def    A_       (    self    , lowercase    ):
							# Message copied from Transformer-XL documentation
							raise NotImplementedError(
							    F'''The model {self.model_type} is one of the few models that has no sequence length limit.'''    )

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

import numpy as np
import PIL
from PIL import Image

from ...utils import (
    BaseOutput,
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_onnx_available,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)



@dataclass
class    a_ (			_a    ):
			a	:			Union[List[PIL.Image.Image], np.ndarray]
			a	:			Optional[List[bool]]


try:
		if not (is_transformers_available() and is_torch_available()):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
		from .pipeline_cycle_diffusion import CycleDiffusionPipeline
		from .pipeline_stable_diffusion import StableDiffusionPipeline
		from .pipeline_stable_diffusion_attend_and_excite import StableDiffusionAttendAndExcitePipeline
		from .pipeline_stable_diffusion_imgaimg import StableDiffusionImgaImgPipeline
		from .pipeline_stable_diffusion_inpaint import StableDiffusionInpaintPipeline
		from .pipeline_stable_diffusion_inpaint_legacy import StableDiffusionInpaintPipelineLegacy
		from .pipeline_stable_diffusion_instruct_pixapix import StableDiffusionInstructPixaPixPipeline
		from .pipeline_stable_diffusion_latent_upscale import StableDiffusionLatentUpscalePipeline
		from .pipeline_stable_diffusion_ldmad import StableDiffusionLDMaDPipeline
		from .pipeline_stable_diffusion_model_editing import StableDiffusionModelEditingPipeline
		from .pipeline_stable_diffusion_panorama import StableDiffusionPanoramaPipeline
		from .pipeline_stable_diffusion_paradigms import StableDiffusionParadigmsPipeline
		from .pipeline_stable_diffusion_sag import StableDiffusionSAGPipeline
		from .pipeline_stable_diffusion_upscale import StableDiffusionUpscalePipeline
		from .pipeline_stable_unclip import StableUnCLIPPipeline
		from .pipeline_stable_unclip_imgaimg import StableUnCLIPImgaImgPipeline
		from .safety_checker import StableDiffusionSafetyChecker
		from .stable_unclip_image_normalizer import StableUnCLIPImageNormalizer

try:
		if not (is_transformers_available() and is_torch_available() and is_transformers_version('''>=''', '''4.25.0''')):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_objects import StableDiffusionImageVariationPipeline
else:
		from .pipeline_stable_diffusion_image_variation import StableDiffusionImageVariationPipeline


try:
		if not (is_transformers_available() and is_torch_available() and is_transformers_version('''>=''', '''4.26.0''')):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_objects import (
		    StableDiffusionDepthaImgPipeline,
		    StableDiffusionDiffEditPipeline,
		    StableDiffusionPixaPixZeroPipeline,
		)
else:
		from .pipeline_stable_diffusion_depthaimg import StableDiffusionDepthaImgPipeline
		from .pipeline_stable_diffusion_diffedit import StableDiffusionDiffEditPipeline
		from .pipeline_stable_diffusion_pixapix_zero import StableDiffusionPixaPixZeroPipeline


try:
		if not (
		    is_torch_available()
		    and is_transformers_available()
		    and is_k_diffusion_available()
		    and is_k_diffusion_version('''>=''', '''0.0.12''')
		):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
		from .pipeline_stable_diffusion_k_diffusion import StableDiffusionKDiffusionPipeline

try:
		if not (is_transformers_available() and is_onnx_available()):
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		from ...utils.dummy_onnx_objects import *  # noqa F403
else:
		from .pipeline_onnx_stable_diffusion import OnnxStableDiffusionPipeline, StableDiffusionOnnxPipeline
		from .pipeline_onnx_stable_diffusion_imgaimg import OnnxStableDiffusionImgaImgPipeline
		from .pipeline_onnx_stable_diffusion_inpaint import OnnxStableDiffusionInpaintPipeline
		from .pipeline_onnx_stable_diffusion_inpaint_legacy import OnnxStableDiffusionInpaintPipelineLegacy
		from .pipeline_onnx_stable_diffusion_upscale import OnnxStableDiffusionUpscalePipeline

if is_transformers_available() and is_flax_available():
		import flax



		@flax.struct.dataclass
		class    a_ (			_a    ):
					a	:			np.ndarray
					a	:			List[bool]







		from ...schedulers.scheduling_pndm_flax import PNDMSchedulerState
		from .pipeline_flax_stable_diffusion import FlaxStableDiffusionPipeline
		from .pipeline_flax_stable_diffusion_imgaimg import FlaxStableDiffusionImgaImgPipeline
		from .pipeline_flax_stable_diffusion_inpaint import FlaxStableDiffusionInpaintPipeline
		from .safety_checker_flax import FlaxStableDiffusionSafetyChecker