
'''simple docstring'''
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


lowercase__											=logging.get_logger(__name__)

# General docstring
lowercase__											='RegNetConfig'

# Base docstring
lowercase__											='facebook/regnet-y-040'
lowercase__											=[1, 10_88, 7, 7]

# Image classification docstring
lowercase__											='facebook/regnet-y-040'
lowercase__											='tabby, tabby cat'

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







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




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase = 3					,   UpperCAmelCase = 1					,   UpperCAmelCase = 1					,   UpperCAmelCase = "relu"					,   **UpperCAmelCase					,   ):
				super().__init__(**UpperCAmelCase	)
				# 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=UpperCAmelCase					,   kernel_size=UpperCAmelCase					,   strides=UpperCAmelCase					,   padding="""VALID"""					,   groups=UpperCAmelCase					,   use_bias=UpperCAmelCase					,   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 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self.convolution(self.padding(UpperCAmelCase	)	)
				a_      				=						self.normalization(UpperCAmelCase	)
				a_      				=						self.activation(UpperCAmelCase	)
				return hidden_state







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




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






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						shape_list(UpperCAmelCase	)[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(UpperCAmelCase					,   perm=(0, 2, 3, 1)	)
				a_      				=						self.embedder(UpperCAmelCase	)
				return hidden_state







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




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






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase = False	):
				return self.normalization(self.convolution(UpperCAmelCase	)					,   training=UpperCAmelCase	)







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




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






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				# [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
				a_      				=						self.pooler(UpperCAmelCase	)
				for layer_module in self.attention:
					a_      				=						layer_module(UpperCAmelCase	)
				a_      				=						hidden_state * pooled
				return hidden_state







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




			def __init__(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase = 1					,   **UpperCAmelCase	):
				super().__init__(**UpperCAmelCase	)
				a_      				=						in_channels != out_channels or stride != 1
				a_      				=						max(1					,   out_channels // config.groups_width	)
				a_      				=						(
				    TFRegNetShortCut(UpperCAmelCase					,   stride=UpperCAmelCase					,   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(UpperCAmelCase					,   kernel_size=1					,   activation=config.hidden_act					,   name="""layer.0"""	),
				    TFRegNetConvLayer(
				        UpperCAmelCase					,   stride=UpperCAmelCase					,   groups=UpperCAmelCase					,   activation=config.hidden_act					,   name="""layer.1"""	),
				    TFRegNetConvLayer(UpperCAmelCase					,   kernel_size=1					,   activation=UpperCAmelCase					,   name="""layer.2"""	),
				]
				a_      				=						ACTaFN[config.hidden_act]






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						hidden_state
				for layer_module in self.layers:
					a_      				=						layer_module(UpperCAmelCase	)
				a_      				=						self.shortcut(UpperCAmelCase	)
				hidden_state += residual
				a_      				=						self.activation(UpperCAmelCase	)
				return hidden_state







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




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






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						hidden_state
				for layer_module in self.layers:
					a_      				=						layer_module(UpperCAmelCase	)
				a_      				=						self.shortcut(UpperCAmelCase	)
				hidden_state += residual
				a_      				=						self.activation(UpperCAmelCase	)
				return hidden_state







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




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

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






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				for layer_module in self.layers:
					a_      				=						layer_module(UpperCAmelCase	)
				return hidden_state







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




			def __init__(       self					,   UpperCAmelCase					,   **UpperCAmelCase	):
				super().__init__(**UpperCAmelCase	)
				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(
				        UpperCAmelCase					,   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(UpperCAmelCase					,   config.depths[1:]	)	):
					self.stages.append(TFRegNetStage(UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase					,   depth=UpperCAmelCase					,   name=f'''stages.{i+1}'''	)	)






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase = False					,   UpperCAmelCase = 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(UpperCAmelCase	)

				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=UpperCAmelCase					,   hidden_states=UpperCAmelCase	)







@keras_serializable
class   a_ (      tf.keras.layers.Layer					):
			lowerCamelCase__	:			List[str]       =    RegNetConfig




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






			@unpack_inputs
			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase = 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(UpperCAmelCase					,   training=UpperCAmelCase	)

				a_      				=						self.encoder(
				    UpperCAmelCase					,   output_hidden_states=UpperCAmelCase					,   return_dict=UpperCAmelCase					,   training=UpperCAmelCase	)

				a_      				=						encoder_outputs[0]
				a_      				=						self.pooler(UpperCAmelCase	)

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

				# Change the other hidden state outputs to NCHW as well
				if output_hidden_states:
					a_      				=						tuple([tf.transpose(UpperCAmelCase					,   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=UpperCAmelCase					,   pooler_output=UpperCAmelCase					,   hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states					,   )







class   a_ (      UpperCamelCase__					):
			lowerCamelCase__	:			List[Any]       =    RegNetConfig
			lowerCamelCase__	:			str       =    'regnet'
			lowerCamelCase__	:			Optional[Any]       =    'pixel_values'




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







lowercase__											=r'\n    Parameters:\n    This model is a Tensorflow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and\n    behavior.\n        config ([`RegNetConfig`]): 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 [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n'

lowercase__											=r'\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConveNextImageProcessor.__call__`] for details.\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 RegNet model outputting raw features without any specific head on top.'		,  UpperCamelCase__		,  )
class   a_ (      UpperCamelCase__					):




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






			@unpack_inputs
			@add_start_docstrings_to_model_forward(UpperCAmelCase	)
			@add_code_sample_docstrings(
			    checkpoint=_CHECKPOINT_FOR_DOC					,   output_type=UpperCAmelCase					,   config_class=_CONFIG_FOR_DOC					,   modality="""vision"""					,   expected_output=_EXPECTED_OUTPUT_SHAPE					,   )
			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase=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=UpperCAmelCase					,   output_hidden_states=UpperCAmelCase					,   return_dict=UpperCAmelCase					,   training=UpperCAmelCase					,   )
				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    '		,  UpperCamelCase__		,  )
class   a_ (      UpperCamelCase__		,  UpperCamelCase__					):




			def __init__(       self					,   UpperCAmelCase					,   *UpperCAmelCase					,   **UpperCAmelCase	):
				super().__init__(UpperCAmelCase					,   *UpperCAmelCase					,   **UpperCAmelCase	)
				a_      				=						config.num_labels
				a_      				=						TFRegNetMainLayer(UpperCAmelCase					,   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(UpperCAmelCase	)
			@add_code_sample_docstrings(
			    checkpoint=_IMAGE_CLASS_CHECKPOINT					,   output_type=UpperCAmelCase					,   config_class=_CONFIG_FOR_DOC					,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT					,   )
			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase = None					,   UpperCAmelCase=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(
				    UpperCAmelCase					,   output_hidden_states=UpperCAmelCase					,   return_dict=UpperCAmelCase					,   training=UpperCAmelCase	)

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

				a_      				=						self.classifier[0](UpperCAmelCase	)
				a_      				=						self.classifier[1](UpperCAmelCase	)

				a_      				=						None if labels is None else self.hf_compute_loss(labels=UpperCAmelCase					,   logits=UpperCAmelCase	)

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

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


'''simple docstring'''
def      UpperCamelCase_				(      A__  ,      A__  ,      A__						):
	if len(A__						) != len(A__						):
		raise ValueError("""The length of profit and weight must be same."""						)
	if max_weight <= 0:
		raise ValueError("""max_weight must greater than zero."""						)
	if any(p < 0 for p in profit						):
		raise ValueError("""Profit can not be negative."""						)
	if any(w < 0 for w in weight						):
		raise ValueError("""Weight can not be negative."""						)

	# List created to store profit gained for the 1kg in case of each weight
	# respectively.  Calculate and append profit/weight for each element.
	a_      				=						[p / w for p, w in zip(A__  ,      A__						)]

	# Creating a copy of the list and sorting profit/weight in ascending order
	a_      				=						sorted(A__						)

	# declaring useful variables
	a_      				=						len(A__						)
	a_      				=						0
	a_      				=						0
	a_      				=						0

	# loop till the total weight do not reach max limit e.g. 15 kg and till i<length
	while limit <= max_weight and i < length:
		# flag value for encountered greatest element in sorted_profit_by_weight
		a_      				=						sorted_profit_by_weight[length - i - 1]
		a_      				=						profit_by_weight.index(A__						)
		a_      				=						-1

		# check if the weight encountered is less than the total weight
		# encountered before.
		if max_weight - limit >= weight[index]:
			limit += weight[index]
			# Adding profit gained for the given weight 1 ===
			# weight[index]/weight[index]
			gain += 1 * profit[index]
		else:
			# Since the weight encountered is greater than limit, therefore take the
			# required number of remaining kgs and calculate profit for it.
			# weight remaining / weight[index]
			gain += (max_weight - limit) / weight[index] * profit[index]
			break
		i += 1
	return gain


if __name__ == "__main__":
		print(
		    'Input profits, weights, and then max_weight (all positive ints) separated by '
		    'spaces.'
		)

		lowercase__											=[int(x) for x in input('Input profits separated by spaces: ').split()]
		lowercase__											=[int(x) for x in input('Input weights separated by spaces: ').split()]
		lowercase__											=int(input('Max weight allowed: '))

		# Function Call
		calc_profit(profit, weight, max_weight)
