
    2Vh8                        d dl mZ d dl mZ d dlmZ d dlmZ d dlmZ d dl	m
Z
 d dlmZ d dlmZ d	Z ed
dg      	 	 	 	 	 	 	 	 dd       Z	 	 	 	 	 ddZ G d de      ZddZ ed      dd       Z ed      dd       Zej,                  j/                  dej0                  ej2                        e_        ej*                  j4                  e_        y)    )backend)layers)keras_export)imagenet_utils)Layer)
Functional)operation_utils)
file_utilszQhttps://storage.googleapis.com/tensorflow/keras-applications/inception_resnet_v2/z8keras.applications.inception_resnet_v2.InceptionResNetV2z$keras.applications.InceptionResNetV2Nc                 v	   |dv s t        j                  |      st        d      |dk(  r| r|dk7  rt        d|       t        j                  |ddt        j                         | |      }|t        j                  |
      }n/t        j                  |      st        j                  ||      }n|}t        |dddd      }	t        |	ddd      }	t        |	dd      }	 t        j                  dd      |	      }	t        |	ddd      }	t        |	ddd      }	 t        j                  dd      |	      }	t        |	dd      }
t        |	dd      }t        |dd      }t        |	dd      }t        |dd      }t        |dd      } t        j                  ddd      |	      }t        |dd      }|
|||g}t        j                         dk(  rdnd} t        j                  |d      |      }	t        dd      D ]  }t        |	dd |!      }	 t        |	d"ddd      }
t        |	d#d      }t        |d#d      }t        |d"ddd      } t        j                  ddd      |	      }|
||g} t        j                  |d$      |      }	t        dd%      D ]  }t        |	d&d'|!      }	 t        |	d#d      }
t        |
d"ddd      }
t        |	d#d      }t        |d(ddd      }t        |	d#d      }t        |d(d      }t        |d)ddd      } t        j                  ddd      |	      }|
|||g} t        j                  |d*      |      }	t        dd+      D ]  }t        |	d,d-|!      }	 t        |	d.d	d-d+/      }	t        |	d0dd12      }	| rQ t        j                   d32      |	      }	t        j"                  ||        t        j$                  ||d45      |	      }	n?|d6k(  r t        j                          |	      }	n|d7k(  r t        j&                         |	      }	|t)        j*                  |      }n|}t-        ||	|2      }|dk(  rZ| r#d8}t        j.                  |t0        |z   d9d:;      }n"d<}t        j.                  |t0        |z   d9d=;      }|j3                  |       |S ||j3                  |       |S )>a  Instantiates the Inception-ResNet v2 architecture.

    Reference:
    - [Inception-v4, Inception-ResNet and the Impact of
       Residual Connections on Learning](https://arxiv.org/abs/1602.07261)
      (AAAI 2017)

    This function returns a Keras image classification model,
    optionally loaded with weights pre-trained on ImageNet.

    For image classification use cases, see
    [this page for detailed examples](
      https://keras.io/api/applications/#usage-examples-for-image-classification-models).

    For transfer learning use cases, make sure to read the
    [guide to transfer learning & fine-tuning](
      https://keras.io/guides/transfer_learning/).

    Note: each Keras Application expects a specific kind of
    input preprocessing. For InceptionResNetV2, call
    `keras.applications.inception_resnet_v2.preprocess_input`
    on your inputs before passing them to the model.
    `inception_resnet_v2.preprocess_input`
    will scale input pixels between -1 and 1.

    Args:
        include_top: whether to include the fully-connected
            layer at the top of the network.
        weights: one of `None` (random initialization),
            `"imagenet"` (pre-training on ImageNet),
            or the path to the weights file to be loaded.
        input_tensor: optional Keras tensor
            (i.e. output of `layers.Input()`)
            to use as image input for the model.
        input_shape: optional shape tuple, only to be specified
            if `include_top` is `False` (otherwise the input shape
            has to be `(299, 299, 3)`
            (with `'channels_last'` data format)
            or `(3, 299, 299)` (with `'channels_first'` data format).
            It should have exactly 3 inputs channels,
            and width and height should be no smaller than 75.
            E.g. `(150, 150, 3)` would be one valid value.
        pooling: Optional pooling mode for feature extraction
            when `include_top` is `False`.
            - `None` means that the output of the model will be
                the 4D tensor output of the last convolutional block.
            - `'avg'` means that global average pooling
                will be applied to the output of the
                last convolutional block, and thus
                the output of the model will be a 2D tensor.
            - `'max'` means that global max pooling will be applied.
        classes: optional number of classes to classify images
            into, only to be specified if `include_top` is `True`,
            and if no `weights` argument is specified.
        classifier_activation: A `str` or callable.
            The activation function to use on the "top" layer.
            Ignored unless `include_top=True`.
            Set `classifier_activation=None` to return the logits
            of the "top" layer. When loading pretrained weights,
            `classifier_activation` can only be `None` or `"softmax"`.
        name: The name of the model (string).

    Returns:
        A model instance.
    >   NimagenetzThe `weights` argument should be either `None` (random initialization), `imagenet` (pre-training on ImageNet), or the path to the weights file to be loaded.r     zbIf using `weights="imagenet"` with `include_top=True`, `classes` should be 1000. Received classes=i+  K   )default_sizemin_sizedata_formatrequire_flattenweightsN)shape)tensorr             valid)stridespadding)r   @   )r   P         `   0      samechannels_firstmixed_5baxisname   g(\?block35)scale
block_type	block_idxi     mixed_6a   g?block17i   i@  mixed_7a
   g?block8g      ?)r+   
activationr,   r-   i   conv_7br(   avg_poolpredictions)r5   r(   avgmaxz9inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5models e693bd0210a403b3192acc6073ad2e96)cache_subdir	file_hashz?inception_resnet_v2_weights_tf_dim_ordering_tf_kernels_notop.h5 d19885ff4a710c122648d3b5c3b684e4)r
   exists
ValueErrorr   obtain_input_shaper   image_data_formatr   Inputis_keras_tensor	conv2d_bnMaxPooling2DAveragePooling2DConcatenaterangeinception_resnet_blockGlobalAveragePooling2Dvalidate_activationDenseGlobalMaxPooling2Dr	   get_source_inputsr   get_fileBASE_WEIGHT_URLload_weights)include_topr   input_tensorinput_shapepoolingclassesclassifier_activationr(   	img_inputxbranch_0branch_1branch_2branch_poolbrancheschannel_axisr-   inputsmodelfnameweights_paths                        Z/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/applications/inception_resnet_v2.pyInceptionResNetV2rh      s&   b ))Z->->w-G<
 	
 *D  'y*
 	
 !33--/#K LL{3	&&|4LLI$I 	)RAw?A!RG,A!RA)Aq)!,A!RG,A!S!W-A)Aq)!,A B"HB"H2q)HB"H2q)H2q)HG&))!QGJKKQ/K(Hk:H1137GG1QL>:>xHA 1b\ 
	"Ti9

 CAw?HC#H3*H31gFHD&%%aGDQGK(K0H>:>xHA 1b\ 
	"SY)

 C#H31gFHC#H31gFHC#H3*H31gFHD&%%aGDQGK(Hk:H>:>xHA 1b\ 
	"SX

 		(b	A
 	!T19-A:F))z:1=**+@'J
FLL 5M

 e/--/2A+))+A.A  22<@ vqt,E *OE%..%'%<	L6  &..%'%<	L 	<( L 
	7#L    c           	           t        j                  ||||||      |       } |sBt        j                         dk(  rdnd}|dn|dz   }	 t        j                  |d|	      |       } |&|dn|d	z   }
 t        j
                  ||

      |       } | S )a2  Utility function to apply conv + BN.

    Args:
        x: input tensor.
        filters: filters in `Conv2D`.
        kernel_size: kernel size as in `Conv2D`.
        strides: strides in `Conv2D`.
        padding: padding mode in `Conv2D`.
        activation: activation in `Conv2D`.
        use_bias: whether to use a bias in `Conv2D`.
        name: name of the ops; will become `name + '_ac'`
            for the activation and `name + '_bn'` for the batch norm layer.

    Returns:
        Output tensor after applying `Conv2D` and `BatchNormalization`.
    )r   r   use_biasr(   r$   r   r   N_bnF)r'   r+   r(   _acr7   )r   Conv2Dr   rD   BatchNormalization
Activation)r\   filterskernel_sizer   r   r5   rk   r(   bn_axisbn_nameac_names              rg   rG   rG      s    4		 		A 0026FF!A,$D5LNF%%7%gN
 ,$D5L7Fjw7:Hri   c                   .     e Zd Z fdZ fdZd Z xZS )CustomScaleLayerc                 2    t        |   di | || _        y )N )super__init__r+   )selfr+   kwargs	__class__s      rg   r{   zCustomScaleLayer.__init__'  s    "6"
ri   c                 ^    t         |          }|j                  d| j                  i       |S )Nr+   )rz   
get_configupdater+   )r|   configr~   s     rg   r   zCustomScaleLayer.get_config+  s*    #%w

+,ri   c                 2    |d   |d   | j                   z  z   S )Nr   r   )r+   )r|   rc   s     rg   callzCustomScaleLayer.call0  s    ay6!9tzz111ri   )__name__
__module____qualname__r{   r   r   __classcell__)r~   s   @rg   rw   rw   &  s    
2ri   rw   c           	      2   |dk(  rTt        | dd      }t        | dd      }t        |dd      }t        | dd      }t        |dd      }t        |dd      }|||g}n|dk(  r=t        | dd      }t        | d	d      }t        |d
ddg      }t        |dddg      }||g}nY|dk(  r=t        | dd      }t        | dd      }t        |dddg      }t        |dddg      }||g}nt        dt        |      z         |dz   t        |      z   }	t        j                         dk(  rdnd}
 t        j                  |
|	dz         |      }t        || j                  |
   ddd|	dz         } t        |      | |g      } |  t        j                  ||	dz         |       } | S )a  Adds an Inception-ResNet block.

    Args:
        x: input tensor.
        scale: scaling factor to scale the residuals
            (i.e., the output of passing `x` through an inception module)
            before adding them to the shortcut
            branch. Let `r` be the output from the residual branch,
            the output of this block will be `x + scale * r`.
        block_type: `'block35'`, `'block17'` or `'block8'`,
            determines the network structure in the residual branch.
        block_idx: an `int` used for generating layer names.
            The Inception-ResNet blocks are repeated many times
            in this network. We use `block_idx` to identify each
            of the repetitions. For example, the first
            Inception-ResNet-A block will have
            `block_type='block35', block_idx=0`, and the layer names
            will have a common prefix `'block35_0'`.
        activation: activation function to use at the end of the block.

    Returns:
        Output tensor for the block.
    r*   r   r   r   r!   r   r1   r            r4      r.   zXUnknown Inception-ResNet block type. Expects "block35", "block17" or "block8", but got: _r$   _mixedr&   NT_conv)r5   rk   r(   rm   r7   )
rG   rB   strr   rD   r   rJ   r   rw   rp   )r\   r+   r,   r-   r5   r]   r^   r_   ra   
block_namerb   mixedups                rg   rL   rL   4  s   0 YQA&QA&Xr1-QA&Xr1-Xr1-h1	y	 QQ'QQ'XsQF3XsQF3h'	x	QQ'QQ'XsQF3XsQF3h'j/*
 	
 c!C	N2J1137GG1QLMFLzH7LME 
		'!
B 	 B(ABFjzE/AB1EHri   z7keras.applications.inception_resnet_v2.preprocess_inputc                 2    t        j                  | |d      S )Ntf)r   mode)r   preprocess_input)r\   r   s     rg   r   r   {  s    **	{ ri   z9keras.applications.inception_resnet_v2.decode_predictionsc                 0    t        j                  | |      S )N)top)r   decode_predictions)predsr   s     rg   r   r     s    ,,U<<ri    )r   reterror)Tr   NNNr   softmaxinception_resnet_v2)r   r#   reluFN)r   )N)r"   )	keras.srcr   r   keras.src.api_exportr   keras.src.applicationsr   keras.src.layers.layerr   keras.src.modelsr   keras.src.opsr	   keras.src.utilsr
   rS   rh   rG   rw   rL   r   r   PREPROCESS_INPUT_DOCformatPREPROCESS_INPUT_RET_DOC_TFPREPROCESS_INPUT_ERROR_DOC__doc__ry   ri   rg   <module>r      s     - 1 ( ' ) &.  B. #	__L 	+\2u 2DN GH I IJ= K= *>>EE	22

3
3 F   
 ,>>FF  ri   