



from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import (
    BackboneOutput,
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import (
    add_code_sample_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    logging,
    replace_return_docstrings,
)
from ...utils.backbone_utils import BackboneMixin
from .configuration_resnet import ResNetConfig


a      :  Any			     =			logging.get_logger(__name__)

# General docstring
a      :  Any			     =			'ResNetConfig'

# Base docstring
a      :  Optional[Any]			     =			'microsoft/resnet-50'
a      :  List[Any]			     =			[1, 2_048, 7, 7]

# Image classification docstring
a      :  int			     =			'microsoft/resnet-50'
a      :  List[Any]			     =			'tiger cat'

a      :  Optional[Any]			     =			[
    'microsoft/resnet-50',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]







class 				_a				(   nn.Module					):

			def __init__(self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = 3,   SCREAMING_SNAKE_CASE_ = 1,   SCREAMING_SNAKE_CASE_ = "relu"					)       ->   Tuple:
						super().__init__()
						UpperCAmelCase_:		List[str]							      =     nn.Convad(
						    SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   kernel_size=SCREAMING_SNAKE_CASE_,   stride=SCREAMING_SNAKE_CASE_,   padding=kernel_size // 2,   bias=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		List[Any]							      =     nn.BatchNormad(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Optional[Any]							      =     ACTaFN[activation] if activation is not None else nn.Identity()

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_					)       ->   Tensor:
						UpperCAmelCase_:		str							      =     self.convolution(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Optional[int]							      =     self.normalization(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Optional[Any]							      =     self.activation(SCREAMING_SNAKE_CASE_					)
						return hidden_state







class 				_a				(   nn.Module					):

			def __init__(self,   SCREAMING_SNAKE_CASE_					)       ->   List[Any]:
						super().__init__()
						UpperCAmelCase_:		Optional[Any]							      =     ResNetConvLayer(
						    config.num_channels,   config.embedding_size,   kernel_size=7,   stride=2,   activation=config.hidden_act					)
						UpperCAmelCase_:		Tuple							      =     nn.MaxPoolad(kernel_size=3,   stride=2,   padding=1					)
						UpperCAmelCase_:		int							      =     config.num_channels

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_					)       ->   Tensor:
						UpperCAmelCase_:		List[Any]							      =     pixel_values.shape[1]
						if 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."""					)
						UpperCAmelCase_:		Union[str, Any]							      =     self.embedder(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		List[Any]							      =     self.pooler(SCREAMING_SNAKE_CASE_					)
						return embedding







class 				_a				(   nn.Module					):

			def __init__(self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = 2					)       ->   Optional[Any]:
						super().__init__()
						UpperCAmelCase_:		Dict							      =     nn.Convad(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   kernel_size=1,   stride=SCREAMING_SNAKE_CASE_,   bias=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Optional[int]							      =     nn.BatchNormad(SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_					)       ->   Tensor:
						UpperCAmelCase_:		Union[str, Any]							      =     self.convolution(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Dict							      =     self.normalization(SCREAMING_SNAKE_CASE_					)
						return hidden_state







class 				_a				(   nn.Module					):

			def __init__(self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = 1,   SCREAMING_SNAKE_CASE_ = "relu"					)       ->   Dict:
						super().__init__()
						UpperCAmelCase_:		List[Any]							      =     in_channels != out_channels or stride != 1
						UpperCAmelCase_:		Dict							      =     (
						    ResNetShortCut(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   stride=SCREAMING_SNAKE_CASE_					) if should_apply_shortcut else nn.Identity()
						)
						UpperCAmelCase_:		str							      =     nn.Sequential(
						    ResNetConvLayer(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   stride=SCREAMING_SNAKE_CASE_					),   ResNetConvLayer(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   activation=SCREAMING_SNAKE_CASE_					),   )
						UpperCAmelCase_:		List[str]							      =     ACTaFN[activation]

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_					)       ->   Dict:
						UpperCAmelCase_:		Union[str, Any]							      =     hidden_state
						UpperCAmelCase_:		Dict							      =     self.layer(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		str							      =     self.shortcut(SCREAMING_SNAKE_CASE_					)
						hidden_state += residual
						UpperCAmelCase_:		Union[str, Any]							      =     self.activation(SCREAMING_SNAKE_CASE_					)
						return hidden_state







class 				_a				(   nn.Module					):

			def __init__(self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = 1,   SCREAMING_SNAKE_CASE_ = "relu",   SCREAMING_SNAKE_CASE_ = 4					)       ->   int:
						super().__init__()
						UpperCAmelCase_:		List[Any]							      =     in_channels != out_channels or stride != 1
						UpperCAmelCase_:		List[str]							      =     out_channels // reduction
						UpperCAmelCase_:		Tuple							      =     (
						    ResNetShortCut(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   stride=SCREAMING_SNAKE_CASE_					) if should_apply_shortcut else nn.Identity()
						)
						UpperCAmelCase_:		List[Any]							      =     nn.Sequential(
						    ResNetConvLayer(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   kernel_size=1					),   ResNetConvLayer(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   stride=SCREAMING_SNAKE_CASE_					),   ResNetConvLayer(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   kernel_size=1,   activation=SCREAMING_SNAKE_CASE_					),   )
						UpperCAmelCase_:		List[Any]							      =     ACTaFN[activation]

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_					)       ->   Optional[Any]:
						UpperCAmelCase_:		Optional[Any]							      =     hidden_state
						UpperCAmelCase_:		List[str]							      =     self.layer(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Union[str, Any]							      =     self.shortcut(SCREAMING_SNAKE_CASE_					)
						hidden_state += residual
						UpperCAmelCase_:		int							      =     self.activation(SCREAMING_SNAKE_CASE_					)
						return hidden_state







class 				_a				(   nn.Module					):

			def __init__(self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = 2,   SCREAMING_SNAKE_CASE_ = 2,   )       ->   str:
						super().__init__()

						UpperCAmelCase_:		Union[str, Any]							      =     ResNetBottleNeckLayer if config.layer_type == """bottleneck""" else ResNetBasicLayer

						UpperCAmelCase_:		List[Any]							      =     nn.Sequential(
						    # downsampling is done in the first layer with stride of 2
						    layer(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   stride=SCREAMING_SNAKE_CASE_,   activation=config.hidden_act					),   *[layer(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   activation=config.hidden_act					) for _ in range(depth - 1					)],   )

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_					)       ->   Tensor:
						UpperCAmelCase_:		Union[str, Any]							      =     input
						for layer in self.layers:
									UpperCAmelCase_:		List[Any]							      =     layer(SCREAMING_SNAKE_CASE_					)
						return hidden_state







class 				_a				(   nn.Module					):

			def __init__(self,   SCREAMING_SNAKE_CASE_					)       ->   Optional[int]:
						super().__init__()
						UpperCAmelCase_:		Any							      =     nn.ModuleList([]					)
						# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
						self.stages.append(
						    ResNetStage(
						        SCREAMING_SNAKE_CASE_,   config.embedding_size,   config.hidden_sizes[0],   stride=2 if config.downsample_in_first_stage else 1,   depth=config.depths[0],   )					)
						UpperCAmelCase_:		Tuple							      =     zip(config.hidden_sizes,   config.hidden_sizes[1:]					)
						for (in_channels, out_channels), depth in zip(SCREAMING_SNAKE_CASE_,   config.depths[1:]					):
									self.stages.append(ResNetStage(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   depth=SCREAMING_SNAKE_CASE_					)					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = False,   SCREAMING_SNAKE_CASE_ = True					)       ->   BaseModelOutputWithNoAttention:
						UpperCAmelCase_:		Optional[Any]							      =     () if output_hidden_states else None

						for stage_module in self.stages:
									if output_hidden_states:
												UpperCAmelCase_:		Union[str, Any]							      =     hidden_states + (hidden_state,)

									UpperCAmelCase_:		Any							      =     stage_module(SCREAMING_SNAKE_CASE_					)

						if output_hidden_states:
									UpperCAmelCase_:		Tuple							      =     hidden_states + (hidden_state,)

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

						return BaseModelOutputWithNoAttention(
						    last_hidden_state=SCREAMING_SNAKE_CASE_,   hidden_states=SCREAMING_SNAKE_CASE_,   )







class 				_a				(   _lowerCAmelCase					):
			A      		=	ResNetConfig
			A      		=	'''resnet'''
			A      		=	'''pixel_values'''
			A      		=	True

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_					)       ->   Optional[Any]:
						if isinstance(SCREAMING_SNAKE_CASE_,   nn.Convad					):
									nn.init.kaiming_normal_(module.weight,   mode="""fan_out""",   nonlinearity="""relu"""					)
						elif isinstance(SCREAMING_SNAKE_CASE_,   (nn.BatchNormad, nn.GroupNorm)					):
									nn.init.constant_(module.weight,   1					)
									nn.init.constant_(module.bias,   0					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_=False					)       ->   int:
						if isinstance(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					):
									UpperCAmelCase_:		Tuple							      =     value






a      :  Any			     =			r'\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n'

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







@add_start_docstrings(
    '''The bare ResNet model outputting raw features without any specific head on top.''' ,		_lowerCAmelCase ,		)
class 				_a				(   _lowerCAmelCase					):

			def __init__(self,   SCREAMING_SNAKE_CASE_					)       ->   Optional[Any]:
						super().__init__(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		List[Any]							      =     config
						UpperCAmelCase_:		Union[str, Any]							      =     ResNetEmbeddings(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Optional[Any]							      =     ResNetEncoder(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Optional[int]							      =     nn.AdaptiveAvgPoolad((1, 1)					)
						# Initialize weights and apply final processing
						self.post_init()

			@add_start_docstrings_to_model_forward(SCREAMING_SNAKE_CASE_					)
			@add_code_sample_docstrings(
			    checkpoint=_CHECKPOINT_FOR_DOC,   output_type=SCREAMING_SNAKE_CASE_,   config_class=_CONFIG_FOR_DOC,   modality="""vision""",   expected_output=_EXPECTED_OUTPUT_SHAPE,   )
			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None					)       ->   BaseModelOutputWithPoolingAndNoAttention:
						UpperCAmelCase_:		List[str]							      =     (
						    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
						)
						UpperCAmelCase_:		Any							      =     return_dict if return_dict is not None else self.config.use_return_dict

						UpperCAmelCase_:		Optional[Any]							      =     self.embedder(SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Dict							      =     self.encoder(
						    SCREAMING_SNAKE_CASE_,   output_hidden_states=SCREAMING_SNAKE_CASE_,   return_dict=SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		str							      =     encoder_outputs[0]

						UpperCAmelCase_:		Dict							      =     self.pooler(SCREAMING_SNAKE_CASE_					)

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

						return BaseModelOutputWithPoolingAndNoAttention(
						    last_hidden_state=SCREAMING_SNAKE_CASE_,   pooler_output=SCREAMING_SNAKE_CASE_,   hidden_states=encoder_outputs.hidden_states,   )







@add_start_docstrings(
    '''
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    ''' ,		_lowerCAmelCase ,		)
class 				_a				(   _lowerCAmelCase					):

			def __init__(self,   SCREAMING_SNAKE_CASE_					)       ->   str:
						super().__init__(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		List[Any]							      =     config.num_labels
						UpperCAmelCase_:		Tuple							      =     ResNetModel(SCREAMING_SNAKE_CASE_					)
						# classification head
						UpperCAmelCase_:		Dict							      =     nn.Sequential(
						    nn.Flatten(),   nn.Linear(config.hidden_sizes[-1],   config.num_labels					) if config.num_labels > 0 else nn.Identity(),   )
						# initialize weights and apply final processing
						self.post_init()

			@add_start_docstrings_to_model_forward(SCREAMING_SNAKE_CASE_					)
			@add_code_sample_docstrings(
			    checkpoint=_IMAGE_CLASS_CHECKPOINT,   output_type=SCREAMING_SNAKE_CASE_,   config_class=_CONFIG_FOR_DOC,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT,   )
			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   )       ->   ImageClassifierOutputWithNoAttention:
						UpperCAmelCase_:		List[str]							      =     return_dict if return_dict is not None else self.config.use_return_dict

						UpperCAmelCase_:		List[Any]							      =     self.resnet(SCREAMING_SNAKE_CASE_,   output_hidden_states=SCREAMING_SNAKE_CASE_,   return_dict=SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Union[str, Any]							      =     outputs.pooler_output if return_dict else outputs[1]

						UpperCAmelCase_:		Union[str, Any]							      =     self.classifier(SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Tuple							      =     None

						if labels is not None:
									if self.config.problem_type is None:
												if self.num_labels == 1:
															UpperCAmelCase_:		int							      =     """regression"""
												elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
															UpperCAmelCase_:		List[str]							      =     """single_label_classification"""
												else:
															UpperCAmelCase_:		int							      =     """multi_label_classification"""
									if self.config.problem_type == "regression":
												UpperCAmelCase_:		List[str]							      =     MSELoss()
												if self.num_labels == 1:
															UpperCAmelCase_:		Any							      =     loss_fct(logits.squeeze(),   labels.squeeze()					)
												else:
															UpperCAmelCase_:		Dict							      =     loss_fct(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					)
									elif self.config.problem_type == "single_label_classification":
												UpperCAmelCase_:		List[str]							      =     CrossEntropyLoss()
												UpperCAmelCase_:		Tuple							      =     loss_fct(logits.view(-1,   self.num_labels					),   labels.view(-1					)					)
									elif self.config.problem_type == "multi_label_classification":
												UpperCAmelCase_:		str							      =     BCEWithLogitsLoss()
												UpperCAmelCase_:		Dict							      =     loss_fct(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					)

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

						return ImageClassifierOutputWithNoAttention(loss=SCREAMING_SNAKE_CASE_,   logits=SCREAMING_SNAKE_CASE_,   hidden_states=outputs.hidden_states					)







@add_start_docstrings(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    ''' ,		_lowerCAmelCase ,		)
class 				_a				(   _lowerCAmelCase ,		_lowerCAmelCase					):

			def __init__(self,   SCREAMING_SNAKE_CASE_					)       ->   Optional[Any]:
						super().__init__(SCREAMING_SNAKE_CASE_					)
						super()._init_backbone(SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Optional[Any]							      =     [config.embedding_size] + config.hidden_sizes
						UpperCAmelCase_:		List[str]							      =     ResNetEmbeddings(SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		int							      =     ResNetEncoder(SCREAMING_SNAKE_CASE_					)

						# initialize weights and apply final processing
						self.post_init()

			@add_start_docstrings_to_model_forward(SCREAMING_SNAKE_CASE_					)
			@replace_return_docstrings(output_type=SCREAMING_SNAKE_CASE_,   config_class=_CONFIG_FOR_DOC					)
			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None					)       ->   BackboneOutput:
						UpperCAmelCase_:		Any							      =     return_dict if return_dict is not None else self.config.use_return_dict
						UpperCAmelCase_:		Tuple							      =     (
						    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
						)

						UpperCAmelCase_:		List[Any]							      =     self.embedder(SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Optional[int]							      =     self.encoder(SCREAMING_SNAKE_CASE_,   output_hidden_states=SCREAMING_SNAKE_CASE_,   return_dict=SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Any							      =     outputs.hidden_states

						UpperCAmelCase_:		Optional[Any]							      =     ()
						for idx, stage in enumerate(self.stage_names					):
									if stage in self.out_features:
												feature_maps += (hidden_states[idx],)

						if not return_dict:
									UpperCAmelCase_:		str							      =     (feature_maps,)
									if output_hidden_states:
												output += (outputs.hidden_states,)
									return output

						return BackboneOutput(
						    feature_maps=SCREAMING_SNAKE_CASE_,   hidden_states=outputs.hidden_states if output_hidden_states else None,   attentions=SCREAMING_SNAKE_CASE_,   )











import logging
from dataclasses import dataclass, field
from typing import Optional

from seqaseq_trainer import arg_to_scheduler

from transformers import TrainingArguments


a      :  Optional[int]			     =			logging.getLogger(__name__)







@dataclass
class 				_a				(   _lowerCAmelCase					):
			A      		=	field(
			    default=0.0 ,		metadata={'''help''': '''The label smoothing epsilon to apply (if not zero).'''}					)
			A      		=	field(default=_lowerCAmelCase ,		metadata={'''help''': '''Whether to SortishSamler or not.'''}					)
			A      		=	field(
			    default=_lowerCAmelCase ,		metadata={'''help''': '''Whether to use generate to calculate generative metrics (ROUGE, BLEU).'''}					)
			A      		=	field(default=_lowerCAmelCase ,		metadata={'''help''': '''whether to use adafactor'''}					)
			A      		=	field(
			    default=_lowerCAmelCase ,		metadata={'''help''': '''Encoder layer dropout probability. Goes into model.config.'''}					)
			A      		=	field(
			    default=_lowerCAmelCase ,		metadata={'''help''': '''Decoder layer dropout probability. Goes into model.config.'''}					)
			A      		=	field(default=_lowerCAmelCase ,		metadata={'''help''': '''Dropout probability. Goes into model.config.'''}					)
			A      		=	field(
			    default=_lowerCAmelCase ,		metadata={'''help''': '''Attention dropout probability. Goes into model.config.'''}					)
			A      		=	field(
			    default='''linear''' ,		metadata={'''help''': F'''Which lr scheduler to use. Selected in {sorted(arg_to_scheduler.keys()					)}'''} ,		)






