



from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


UpperCAmelCase							 =					logging.get_logger(__name__)

# General docstring
UpperCAmelCase							 =					"""RegNetConfig"""

# Base docstring
UpperCAmelCase							 =					"""facebook/regnet-y-040"""
UpperCAmelCase							 =					[1, 1_088, 7, 7]

# Image classification docstring
UpperCAmelCase							 =					"""facebook/regnet-y-040"""
UpperCAmelCase							 =					"""tabby, tabby cat"""

UpperCAmelCase							 =					[
    """facebook/regnet-y-040""",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]

class  __snake_case      (   tf.keras.layers.Layer):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_ = 3  ,  a_ = 1  ,  a_ = 1  ,  a_ = "relu"  ,  **a_  ,  ):
											super().__init__(**_lowerCAmelCase		)
											# The padding and conv has been verified in
											# https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
											a__				      =		tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2		)
											a__				      =		tf.keras.layers.ConvaD(
											    filters=_lowerCAmelCase  ,  kernel_size=_lowerCAmelCase  ,  strides=_lowerCAmelCase  ,  padding="""VALID"""  ,  groups=_lowerCAmelCase  ,  use_bias=_lowerCAmelCase  ,  name="""convolution"""  ,  )
											a__				      =		tf.keras.layers.BatchNormalization(epsilon=1E-5  ,  momentum=0.9  ,  name="""normalization"""		)
											a__				      =		ACTaFN[activation] if activation is not None else tf.identity







							def _a      (							self  ,  a_		):
											a__				      =		self.convolution(self.padding(_lowerCAmelCase		)		)
											a__				      =		self.normalization(_lowerCAmelCase		)
											a__				      =		self.activation(_lowerCAmelCase		)
											return hidden_state




class  __snake_case      (   tf.keras.layers.Layer):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  **a_		):
											super().__init__(**_lowerCAmelCase		)
											a__				      =		config.num_channels
											a__				      =		TFRegNetConvLayer(
											    out_channels=config.embedding_size  ,  kernel_size=3  ,  stride=2  ,  activation=config.hidden_act  ,  name="""embedder"""  ,  )







							def _a      (							self  ,  a_		):
											a__				      =		shape_list(_lowerCAmelCase		)[1]
											if tf.executing_eagerly() and num_channels != self.num_channels:
															raise ValueError(
															    """Make sure that the channel dimension of the pixel values match with the one set in the configuration."""		)

											# When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
											# So change the input format from `NCHW` to `NHWC`.
											# shape = (batch_size, in_height, in_width, in_channels=num_channels)
											a__				      =		tf.transpose(_lowerCAmelCase  ,  perm=(0, 2, 3, 1)		)
											a__				      =		self.embedder(_lowerCAmelCase		)
											return hidden_state




class  __snake_case      (   tf.keras.layers.Layer):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_ = 2  ,  **a_		):
											super().__init__(**_lowerCAmelCase		)
											a__				      =		tf.keras.layers.ConvaD(
											    filters=_lowerCAmelCase  ,  kernel_size=1  ,  strides=_lowerCAmelCase  ,  use_bias=_lowerCAmelCase  ,  name="""convolution"""		)
											a__				      =		tf.keras.layers.BatchNormalization(epsilon=1E-5  ,  momentum=0.9  ,  name="""normalization"""		)







							def _a      (							self  ,  a_  ,  a_ = False		):
											return self.normalization(self.convolution(_lowerCAmelCase		)  ,  training=_lowerCAmelCase		)




class  __snake_case      (   tf.keras.layers.Layer):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_  ,  **a_		):
											super().__init__(**_lowerCAmelCase		)
											a__				      =		tf.keras.layers.GlobalAveragePoolingaD(keepdims=_lowerCAmelCase  ,  name="""pooler"""		)
											a__				      =		[
											    tf.keras.layers.ConvaD(filters=_lowerCAmelCase  ,  kernel_size=1  ,  activation="""relu"""  ,  name="""attention.0"""		),
											    tf.keras.layers.ConvaD(filters=_lowerCAmelCase  ,  kernel_size=1  ,  activation="""sigmoid"""  ,  name="""attention.2"""		),
											]







							def _a      (							self  ,  a_		):
											a__				      =		self.pooler(_lowerCAmelCase		)
											for layer_module in self.attention:
															a__				      =		layer_module(_lowerCAmelCase		)
											a__				      =		hidden_state * pooled
											return hidden_state




class  __snake_case      (   tf.keras.layers.Layer):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_  ,  a_  ,  a_ = 1  ,  **a_		):
											super().__init__(**_lowerCAmelCase		)
											a__				      =		in_channels != out_channels or stride != 1
											a__				      =		max(1  ,  out_channels // config.groups_width		)
											a__				      =		(
											    TFRegNetShortCut(_lowerCAmelCase  ,  stride=_lowerCAmelCase  ,  name="""shortcut"""		)
											    if should_apply_shortcut
											    else tf.keras.layers.Activation("""linear"""  ,  name="""shortcut"""		)
											)
											# `self.layers` instead of `self.layer` because that is a reserved argument.
											a__				      =		[
											    TFRegNetConvLayer(_lowerCAmelCase  ,  kernel_size=1  ,  activation=config.hidden_act  ,  name="""layer.0"""		),
											    TFRegNetConvLayer(
											        _lowerCAmelCase  ,  stride=_lowerCAmelCase  ,  groups=_lowerCAmelCase  ,  activation=config.hidden_act  ,  name="""layer.1"""		),
											    TFRegNetConvLayer(_lowerCAmelCase  ,  kernel_size=1  ,  activation=_lowerCAmelCase  ,  name="""layer.2"""		),
											]
											a__				      =		ACTaFN[config.hidden_act]







							def _a      (							self  ,  a_		):
											a__				      =		hidden_state
											for layer_module in self.layers:
															a__				      =		layer_module(_lowerCAmelCase		)
											a__				      =		self.shortcut(_lowerCAmelCase		)
											hidden_state += residual
											a__				      =		self.activation(_lowerCAmelCase		)
											return hidden_state




class  __snake_case      (   tf.keras.layers.Layer):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_  ,  a_  ,  a_ = 1  ,  **a_		):
											super().__init__(**_lowerCAmelCase		)
											a__				      =		in_channels != out_channels or stride != 1
											a__				      =		max(1  ,  out_channels // config.groups_width		)
											a__				      =		(
											    TFRegNetShortCut(_lowerCAmelCase  ,  stride=_lowerCAmelCase  ,  name="""shortcut"""		)
											    if should_apply_shortcut
											    else tf.keras.layers.Activation("""linear"""  ,  name="""shortcut"""		)
											)
											a__				      =		[
											    TFRegNetConvLayer(_lowerCAmelCase  ,  kernel_size=1  ,  activation=config.hidden_act  ,  name="""layer.0"""		),
											    TFRegNetConvLayer(
											        _lowerCAmelCase  ,  stride=_lowerCAmelCase  ,  groups=_lowerCAmelCase  ,  activation=config.hidden_act  ,  name="""layer.1"""		),
											    TFRegNetSELayer(_lowerCAmelCase  ,  reduced_channels=int(round(in_channels / 4		)		)  ,  name="""layer.2"""		),
											    TFRegNetConvLayer(_lowerCAmelCase  ,  kernel_size=1  ,  activation=_lowerCAmelCase  ,  name="""layer.3"""		),
											]
											a__				      =		ACTaFN[config.hidden_act]







							def _a      (							self  ,  a_		):
											a__				      =		hidden_state
											for layer_module in self.layers:
															a__				      =		layer_module(_lowerCAmelCase		)
											a__				      =		self.shortcut(_lowerCAmelCase		)
											hidden_state += residual
											a__				      =		self.activation(_lowerCAmelCase		)
											return hidden_state




class  __snake_case      (   tf.keras.layers.Layer):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  a_  ,  a_  ,  a_ = 2  ,  a_ = 2  ,  **a_		):
											super().__init__(**_lowerCAmelCase		)

											a__				      =		TFRegNetXLayer if config.layer_type == """x""" else TFRegNetYLayer
											a__				      =		[
											    # downsampling is done in the first layer with stride of 2
											    layer(_lowerCAmelCase  ,  _lowerCAmelCase  ,  _lowerCAmelCase  ,  stride=_lowerCAmelCase  ,  name="""layers.0"""		),
											    *[layer(_lowerCAmelCase  ,  _lowerCAmelCase  ,  _lowerCAmelCase  ,  name=F'''layers.{i+1}'''		) for i in range(depth - 1		)],
											]







							def _a      (							self  ,  a_		):







											for layer_module in self.layers:
															a__				      =		layer_module(_lowerCAmelCase		)
											return hidden_state




class  __snake_case      (   tf.keras.layers.Layer):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  **a_		):
											super().__init__(**_lowerCAmelCase		)
											a__				      =		[]
											# based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
											self.stages.append(
											    TFRegNetStage(
											        _lowerCAmelCase  ,  config.embedding_size  ,  config.hidden_sizes[0]  ,  stride=2 if config.downsample_in_first_stage else 1  ,  depth=config.depths[0]  ,  name="""stages.0"""  ,  )		)
											a__				      =		zip(config.hidden_sizes  ,  config.hidden_sizes[1:]		)
											for i, ((in_channels, out_channels), depth) in enumerate(zip(_lowerCAmelCase  ,  config.depths[1:]		)		):
															self.stages.append(TFRegNetStage(_lowerCAmelCase  ,  _lowerCAmelCase  ,  _lowerCAmelCase  ,  depth=_lowerCAmelCase  ,  name=F'''stages.{i+1}'''		)		)







							def _a      (							self  ,  a_  ,  a_ = False  ,  a_ = True		):
											a__				      =		() if output_hidden_states else None

											for stage_module in self.stages:
															if output_hidden_states:
																			a__				      =		hidden_states + (hidden_state,)

															a__				      =		stage_module(_lowerCAmelCase		)

											if output_hidden_states:
															a__				      =		hidden_states + (hidden_state,)

											if not return_dict:
															return tuple(v for v in [hidden_state, hidden_states] if v is not None		)

											return TFBaseModelOutputWithNoAttention(last_hidden_state=_lowerCAmelCase  ,  hidden_states=_lowerCAmelCase		)




@keras_serializable
class  __snake_case      (   tf.keras.layers.Layer):







							'''simple docstring'''






							UpperCamelCase__				:      Dict         =					RegNetConfig


							def __init__(							self  ,  a_  ,  **a_		):
											super().__init__(**_lowerCAmelCase		)
											a__				      =		config
											a__				      =		TFRegNetEmbeddings(_lowerCAmelCase  ,  name="""embedder"""		)
											a__				      =		TFRegNetEncoder(_lowerCAmelCase  ,  name="""encoder"""		)
											a__				      =		tf.keras.layers.GlobalAveragePoolingaD(keepdims=_lowerCAmelCase  ,  name="""pooler"""		)







							@unpack_inputs
							def _a      (							self  ,  a_  ,  a_ = None  ,  a_ = None  ,  a_ = False  ,  ):
											a__				      =		(
											    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
											)
											a__				      =		return_dict if return_dict is not None else self.config.use_return_dict

											a__				      =		self.embedder(_lowerCAmelCase  ,  training=_lowerCAmelCase		)

											a__				      =		self.encoder(
											    _lowerCAmelCase  ,  output_hidden_states=_lowerCAmelCase  ,  return_dict=_lowerCAmelCase  ,  training=_lowerCAmelCase		)

											a__				      =		encoder_outputs[0]
											a__				      =		self.pooler(_lowerCAmelCase		)

											# Change to NCHW output format have uniformity in the modules
											a__				      =		tf.transpose(_lowerCAmelCase  ,  perm=(0, 3, 1, 2)		)
											a__				      =		tf.transpose(_lowerCAmelCase  ,  perm=(0, 3, 1, 2)		)

											# Change the other hidden state outputs to NCHW as well
											if output_hidden_states:
															a__				      =		tuple([tf.transpose(_lowerCAmelCase  ,  perm=(0, 3, 1, 2)		) for h in encoder_outputs[1]]		)

											if not return_dict:
															return (last_hidden_state, pooled_output) + encoder_outputs[1:]

											return TFBaseModelOutputWithPoolingAndNoAttention(
											    last_hidden_state=_lowerCAmelCase  ,  pooler_output=_lowerCAmelCase  ,  hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states  ,  )




class  __snake_case      (   _lowerCAmelCase):







							'''simple docstring'''






							UpperCamelCase__				:      Optional[int]         =					RegNetConfig
							UpperCamelCase__				:      Optional[Any]         =					'regnet'
							UpperCamelCase__				:      Dict         =					'pixel_values'


							@property
							def _a      (							self		):
											return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)  ,  dtype=tf.floataa		)}




UpperCAmelCase							 =					r"""
    Parameters:
    This model is a Tensorflow
    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a
    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and
    behavior.
        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
"""

UpperCAmelCase							 =					r"""
    Args:
        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConveNextImageProcessor.__call__`] for details.
        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""

@add_start_docstrings(
    """The bare RegNet model outputting raw features without any specific head on top."""			,_lowerCAmelCase			,)
class  __snake_case      (   _lowerCAmelCase):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  *a_  ,  **a_		):
											super().__init__(_lowerCAmelCase  ,  *_lowerCAmelCase  ,  **_lowerCAmelCase		)
											a__				      =		TFRegNetMainLayer(_lowerCAmelCase  ,  name="""regnet"""		)







							@unpack_inputs
							@add_start_docstrings_to_model_forward(_lowerCAmelCase		)
							@add_code_sample_docstrings(
							    checkpoint=_CHECKPOINT_FOR_DOC  ,  output_type=_lowerCAmelCase  ,  config_class=_CONFIG_FOR_DOC  ,  modality="""vision"""  ,  expected_output=_EXPECTED_OUTPUT_SHAPE  ,  )
							def _a      (							self  ,  a_  ,  a_ = None  ,  a_ = None  ,  a_=False  ,  ):
											a__				      =		(
											    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
											)
											a__				      =		return_dict if return_dict is not None else self.config.use_return_dict

											a__				      =		self.regnet(
											    pixel_values=_lowerCAmelCase  ,  output_hidden_states=_lowerCAmelCase  ,  return_dict=_lowerCAmelCase  ,  training=_lowerCAmelCase  ,  )
											if not return_dict:
															return (outputs[0],) + outputs[1:]

											return TFBaseModelOutputWithPoolingAndNoAttention(
											    last_hidden_state=outputs.last_hidden_state  ,  pooler_output=outputs.pooler_output  ,  hidden_states=outputs.hidden_states  ,  )




@add_start_docstrings(
    """\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    """			,_lowerCAmelCase			,)
class  __snake_case      (   _lowerCAmelCase			,_lowerCAmelCase):







							'''simple docstring'''






							def __init__(							self  ,  a_  ,  *a_  ,  **a_		):
											super().__init__(_lowerCAmelCase  ,  *_lowerCAmelCase  ,  **_lowerCAmelCase		)
											a__				      =		config.num_labels
											a__				      =		TFRegNetMainLayer(_lowerCAmelCase  ,  name="""regnet"""		)
											# classification head
											a__				      =		[
											    tf.keras.layers.Flatten(),
											    tf.keras.layers.Dense(config.num_labels  ,  name="""classifier.1"""		) if config.num_labels > 0 else tf.identity,
											]







							@unpack_inputs
							@add_start_docstrings_to_model_forward(_lowerCAmelCase		)
							@add_code_sample_docstrings(
							    checkpoint=_IMAGE_CLASS_CHECKPOINT  ,  output_type=_lowerCAmelCase  ,  config_class=_CONFIG_FOR_DOC  ,  expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT  ,  )
							def _a      (							self  ,  a_ = None  ,  a_ = None  ,  a_ = None  ,  a_ = None  ,  a_=False  ,  ):
											a__				      =		(
											    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
											)
											a__				      =		return_dict if return_dict is not None else self.config.use_return_dict

											a__				      =		self.regnet(
											    _lowerCAmelCase  ,  output_hidden_states=_lowerCAmelCase  ,  return_dict=_lowerCAmelCase  ,  training=_lowerCAmelCase		)

											a__				      =		outputs.pooler_output if return_dict else outputs[1]

											a__				      =		self.classifier[0](_lowerCAmelCase		)
											a__				      =		self.classifier[1](_lowerCAmelCase		)

											a__				      =		None if labels is None else self.hf_compute_loss(labels=_lowerCAmelCase  ,  logits=_lowerCAmelCase		)

											if not return_dict:
															a__				      =		(logits,) + outputs[2:]
															return ((loss,) + output) if loss is not None else output

											return TFSequenceClassifierOutput(loss=_lowerCAmelCase  ,  logits=_lowerCAmelCase  ,  hidden_states=outputs.hidden_states		)






import os
from datetime import datetime as dt

from github import Github


UpperCAmelCase							 =					[
    """good first issue""",
    """good second issue""",
    """good difficult issue""",
    """enhancement""",
    """new pipeline/model""",
    """new scheduler""",
    """wip""",
]

def 			A_      (	):

				"""simple docstring"""
				a__				      =		Github(os.environ["""GITHUB_TOKEN"""]		)
				a__				      =		g.get_repo("""huggingface/diffusers"""		)
				a__				      =		repo.get_issues(state="""open"""		)

				for issue in open_issues:
								a__				      =		sorted(issue.get_comments() ,		key=lambda __a		: i.created_at ,		reverse=__a		)
								a__				      =		comments[0] if len(__a		) > 0 else None
								if (
								    last_comment is not None
								    and last_comment.user.login == "github-actions[bot]"
								    and (dt.utcnow() - issue.updated_at).days > 7
								    and (dt.utcnow() - issue.created_at).days >= 30
								    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()		)
								):
												# Closes the issue after 7 days of inactivity since the Stalebot notification.
												issue.edit(state="""closed"""		)
								elif (
								    "stale" in issue.get_labels()
								    and last_comment is not None
								    and last_comment.user.login != "github-actions[bot]"
								):
												# Opens the issue if someone other than Stalebot commented.
												issue.edit(state="""open"""		)
												issue.remove_from_labels("""stale"""		)
								elif (
								    (dt.utcnow() - issue.updated_at).days > 23
								    and (dt.utcnow() - issue.created_at).days >= 30
								    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()		)
								):
												# Post a Stalebot notification after 23 days of inactivity.
												issue.create_comment(
												    """This issue has been automatically marked as stale because it has not had """
												    """recent activity. If you think this still needs to be addressed """
												    """please comment on this thread.\n\nPlease note that issues that do not follow the """
												    """[contributing guidelines](https://github.com/huggingface/diffusers/blob/main/CONTRIBUTING.md) """
												    """are likely to be ignored."""		)
												issue.add_to_labels("""stale"""		)


if __name__ == "__main__":
	main()

