




from typing import Optional, Union

import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin
class 			_UpperCamelCase      (				lowercase__	,       lowercase__		):
      @register_to_config
      def __init__(			self   :Optional[int] ,      lowerCamelCase   :List[Any] = 768 ,      )     ->			Any:
       super().__init__()

       UpperCAmelCase__							 =						nn.Parameter(torch.zeros(1 ,      lowerCamelCase      )      )
       UpperCAmelCase__							 =						nn.Parameter(torch.ones(1 ,      lowerCamelCase      )      )
      def 	UpperCAmelCase_						(			self   :Optional[int] ,      lowerCamelCase   :Tuple = None ,      lowerCamelCase   :Union[str, Any] = None ,      )     ->			List[Any]:
       UpperCAmelCase__							 =						nn.Parameter(self.mean.to(lowerCamelCase      ).to(lowerCamelCase      )      )
       UpperCAmelCase__							 =						nn.Parameter(self.std.to(lowerCamelCase      ).to(lowerCamelCase      )      )
       return self
      def 	UpperCAmelCase_						(			self   :Dict ,      lowerCamelCase   :str      )     ->			Union[str, Any]:
       UpperCAmelCase__							 =						(embeds - self.mean) * 1.0 / self.std
       return embeds







      def 	UpperCAmelCase_						(			self   :str ,      lowerCamelCase   :Optional[Any]      )     ->			str:
       UpperCAmelCase__							 =						(embeds * self.std) + self.mean
       return embeds












from ..utils import DummyObject, requires_backends
class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :List[Any] ,      *lowerCamelCase   :int ,      **lowerCamelCase   :List[Any]      )     ->			Dict:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Union[str, Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :List[str]      )     ->			int:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[int] ,      *lowerCamelCase   :List[str] ,      **lowerCamelCase   :List[Any]      )     ->			Dict:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Dict ,      *lowerCamelCase   :int ,      **lowerCamelCase   :str      )     ->			str:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[int] ,      *lowerCamelCase   :Tuple ,      **lowerCamelCase   :List[Any]      )     ->			Optional[int]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Dict ,      **lowerCamelCase   :Optional[int]      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :List[str] ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :Any      )     ->			Union[str, Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :str ,      **lowerCamelCase   :List[Any]      )     ->			Tuple:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :str ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :Dict      )     ->			int:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Union[str, Any] ,      *lowerCamelCase   :int ,      **lowerCamelCase   :Dict      )     ->			List[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :int ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :str      )     ->			Optional[int]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[str] ,      *lowerCamelCase   :Optional[int] ,      **lowerCamelCase   :Tuple      )     ->			Dict:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Union[str, Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :List[str]      )     ->			Union[str, Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :Optional[Any]      )     ->			Optional[int]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :Dict ,      **lowerCamelCase   :Optional[int]      )     ->			List[str]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Tuple ,      *lowerCamelCase   :str ,      **lowerCamelCase   :List[str]      )     ->			List[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Any ,      *lowerCamelCase   :List[str] ,      **lowerCamelCase   :Any      )     ->			int:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :Optional[Any]      )     ->			Tuple:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Any ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :List[str]      )     ->			List[str]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Optional[int] ,      **lowerCamelCase   :Dict      )     ->			Union[str, Any]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :int ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :str      )     ->			str:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :str ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :Union[str, Any]      )     ->			Optional[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :List[str]      )     ->			int:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :Union[str, Any]      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Dict ,      *lowerCamelCase   :Dict ,      **lowerCamelCase   :int      )     ->			List[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Tuple ,      *lowerCamelCase   :Optional[Any] ,      **lowerCamelCase   :Optional[int]      )     ->			Dict:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :Any ,      *lowerCamelCase   :Optional[int] ,      **lowerCamelCase   :List[str]      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :List[Any] ,      *lowerCamelCase   :int ,      **lowerCamelCase   :Optional[Any]      )     ->			List[str]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :int ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :List[Any]      )     ->			Any:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :str ,      *lowerCamelCase   :Optional[int] ,      **lowerCamelCase   :str      )     ->			List[str]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :List[Any] ,      *lowerCamelCase   :str ,      **lowerCamelCase   :int      )     ->			List[Any]:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[str] ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :Any      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :Optional[Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :Tuple      )     ->			int:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :Any ,      *lowerCamelCase   :List[Any] ,      **lowerCamelCase   :Tuple      )     ->			Dict:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :List[Any] ,      *lowerCamelCase   :int ,      **lowerCamelCase   :Union[str, Any]      )     ->			List[Any]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :str ,      *lowerCamelCase   :int ,      **lowerCamelCase   :List[str]      )     ->			List[str]:
       requires_backends(cls ,      ["flax"]      )



class 			_UpperCamelCase      (				metaclass=lowerCAmelCase		):
      UpperCAmelCase_        =		["""flax"""]
      def __init__(			self   :int ,      *lowerCamelCase   :Dict ,      **lowerCamelCase   :Optional[int]      )     ->			str:
       requires_backends(self ,      ["flax"]      )
      @classmethod
      def 	UpperCAmelCase_						(			cls   :Union[str, Any] ,      *lowerCamelCase   :Any ,      **lowerCamelCase   :Union[str, Any]      )     ->			Optional[int]:
       requires_backends(cls ,      ["flax"]      )







      @classmethod
      def 	UpperCAmelCase_						(			cls   :int ,      *lowerCamelCase   :Union[str, Any] ,      **lowerCamelCase   :Any      )     ->			Optional[Any]:
       requires_backends(cls ,      ["flax"]      )





