


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE       :		Union[str, Any]         =				{"configuration_xlnet": ["XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLNetConfig"]}

try:
   if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   SCREAMING_SNAKE_CASE       :		Optional[Any]         =				["XLNetTokenizer"]

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   SCREAMING_SNAKE_CASE       :		List[str]         =				["XLNetTokenizerFast"]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   SCREAMING_SNAKE_CASE       :		Dict         =				[
       "XLNET_PRETRAINED_MODEL_ARCHIVE_LIST",
       "XLNetForMultipleChoice",
       "XLNetForQuestionAnswering",
       "XLNetForQuestionAnsweringSimple",
       "XLNetForSequenceClassification",
       "XLNetForTokenClassification",
       "XLNetLMHeadModel",
       "XLNetModel",
       "XLNetPreTrainedModel",
       "load_tf_weights_in_xlnet",
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   SCREAMING_SNAKE_CASE       :		str         =				[
       "TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST",
       "TFXLNetForMultipleChoice",
       "TFXLNetForQuestionAnsweringSimple",
       "TFXLNetForSequenceClassification",
       "TFXLNetForTokenClassification",
       "TFXLNetLMHeadModel",
       "TFXLNetMainLayer",
       "TFXLNetModel",
       "TFXLNetPreTrainedModel",
   ]


if TYPE_CHECKING:
   from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig

   try:
      if not is_sentencepiece_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_xlnet import XLNetTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_xlnet_fast import XLNetTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_xlnet import (
          XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
          XLNetForMultipleChoice,
          XLNetForQuestionAnswering,
          XLNetForQuestionAnsweringSimple,
          XLNetForSequenceClassification,
          XLNetForTokenClassification,
          XLNetLMHeadModel,
          XLNetModel,
          XLNetPreTrainedModel,
          load_tf_weights_in_xlnet,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_xlnet import (
          TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFXLNetForMultipleChoice,
          TFXLNetForQuestionAnsweringSimple,
          TFXLNetForSequenceClassification,
          TFXLNetForTokenClassification,
          TFXLNetLMHeadModel,
          TFXLNetMainLayer,
          TFXLNetModel,
          TFXLNetPreTrainedModel,
      )

else:
   import sys

   SCREAMING_SNAKE_CASE       :		str         =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






import numpy as np
import torch
import torch.nn as nn
from transformers import CLIPConfig, CLIPVisionModelWithProjection, PreTrainedModel

from ...utils import logging


SCREAMING_SNAKE_CASE       :		int         =				logging.get_logger(__name__)






class      UpperCamelCase					(		lowercase__     ):


   '''simple docstring'''







   lowercase					:	List[str]									=CLIPConfig

   lowercase					:	Tuple									=["""CLIPEncoderLayer"""]
   def __init__(     self   ,							UpperCamelCase_		):
        super().__init__(UpperCamelCase_		)

        lowercase_       :Union[str, Any]     =       CLIPVisionModelWithProjection(config.vision_config		)

        lowercase_       :str     =       nn.Linear(config.vision_config.projection_dim   ,							1		)
        lowercase_       :Optional[int]     =       nn.Linear(config.vision_config.projection_dim   ,							1		)




   @torch.no_grad()
   def 		UpperCamelCase  (     self   ,							UpperCamelCase_   ,							UpperCamelCase_   ,							UpperCamelCase_=0.5   ,							UpperCamelCase_=0.5		):
        lowercase_       :Optional[int]     =       self.vision_model(UpperCamelCase_		)[0]

        lowercase_       :Optional[int]     =       self.p_head(UpperCamelCase_		)
        lowercase_       :List[Any]     =       nsfw_detected.flatten()
        lowercase_       :List[str]     =       nsfw_detected > p_threshold
        lowercase_       :Optional[int]     =       nsfw_detected.tolist()

        if any(UpperCamelCase_		):
             logger.warning(
                 '''Potential NSFW content was detected in one or more images. A black image will be returned instead.'''
                 ''' Try again with a different prompt and/or seed.'''		)

        for idx, nsfw_detected_ in enumerate(UpperCamelCase_		):
             if nsfw_detected_:
                  lowercase_       :str     =       np.zeros(images[idx].shape		)

        lowercase_       :int     =       self.w_head(UpperCamelCase_		)
        lowercase_       :Union[str, Any]     =       watermark_detected.flatten()
        lowercase_       :int     =       watermark_detected > w_threshold
        lowercase_       :int     =       watermark_detected.tolist()

        if any(UpperCamelCase_		):
             logger.warning(
                 '''Potential watermarked content was detected in one or more images. A black image will be returned instead.'''
                 ''' Try again with a different prompt and/or seed.'''		)

        for idx, watermark_detected_ in enumerate(UpperCamelCase_		):
             if watermark_detected_:
                  lowercase_       :Dict     =       np.zeros(images[idx].shape		)

        return images, nsfw_detected, watermark_detected

