





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

import numpy as np
import torch

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, logging, randn_tensor
from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin


__A       : List[Any]						    = logging.get_logger(__name__)  # pylint: disable=invalid-name







@dataclass
# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->EulerDiscrete
class     lowerCamelCase(	__snake_case  ):
     '''simple docstring'''


     __magic_name__        = 42
     __magic_name__        = None





def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE=0.999       ,    _SCREAMING_SNAKE_CASE="cosine"       ,    )       ->   str:




    """simple docstring"""




    if alpha_transform_type == "cosine":

        def alpha_bar_fn(_SCREAMING_SNAKE_CASE							):
            return math.cos((t + 0.008) / 1.008 * math.pi / 2							) ** 2

    elif alpha_transform_type == "exp":

        def alpha_bar_fn(_SCREAMING_SNAKE_CASE							):
            return math.exp(t * -12.0							)

    else:
        raise ValueError(F"Unsupported alpha_tranform_type: {alpha_transform_type}"							)

    _A    =       []
    for i in range(_SCREAMING_SNAKE_CASE							):
        _A    =       i / num_diffusion_timesteps
        _A    =       (i + 1) / num_diffusion_timesteps
        betas.append(min(1 - alpha_bar_fn(_SCREAMING_SNAKE_CASE							) / alpha_bar_fn(_SCREAMING_SNAKE_CASE							)       ,    _SCREAMING_SNAKE_CASE							)							)
    return torch.tensor(_SCREAMING_SNAKE_CASE       ,    dtype=torch.floataa							)







class     lowerCamelCase(	__snake_case ,   __snake_case  ):
     '''simple docstring'''


     __magic_name__        = [e.name for e in KarrasDiffusionSchedulers]
     __magic_name__        = 1




     @register_to_config
     def __init__(						self							,    snake_case_ = 1000							,    snake_case_ = 0.0001							,    snake_case_ = 0.02							,    snake_case_ = "linear"							,    snake_case_ = None							,    snake_case_ = "epsilon"							,    snake_case_ = "linear"							,    snake_case_ = False							,    snake_case_ = "linspace"							,    snake_case_ = 0							,    ):
         if trained_betas is not None:
             _A    =       torch.tensor(snake_case_							,    dtype=torch.floataa       )
         elif beta_schedule == "linear":
             _A    =       torch.linspace(snake_case_							,    snake_case_							,    snake_case_							,    dtype=torch.floataa       )
         elif beta_schedule == "scaled_linear":
             # this schedule is very specific to the latent diffusion model.
             _A    =       (
                 torch.linspace(beta_start**0.5							,    beta_end**0.5							,    snake_case_							,    dtype=torch.floataa       ) ** 2
             )
         elif beta_schedule == "squaredcos_cap_v2":
             # Glide cosine schedule
             _A    =       betas_for_alpha_bar(snake_case_       )
         else:
             raise NotImplementedError(F"{beta_schedule} does is not implemented for {self.__class__}"       )

         _A    =       1.0 - self.betas
         _A    =       torch.cumprod(self.alphas							,    dim=0       )

         _A    =       np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5       )
         _A    =       np.concatenate([sigmas[::-1], [0.0]]       ).astype(np.floataa       )
         _A    =       torch.from_numpy(snake_case_       )

         # setable values
         _A    =       None
         _A    =       np.linspace(0							,    num_train_timesteps - 1							,    snake_case_							,    dtype=snake_case_       )[::-1].copy()
         _A    =       torch.from_numpy(snake_case_       )
         _A    =       False
         _A    =       use_karras_sigmas




     @property
     def 					lowerCAmelCase__		(						self       ):
         # standard deviation of the initial noise distribution
         if self.config.timestep_spacing in ["linspace", "trailing"]:
             return self.sigmas.max()

         return (self.sigmas.max() ** 2 + 1) ** 0.5




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_       ):
         if isinstance(snake_case_							,    torch.Tensor       ):
             _A    =       timestep.to(self.timesteps.device       )
         _A    =       (self.timesteps == timestep).nonzero().item()
         _A    =       self.sigmas[step_index]

         _A    =       sample / ((sigma**2 + 1) ** 0.5)

         _A    =       True
         return sample




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_ = None       ):
         _A    =       num_inference_steps

         # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
         if self.config.timestep_spacing == "linspace":
             _A    =       np.linspace(0							,    self.config.num_train_timesteps - 1							,    snake_case_							,    dtype=snake_case_       )[
                 ::-1
             ].copy()
         elif self.config.timestep_spacing == "leading":
             _A    =       self.config.num_train_timesteps // self.num_inference_steps
             # creates integer timesteps by multiplying by ratio
             # casting to int to avoid issues when num_inference_step is power of 3
             _A    =       (np.arange(0							,    snake_case_       ) * step_ratio).round()[::-1].copy().astype(snake_case_       )
             timesteps += self.config.steps_offset
         elif self.config.timestep_spacing == "trailing":
             _A    =       self.config.num_train_timesteps / self.num_inference_steps
             # creates integer timesteps by multiplying by ratio
             # casting to int to avoid issues when num_inference_step is power of 3
             _A    =       (np.arange(self.config.num_train_timesteps							,    0							,    -step_ratio       )).round().copy().astype(snake_case_       )
             timesteps -= 1
         else:
             raise ValueError(
                 F"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'."       )

         _A    =       np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5       )
         _A    =       np.log(snake_case_       )

         if self.config.interpolation_type == "linear":
             _A    =       np.interp(snake_case_							,    np.arange(0							,    len(snake_case_       )       )							,    snake_case_       )
         elif self.config.interpolation_type == "log_linear":
             _A    =       torch.linspace(np.log(sigmas[-1]       )							,    np.log(sigmas[0]       )							,    num_inference_steps + 1       ).exp()
         else:
             raise ValueError(
                 F"{self.config.interpolation_type} is not implemented. Please specify interpolation_type to either"
                 ' \'linear\' or \'log_linear\''       )

         if self.use_karras_sigmas:
             _A    =       self._convert_to_karras(in_sigmas=snake_case_							,    num_inference_steps=self.num_inference_steps       )
             _A    =       np.array([self._sigma_to_t(snake_case_							,    snake_case_       ) for sigma in sigmas]       )

         _A    =       np.concatenate([sigmas, [0.0]]       ).astype(np.floataa       )
         _A    =       torch.from_numpy(snake_case_       ).to(device=snake_case_       )
         if str(snake_case_       ).startswith('mps'       ):
             # mps does not support float64
             _A    =       torch.from_numpy(snake_case_       ).to(snake_case_							,    dtype=torch.floataa       )
         else:
             _A    =       torch.from_numpy(snake_case_       ).to(device=snake_case_       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_       ):
         # get log sigma
         _A    =       np.log(snake_case_       )

         # get distribution
         _A    =       log_sigma - log_sigmas[:, np.newaxis]

         # get sigmas range
         _A    =       np.cumsum((dists >= 0)							,    axis=0       ).argmax(axis=0       ).clip(max=log_sigmas.shape[0] - 2       )
         _A    =       low_idx + 1

         _A    =       log_sigmas[low_idx]
         _A    =       log_sigmas[high_idx]

         # interpolate sigmas
         _A    =       (low - log_sigma) / (low - high)
         _A    =       np.clip(snake_case_							,    0							,    1       )

         # transform interpolation to time range
         _A    =       (1 - w) * low_idx + w * high_idx
         _A    =       t.reshape(sigma.shape       )
         return t




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_       ):
         _A    =       in_sigmas[-1].item()
         _A    =       in_sigmas[0].item()

         _A    =       7.0  # 7.0 is the value used in the paper
         _A    =       np.linspace(0							,    1							,    snake_case_       )
         _A    =       sigma_min ** (1 / rho)
         _A    =       sigma_max ** (1 / rho)
         _A    =       (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
         return sigmas




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_ = 0.0							,    snake_case_ = 0.0							,    snake_case_ = float('inf'       )							,    snake_case_ = 1.0							,    snake_case_ = None							,    snake_case_ = True							,    ):

         if (
             isinstance(snake_case_							,    snake_case_       )
             or isinstance(snake_case_							,    torch.IntTensor       )
             or isinstance(snake_case_							,    torch.LongTensor       )
         ):
             raise ValueError(
                 (
                     'Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to'
                     ' `EulerDiscreteScheduler.step()` is not supported. Make sure to pass'
                     ' one of the `scheduler.timesteps` as a timestep.'
                 )							,    )

         if not self.is_scale_input_called:
             logger.warning(
                 'The `scale_model_input` function should be called before `step` to ensure correct denoising. '
                 'See `StableDiffusionPipeline` for a usage example.'       )

         if isinstance(snake_case_							,    torch.Tensor       ):
             _A    =       timestep.to(self.timesteps.device       )

         _A    =       (self.timesteps == timestep).nonzero().item()
         _A    =       self.sigmas[step_index]

         _A    =       min(s_churn / (len(self.sigmas       ) - 1)							,    2**0.5 - 1       ) if s_tmin <= sigma <= s_tmax else 0.0

         _A    =       randn_tensor(
             model_output.shape							,    dtype=model_output.dtype							,    device=model_output.device							,    generator=snake_case_       )

         _A    =       noise * s_noise
         _A    =       sigma * (gamma + 1)

         if gamma > 0:
             _A    =       sample + eps * (sigma_hat**2 - sigma**2) ** 0.5

         # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
         # NOTE: "original_sample" should not be an expected prediction_type but is left in for
         # backwards compatibility
         if self.config.prediction_type == "original_sample" or self.config.prediction_type == "sample":
             _A    =       model_output
         elif self.config.prediction_type == "epsilon":
             _A    =       sample - sigma_hat * model_output
         elif self.config.prediction_type == "v_prediction":
             # * c_out + input * c_skip
             _A    =       model_output * (-sigma / (sigma**2 + 1) ** 0.5) + (sample / (sigma**2 + 1))
         else:
             raise ValueError(
                 F"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`"       )

         # 2. Convert to an ODE derivative
         _A    =       (sample - pred_original_sample) / sigma_hat

         _A    =       self.sigmas[step_index + 1] - sigma_hat

         _A    =       sample + derivative * dt

         if not return_dict:
             return (prev_sample,)

         return EulerDiscreteSchedulerOutput(prev_sample=snake_case_							,    pred_original_sample=snake_case_       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    ):
         # Make sure sigmas and timesteps have the same device and dtype as original_samples
         _A    =       self.sigmas.to(device=original_samples.device							,    dtype=original_samples.dtype       )
         if original_samples.device.type == "mps" and torch.is_floating_point(snake_case_       ):
             # mps does not support float64
             _A    =       self.timesteps.to(original_samples.device							,    dtype=torch.floataa       )
             _A    =       timesteps.to(original_samples.device							,    dtype=torch.floataa       )
         else:
             _A    =       self.timesteps.to(original_samples.device       )
             _A    =       timesteps.to(original_samples.device       )

         _A    =       [(schedule_timesteps == t).nonzero().item() for t in timesteps]

         _A    =       sigmas[step_indices].flatten()
         while len(sigma.shape       ) < len(original_samples.shape       ):
             _A    =       sigma.unsqueeze(-1       )

         _A    =       original_samples + noise * sigma
         return noisy_samples




     def __len__(						self       ):
         return self.config.num_train_timesteps












import unittest

from transformers import YosoConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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 (
     YosoForMaskedLM,
     YosoForMultipleChoice,
     YosoForQuestionAnswering,
     YosoForSequenceClassification,
     YosoForTokenClassification,
     YosoModel,
 )
 from transformers.models.yoso.modeling_yoso import YOSO_PRETRAINED_MODEL_ARCHIVE_LIST







class     lowerCamelCase:
     '''simple docstring'''


     def __init__(						self							,    snake_case_							,    snake_case_=13							,    snake_case_=7							,    snake_case_=True							,    snake_case_=True							,    snake_case_=True							,    snake_case_=True							,    snake_case_=99							,    snake_case_=32							,    snake_case_=5							,    snake_case_=4							,    snake_case_=37							,    snake_case_="gelu"							,    snake_case_=0.1							,    snake_case_=0.1							,    snake_case_=512							,    snake_case_=16							,    snake_case_=2							,    snake_case_=0.02							,    snake_case_=3							,    snake_case_=4							,    snake_case_=None							,    ):
         _A    =       parent
         _A    =       batch_size
         _A    =       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    =       num_labels
         _A    =       num_choices
         _A    =       scope




     def 					lowerCAmelCase__		(						self       ):
         _A    =       ids_tensor([self.batch_size, self.seq_length]							,    self.vocab_size       )

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

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

         _A    =       None
         _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.seq_length]							,    self.num_labels       )
             _A    =       ids_tensor([self.batch_size]							,    self.num_choices       )

         _A    =       self.get_config()

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




     def 					lowerCAmelCase__		(						self       ):
         return YosoConfig(
             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							,    is_decoder=snake_case_							,    initializer_range=self.initializer_range							,    )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.get_config()
         _A    =       300
         return config




     def 					lowerCAmelCase__		(						self       ):
         (
             (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), 
         )    =       self.prepare_config_and_inputs()

         _A    =       True
         _A    =       floats_tensor([self.batch_size, self.seq_length, self.hidden_size]       )
         _A    =       ids_tensor([self.batch_size, self.seq_length]							,    vocab_size=2       )

         return (
             config,
             input_ids,
             token_type_ids,
             input_mask,
             sequence_labels,
             token_labels,
             choice_labels,
             encoder_hidden_states,
             encoder_attention_mask,
         )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       YosoModel(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_       )
         _A    =       model(snake_case_							,    token_type_ids=snake_case_       )
         _A    =       model(snake_case_       )
         self.parent.assertEqual(result.last_hidden_state.shape							,    (self.batch_size, self.seq_length, self.hidden_size)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    ):
         _A    =       True
         _A    =       YosoModel(snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(
             snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    encoder_hidden_states=snake_case_							,    encoder_attention_mask=snake_case_							,    )
         _A    =       model(
             snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    encoder_hidden_states=snake_case_							,    )
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_       )
         self.parent.assertEqual(result.last_hidden_state.shape							,    (self.batch_size, self.seq_length, self.hidden_size)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       YosoForMaskedLM(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    labels=snake_case_       )
         self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.seq_length, self.vocab_size)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       YosoForQuestionAnswering(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(
             snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    start_positions=snake_case_							,    end_positions=snake_case_							,    )
         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 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       self.num_labels
         _A    =       YosoForSequenceClassification(snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    labels=snake_case_       )
         self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_labels)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       self.num_labels
         _A    =       YosoForTokenClassification(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    labels=snake_case_       )
         self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.seq_length, self.num_labels)       )




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




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







@require_torch
class     lowerCamelCase(	__snake_case ,   __snake_case ,   unittest.TestCase  ):
     '''simple docstring'''


     __magic_name__        = (
         (
             YosoModel,
             YosoForMaskedLM,
             YosoForMultipleChoice,
             YosoForQuestionAnswering,
             YosoForSequenceClassification,
             YosoForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     __magic_name__        = False
     __magic_name__        = False
     __magic_name__        = False

     __magic_name__        = ()
     __magic_name__        = (
         {
             'feature-extraction': YosoModel,
             'fill-mask': YosoForMaskedLM,
             'question-answering': YosoForQuestionAnswering,
             'text-classification': YosoForSequenceClassification,
             'token-classification': YosoForTokenClassification,
             'zero-shot': YosoForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoModelTester(self       )
         _A    =       ConfigTester(self							,    config_class=snake_case_							,    hidden_size=37       )




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




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _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(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*snake_case_       )




     @slow
     def 					lowerCAmelCase__		(						self       ):
         for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _A    =       YosoModel.from_pretrained(snake_case_       )
             self.assertIsNotNone(snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         return







@require_torch
class     lowerCamelCase(	unittest.TestCase  ):
     '''simple docstring'''


     @slow
     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoModel.from_pretrained('uw-madison/yoso-4096'       )
         _A    =       torch.tensor([[0, 1, 2, 3, 4, 5]]       )

         with torch.no_grad():
             _A    =       model(snake_case_       )[0]

         _A    =       torch.Size((1, 6, 768)       )
         self.assertEqual(output.shape							,    snake_case_       )

         _A    =       torch.tensor(
             [[[-0.0611, 0.1242, 0.0840], [0.0280, -0.0048, 0.1125], [0.0106, 0.0226, 0.0751]]]       )

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




     @slow
     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoForMaskedLM.from_pretrained('uw-madison/yoso-4096'       )
         _A    =       torch.tensor([[0, 1, 2, 3, 4, 5]]       )

         with torch.no_grad():
             _A    =       model(snake_case_       )[0]

         _A    =       5_0265

         _A    =       torch.Size((1, 6, vocab_size)       )
         self.assertEqual(output.shape							,    snake_case_       )

         _A    =       torch.tensor(
             [[[-2.1313, -3.7285, -2.2407], [-2.7047, -3.3314, -2.6408], [0.0629, -2.5166, -0.3356]]]       )

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




     @slow
     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoForMaskedLM.from_pretrained('uw-madison/yoso-4096'       )
         _A    =       torch.arange(4096       ).unsqueeze(0       )

         with torch.no_grad():
             _A    =       model(snake_case_       )[0]

         _A    =       5_0265

         _A    =       torch.Size((1, 4096, vocab_size)       )
         self.assertEqual(output.shape							,    snake_case_       )

         _A    =       torch.tensor(
             [[[-2.3914, -4.3742, -5.0956], [-4.0988, -4.2384, -7.0406], [-3.1427, -3.7192, -6.6800]]]       )

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





