
import os
import re
import sys
import traceback
import warnings
from pathlib import Path
from typing import Dict, Optional, Union
from uuid import uuida

from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami
from huggingface_hub.file_download import REGEX_COMMIT_HASH
from huggingface_hub.utils import (
    EntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    is_jinja_available,
)
from packaging import version
from requests import HTTPError

from .. import __version__
from .constants import (
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    SAFETENSORS_WEIGHTS_NAME,
    WEIGHTS_NAME,
)
from .import_utils import (
    ENV_VARS_TRUE_VALUES,
    _flax_version,
    _jax_version,
    _onnxruntime_version,
    _torch_version,
    is_flax_available,
    is_onnx_available,
    is_torch_available,
)
from .logging import get_logger


lowercase__		:Any			  =   get_logger(__name__)


lowercase__		:Tuple			  =   Path(__file__).parent / "model_card_template.md"
lowercase__		:Optional[int]			  =   uuida().hex
lowercase__		:Union[str, Any]			  =   os.getenv("HF_HUB_OFFLINE", "").upper() in ENV_VARS_TRUE_VALUES
lowercase__		:Union[str, Any]			  =   os.getenv("DISABLE_TELEMETRY", "").upper() in ENV_VARS_TRUE_VALUES
lowercase__		:List[str]			  =   HUGGINGFACE_CO_RESOLVE_ENDPOINT + "/api/telemetry/"



def 	UpperCamelCase   (							lowerCAmelCase__ = None		):
					'''simple docstring'''
					lowercase						     =						f'diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}'
					if DISABLE_TELEMETRY or HF_HUB_OFFLINE:
										return ua + "; telemetry/off"
					if is_torch_available():
										ua += f'; torch/{_torch_version}'
					if is_flax_available():
										ua += f'; jax/{_jax_version}'
										ua += f'; flax/{_flax_version}'
					if is_onnx_available():
										ua += f'; onnxruntime/{_onnxruntime_version}'
					# CI will set this value to True
					if os.environ.get('''DIFFUSERS_IS_CI'''			,      ''''''		).upper() in ENV_VARS_TRUE_VALUES:
										ua += "; is_ci/true"
					if isinstance(lowerCAmelCase__			,      lowerCAmelCase__		):
										ua += "; " + "; ".join(f'{k}/{v}' for k, v in user_agent.items()		)
					elif isinstance(lowerCAmelCase__			,      lowerCAmelCase__		):
										ua += "; " + user_agent
					return ua



def 	UpperCamelCase   (							lowerCAmelCase__			,      lowerCAmelCase__ = None			,      lowerCAmelCase__ = None		):
					'''simple docstring'''
					if token is None:
										lowercase						     =						HfFolder.get_token()
					if organization is None:
										lowercase						     =						whoami(lowerCAmelCase__		)['''name''']
										return f'{username}/{model_id}'
					else:
										return f'{organization}/{model_id}'



def 	UpperCamelCase   (							lowerCAmelCase__			,      lowerCAmelCase__		):
					'''simple docstring'''
					if not is_jinja_available():
										raise ValueError(
										    '''Modelcard rendering is based on Jinja templates.'''
										    ''' Please make sure to have `jinja` installed before using `create_model_card`.'''
										    ''' To install it, please run `pip install Jinja2`.'''		)

					if hasattr(lowerCAmelCase__			,      '''local_rank'''		) and args.local_rank not in [-1, 0]:
										return

					lowercase						     =						args.hub_token if hasattr(lowerCAmelCase__			,      '''hub_token'''		) else None
					lowercase						     =						get_full_repo_name(lowerCAmelCase__			,      token=lowerCAmelCase__		)

					lowercase						     =						ModelCard.from_template(
					    card_data=ModelCardData(  # Card metadata object that will be converted to YAML block
					        language='''en'''			,      license='''apache-2.0'''			,      library_name='''diffusers'''			,      tags=[]			,      datasets=args.dataset_name			,      metrics=[]			,      )			,      template_path=lowerCAmelCase__			,      model_name=lowerCAmelCase__			,      repo_name=lowerCAmelCase__			,      dataset_name=args.dataset_name if hasattr(lowerCAmelCase__			,      '''dataset_name'''		) else None			,      learning_rate=args.learning_rate			,      train_batch_size=args.train_batch_size			,      eval_batch_size=args.eval_batch_size			,      gradient_accumulation_steps=(
					        args.gradient_accumulation_steps if hasattr(lowerCAmelCase__			,      '''gradient_accumulation_steps'''		) else None
					    )			,      adam_betaa=args.adam_betaa if hasattr(lowerCAmelCase__			,      '''adam_beta1'''		) else None			,      adam_betaa=args.adam_betaa if hasattr(lowerCAmelCase__			,      '''adam_beta2'''		) else None			,      adam_weight_decay=args.adam_weight_decay if hasattr(lowerCAmelCase__			,      '''adam_weight_decay'''		) else None			,      adam_epsilon=args.adam_epsilon if hasattr(lowerCAmelCase__			,      '''adam_epsilon'''		) else None			,      lr_scheduler=args.lr_scheduler if hasattr(lowerCAmelCase__			,      '''lr_scheduler'''		) else None			,      lr_warmup_steps=args.lr_warmup_steps if hasattr(lowerCAmelCase__			,      '''lr_warmup_steps'''		) else None			,      ema_inv_gamma=args.ema_inv_gamma if hasattr(lowerCAmelCase__			,      '''ema_inv_gamma'''		) else None			,      ema_power=args.ema_power if hasattr(lowerCAmelCase__			,      '''ema_power'''		) else None			,      ema_max_decay=args.ema_max_decay if hasattr(lowerCAmelCase__			,      '''ema_max_decay'''		) else None			,      mixed_precision=args.mixed_precision			,      )

					lowercase						     =						os.path.join(args.output_dir			,      '''README.md'''		)
					model_card.save(lowerCAmelCase__		)



def 	UpperCamelCase   (							lowerCAmelCase__			,      lowerCAmelCase__ = None		):
					'''simple docstring'''
					if resolved_file is None or commit_hash is not None:
										return commit_hash
					lowercase						     =						str(Path(lowerCAmelCase__		).as_posix()		)
					lowercase						     =						re.search(R'''snapshots/([^/]+)/'''			,      lowerCAmelCase__		)
					if search is None:
										return None
					lowercase						     =						search.groups()[0]
					return commit_hash if REGEX_COMMIT_HASH.match(lowerCAmelCase__		) else None


# Old default cache path, potentially to be migrated.
# This logic was more or less taken from `transformers`, with the following differences:
# - Diffusers doesn't use custom environment variables to specify the cache path.
# - There is no need to migrate the cache format, just move the files to the new location.
lowercase__		:int			  =   os.path.expanduser(
    os.getenv("HF_HOME", os.path.join(os.getenv("XDG_CACHE_HOME", "~/.cache"), "huggingface"))
)
lowercase__		:Any			  =   os.path.join(hf_cache_home, "diffusers")



def 	UpperCamelCase   (							lowerCAmelCase__ = None			,      lowerCAmelCase__ = None		):
					'''simple docstring'''
					if new_cache_dir is None:
										lowercase						     =						DIFFUSERS_CACHE
					if old_cache_dir is None:
										lowercase						     =						old_diffusers_cache

					lowercase						     =						Path(lowerCAmelCase__		).expanduser()
					lowercase						     =						Path(lowerCAmelCase__		).expanduser()
					for old_blob_path in old_cache_dir.glob('''**/blobs/*'''		):
										if old_blob_path.is_file() and not old_blob_path.is_symlink():
															lowercase						     =						new_cache_dir / old_blob_path.relative_to(lowerCAmelCase__		)
															new_blob_path.parent.mkdir(parents=lowerCAmelCase__			,      exist_ok=lowerCAmelCase__		)
															os.replace(lowerCAmelCase__			,      lowerCAmelCase__		)
															try:
																				os.symlink(lowerCAmelCase__			,      lowerCAmelCase__		)
															except OSError:
																				logger.warning(
																				    '''Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded.'''		)
					# At this point, old_cache_dir contains symlinks to the new cache (it can still be used).


lowercase__		:List[str]			  =   os.path.join(DIFFUSERS_CACHE, "version_diffusers_cache.txt")
if not os.path.isfile(cache_version_file):
							lowercase__		:List[str]			  =   0
else:
							with open(cache_version_file) as f:
														try:
																					lowercase__		:str			  =   int(f.read())
														except ValueError:
																					lowercase__		:str			  =   0

if cache_version < 1:
							lowercase__		:str			  =   os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0
							if old_cache_is_not_empty:
														logger.warning(
														    "The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your "
														    "existing cached models. This is a one-time operation, you can interrupt it or run it "
														    "later by calling `diffusers.utils.hub_utils.move_cache()`."
														)
														try:
																					move_cache()
														except Exception as e:
																					lowercase__		:str			  =   "\n".join(traceback.format_tb(e.__traceback__))
																					logger.error(
																					    F'There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease '
																					    "file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole "
																					    "message and we will do our best to help."
																					)

if cache_version < 1:
							try:
														os.makedirs(DIFFUSERS_CACHE, exist_ok=True)
														with open(cache_version_file, "w") as f:
																					f.write("1")
							except Exception:
														logger.warning(
														    F'There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure '
														    "the directory exists and can be written to."
														)



def 	UpperCamelCase   (							lowerCAmelCase__			,      lowerCAmelCase__ = None		):
					'''simple docstring'''
					if variant is not None:
										lowercase						     =						weights_name.split('''.'''		)
										lowercase						     =						splits[:-1] + [variant] + splits[-1:]
										lowercase						     =						'''.'''.join(lowerCAmelCase__		)

					return weights_name



def 	UpperCamelCase   (							lowerCAmelCase__			,      *,
    lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__=None			,      ):
					'''simple docstring'''
					lowercase						     =						str(lowerCAmelCase__		)
					if os.path.isfile(lowerCAmelCase__		):
										return pretrained_model_name_or_path
					elif os.path.isdir(lowerCAmelCase__		):
										if os.path.isfile(os.path.join(lowerCAmelCase__			,      lowerCAmelCase__		)		):
															# Load from a PyTorch checkpoint
															lowercase						     =						os.path.join(lowerCAmelCase__			,      lowerCAmelCase__		)
															return model_file
										elif subfolder is not None and os.path.isfile(
										    os.path.join(lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__		)		):
															lowercase						     =						os.path.join(lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__		)
															return model_file
										else:
															raise EnvironmentError(
															    f'Error no file named {weights_name} found in directory {pretrained_model_name_or_path}.'		)
					else:
										# 1. First check if deprecated way of loading from branches is used
										if (
										    revision in DEPRECATED_REVISION_ARGS
										    and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME)
										    and version.parse(version.parse(lowerCAmelCase__		).base_version		) >= version.parse('''0.20.0'''		)
										):
															try:
																				lowercase						     =						hf_hub_download(
																				    lowerCAmelCase__			,      filename=_add_variant(lowerCAmelCase__			,      lowerCAmelCase__		)			,      cache_dir=lowerCAmelCase__			,      force_download=lowerCAmelCase__			,      proxies=lowerCAmelCase__			,      resume_download=lowerCAmelCase__			,      local_files_only=lowerCAmelCase__			,      use_auth_token=lowerCAmelCase__			,      user_agent=lowerCAmelCase__			,      subfolder=lowerCAmelCase__			,      revision=revision or commit_hash			,      )
																				warnings.warn(
																				    f'Loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'` is deprecated. Loading instead from `revision=\'main\'` with `variant={revision}`. Loading model variants via `revision=\'{revision}\'` will be removed in diffusers v1. Please use `variant=\'{revision}\'` instead.'			,      lowerCAmelCase__			,      )
																				return model_file
															except:  # noqa: E722
																				warnings.warn(
																				    f'You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant=\'{revision}\'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(lowerCAmelCase__			,      lowerCAmelCase__		)} file in the \'main\' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title \'{pretrained_model_name_or_path} is missing {_add_variant(lowerCAmelCase__			,      lowerCAmelCase__		)}\' so that the correct variant file can be added.'			,      lowerCAmelCase__			,      )
										try:
															# 2. Load model file as usual
															lowercase						     =						hf_hub_download(
															    lowerCAmelCase__			,      filename=lowerCAmelCase__			,      cache_dir=lowerCAmelCase__			,      force_download=lowerCAmelCase__			,      proxies=lowerCAmelCase__			,      resume_download=lowerCAmelCase__			,      local_files_only=lowerCAmelCase__			,      use_auth_token=lowerCAmelCase__			,      user_agent=lowerCAmelCase__			,      subfolder=lowerCAmelCase__			,      revision=revision or commit_hash			,      )
															return model_file

										except RepositoryNotFoundError:
															raise EnvironmentError(
															    f'{pretrained_model_name_or_path} is not a local folder and is not a valid model identifier '
															    '''listed on \'https://huggingface.co/models\'\nIf this is a private repository, make sure to pass a '''
															    '''token having permission to this repo with `use_auth_token` or log in with `huggingface-cli '''
															    '''login`.'''		)
										except RevisionNotFoundError:
															raise EnvironmentError(
															    f'{revision} is not a valid git identifier (branch name, tag name or commit id) that exists for '
															    '''this model name. Check the model page at '''
															    f'\'https://huggingface.co/{pretrained_model_name_or_path}\' for available revisions.'		)
										except EntryNotFoundError:
															raise EnvironmentError(
															    f'{pretrained_model_name_or_path} does not appear to have a file named {weights_name}.'		)
										except HTTPError as err:
															raise EnvironmentError(
															    f'There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}'		)
										except ValueError:
															raise EnvironmentError(
															    f'We couldn\'t connect to \'{HUGGINGFACE_CO_RESOLVE_ENDPOINT}\' to load this model, couldn\'t find it'
															    f' in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a'
															    f' directory containing a file named {weights_name} or'
															    ''' \nCheckout your internet connection or see how to run the library in'''
															    ''' offline mode at \'https://huggingface.co/docs/diffusers/installation#offline-mode\'.'''		)
										except EnvironmentError:
															raise EnvironmentError(
															    f'Can\'t load the model for \'{pretrained_model_name_or_path}\'. If you were trying to load it from '
															    '''\'https://huggingface.co/models\', make sure you don\'t have a local directory with the same name. '''
															    f'Otherwise, make sure \'{pretrained_model_name_or_path}\' is the correct path to a directory '
															    f'containing a file named {weights_name}'		)






import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
							import torch

							from transformers import (
							    MODEL_FOR_PRETRAINING_MAPPING,
							    AlbertForMaskedLM,
							    AlbertForMultipleChoice,
							    AlbertForPreTraining,
							    AlbertForQuestionAnswering,
							    AlbertForSequenceClassification,
							    AlbertForTokenClassification,
							    AlbertModel,
							)
							from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST







class     lowercase		:




							def __init__(    self       ,A__       ,A__=1_3       ,A__=7       ,A__=True       ,A__=True       ,A__=True       ,A__=True       ,A__=9_9       ,A__=1_6       ,A__=3_6       ,A__=6       ,A__=6       ,A__=6       ,A__=3_7       ,A__="gelu"       ,A__=0.1       ,A__=0.1       ,A__=5_1_2       ,A__=1_6       ,A__=2       ,A__=0.02       ,A__=3       ,A__=4       ,A__=None       ,):
												lowercase						     =						parent
												lowercase						     =						batch_size
												lowercase						     =						seq_length
												lowercase						     =						is_training
												lowercase						     =						use_input_mask
												lowercase						     =						use_token_type_ids
												lowercase						     =						use_labels
												lowercase						     =						vocab_size
												lowercase						     =						embedding_size
												lowercase						     =						hidden_size
												lowercase						     =						num_hidden_layers
												lowercase						     =						num_hidden_groups
												lowercase						     =						num_attention_heads
												lowercase						     =						intermediate_size
												lowercase						     =						hidden_act
												lowercase						     =						hidden_dropout_prob
												lowercase						     =						attention_probs_dropout_prob
												lowercase						     =						max_position_embeddings
												lowercase						     =						type_vocab_size
												lowercase						     =						type_sequence_label_size
												lowercase						     =						initializer_range
												lowercase						     =						num_labels
												lowercase						     =						num_choices
												lowercase						     =						scope




							def 			A__				(    self):
												lowercase						     =						ids_tensor([self.batch_size, self.seq_length]       ,self.vocab_size)

												lowercase						     =						None
												if self.use_input_mask:
																	lowercase						     =						random_attention_mask([self.batch_size, self.seq_length])

												lowercase						     =						None
												if self.use_token_type_ids:
																	lowercase						     =						ids_tensor([self.batch_size, self.seq_length]       ,self.type_vocab_size)

												lowercase						     =						None
												lowercase						     =						None
												lowercase						     =						None
												if self.use_labels:
																	lowercase						     =						ids_tensor([self.batch_size]       ,self.type_sequence_label_size)
																	lowercase						     =						ids_tensor([self.batch_size, self.seq_length]       ,self.num_labels)
																	lowercase						     =						ids_tensor([self.batch_size]       ,self.num_choices)

												lowercase						     =						self.get_config()

												return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




							def 			A__				(    self):
												return AlbertConfig(
												    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       ,num_hidden_groups=self.num_hidden_groups       ,)




							def 			A__				(    self       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__):
												lowercase						     =						AlbertModel(config=A__)
												model.to(A__)
												model.eval()
												lowercase						     =						model(A__       ,attention_mask=A__       ,token_type_ids=A__)
												lowercase						     =						model(A__       ,token_type_ids=A__)
												lowercase						     =						model(A__)
												self.parent.assertEqual(result.last_hidden_state.shape       ,(self.batch_size, self.seq_length, self.hidden_size))
												self.parent.assertEqual(result.pooler_output.shape       ,(self.batch_size, self.hidden_size))




							def 			A__				(    self       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__):
												lowercase						     =						AlbertForPreTraining(config=A__)
												model.to(A__)
												model.eval()
												lowercase						     =						model(
												    A__       ,attention_mask=A__       ,token_type_ids=A__       ,labels=A__       ,sentence_order_label=A__       ,)
												self.parent.assertEqual(result.prediction_logits.shape       ,(self.batch_size, self.seq_length, self.vocab_size))
												self.parent.assertEqual(result.sop_logits.shape       ,(self.batch_size, config.num_labels))




							def 			A__				(    self       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__):
												lowercase						     =						AlbertForMaskedLM(config=A__)
												model.to(A__)
												model.eval()
												lowercase						     =						model(A__       ,attention_mask=A__       ,token_type_ids=A__       ,labels=A__)
												self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.seq_length, self.vocab_size))




							def 			A__				(    self       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__):
												lowercase						     =						AlbertForQuestionAnswering(config=A__)
												model.to(A__)
												model.eval()
												lowercase						     =						model(
												    A__       ,attention_mask=A__       ,token_type_ids=A__       ,start_positions=A__       ,end_positions=A__       ,)
												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 			A__				(    self       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__):
												lowercase						     =						self.num_labels
												lowercase						     =						AlbertForSequenceClassification(A__)
												model.to(A__)
												model.eval()
												lowercase						     =						model(A__       ,attention_mask=A__       ,token_type_ids=A__       ,labels=A__)
												self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.num_labels))




							def 			A__				(    self       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__):
												lowercase						     =						self.num_labels
												lowercase						     =						AlbertForTokenClassification(config=A__)
												model.to(A__)
												model.eval()
												lowercase						     =						model(A__       ,attention_mask=A__       ,token_type_ids=A__       ,labels=A__)
												self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.seq_length, self.num_labels))




							def 			A__				(    self       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__       ,A__):
												lowercase						     =						self.num_choices
												lowercase						     =						AlbertForMultipleChoice(config=A__)
												model.to(A__)
												model.eval()
												lowercase						     =						input_ids.unsqueeze(1).expand(-1       ,self.num_choices       ,-1).contiguous()
												lowercase						     =						token_type_ids.unsqueeze(1).expand(-1       ,self.num_choices       ,-1).contiguous()
												lowercase						     =						input_mask.unsqueeze(1).expand(-1       ,self.num_choices       ,-1).contiguous()
												lowercase						     =						model(
												    A__       ,attention_mask=A__       ,token_type_ids=A__       ,labels=A__       ,)
												self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.num_choices))





							def 			A__				(    self):
												lowercase						     =						self.prepare_config_and_inputs()
												(
												    (
												    lowercase
												)     ,						(
												    lowercase
												)     ,						(
												    lowercase
												)     ,						(
												    lowercase
												)     ,						(
												    lowercase
												)     ,						(
												    lowercase
												)     ,						(
												    lowercase
												)     ,						
												)						     =						config_and_inputs
												lowercase						     =						{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
												return config, inputs_dict







@require_torch
class     lowercase		( SCREAMING_SNAKE_CASE__	,  SCREAMING_SNAKE_CASE__	,  unittest.TestCase		):
							lowercase_	:	Union[str, Any]	 =(
							    (
							        AlbertModel,
							        AlbertForPreTraining,
							        AlbertForMaskedLM,
							        AlbertForMultipleChoice,
							        AlbertForSequenceClassification,
							        AlbertForTokenClassification,
							        AlbertForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							lowercase_	:	int	 =(
							    {
							        '''feature-extraction''': AlbertModel,
							        '''fill-mask''': AlbertForMaskedLM,
							        '''question-answering''': AlbertForQuestionAnswering,
							        '''text-classification''': AlbertForSequenceClassification,
							        '''token-classification''': AlbertForTokenClassification,
							        '''zero-shot''': AlbertForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							lowercase_	:	str	 =True




							def 			A__				(    self       ,A__       ,A__       ,A__=False):
												lowercase						     =						super()._prepare_for_class(A__       ,A__       ,return_labels=A__)

												if return_labels:
																	if model_class in get_values(A__):
																						lowercase						     =						torch.zeros(
																						    (self.model_tester.batch_size, self.model_tester.seq_length)       ,dtype=torch.long       ,device=A__)
																						lowercase						     =						torch.zeros(
																						    self.model_tester.batch_size       ,dtype=torch.long       ,device=A__)
												return inputs_dict




							def 			A__				(    self):
												lowercase						     =						AlbertModelTester(self)
												lowercase						     =						ConfigTester(self       ,config_class=A__       ,hidden_size=3_7)




							def 			A__				(    self):
												self.config_tester.run_common_tests()




							def 			A__				(    self):
												lowercase						     =						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*A__)




							def 			A__				(    self):
												lowercase						     =						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_pretraining(*A__)




							def 			A__				(    self):
												lowercase						     =						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*A__)




							def 			A__				(    self):
												lowercase						     =						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_multiple_choice(*A__)




							def 			A__				(    self):
												lowercase						     =						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*A__)




							def 			A__				(    self):
												lowercase						     =						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*A__)




							def 			A__				(    self):
												lowercase						     =						self.model_tester.prepare_config_and_inputs()
												for type in ["absolute", "relative_key", "relative_key_query"]:
																	lowercase						     =						type
																	self.model_tester.create_and_check_model(*A__)





							@slow
							def 			A__				(    self):
												for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase						     =						AlbertModel.from_pretrained(A__)
																	self.assertIsNotNone(A__)







@require_torch
class     lowercase		( unittest.TestCase		):




							@slow
							def 			A__				(    self):
												lowercase						     =						AlbertModel.from_pretrained('''albert-base-v2''')
												lowercase						     =						torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]])
												lowercase						     =						torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
												with torch.no_grad():
																	lowercase						     =						model(A__       ,attention_mask=A__)[0]
												lowercase						     =						torch.Size((1, 1_1, 7_6_8))
												self.assertEqual(output.shape       ,A__)
												lowercase						     =						torch.tensor(
												    [[[-0.6513, 1.5035, -0.2766], [-0.6515, 1.5046, -0.2780], [-0.6512, 1.5049, -0.2784]]])

												self.assertTrue(torch.allclose(output[:, 1:4, 1:4]       ,A__       ,atol=1E-4))




