code: def inception_resnet_v1(
      inputs,
      num_classes,
      is_training=True,
      dropout_keep_prob=0.8,
      bottleneck_layer_size=512,
      reuse=None,
      scope="InceptionResnetV1",
  ):
      """Creates the Inception Resnet V1 model.
      Args:
        inputs: a 4-D tensor of size [batch_size, height, width, 3].
        num_classes: number of predicted classes.
        is_training: whether is training or not.
        dropout_keep_prob: float, the fraction to keep before final layer.
        reuse: whether or not the network and its variables should be reused. To be
          able to reuse 'scope' must be given.
        scope: Optional variable_scope.
      Returns:
        logits: the logits outputs of the model.
        end_points: the set of end_points from the inception model.
      """
      end_points = {}
  
      with tf.variable_scope(
          scope, "InceptionResnetV1", [inputs], reuse=reuse
      ):
          with slim.arg_scope(
              [slim.batch_norm, slim.dropout], is_training=is_training
          ):
              with slim.arg_scope(
                  [slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
                  stride=1,
                  padding="SAME",
              ):
                  # 149 x 149 x 32
                  net = slim.conv2d(
                      inputs,
                      32,
                      3,
                      stride=2,
                      padding="VALID",
                      scope="Conv2d_1a_3x3",
                  )
                  end_points["Conv2d_1a_3x3"] = net
                  # 147 x 147 x 32
                  net = slim.conv2d(
                      net, 32, 3, padding="VALID", scope="Conv2d_2a_3x3"
                  )
                  end_points["Conv2d_2a_3x3"] = net
                  # 147 x 147 x 64
                  net = slim.conv2d(net, 64, 3, scope="Conv2d_2b_3x3")
                  end_points["Conv2d_2b_3x3"] = net
                  # 73 x 73 x 64
                  net = slim.max_pool2d(
                      net,
                      3,
                      stride=2,
                      padding="VALID",
                      scope="MaxPool_3a_3x3",
                  )
                  end_points["MaxPool_3a_3x3"] = net
                  # 73 x 73 x 80
                  net = slim.conv2d(
                      net, 80, 1, padding="VALID", scope="Conv2d_3b_1x1"
                  )
                  end_points["Conv2d_3b_1x1"] = net
                  # 71 x 71 x 192
                  net = slim.conv2d(
                      net,
                      192,
                      3,
                      padding="VALID",
                      scope="Conv2d_4a_3x3",
                  )
                  end_points["Conv2d_4a_3x3"] = net
                  # 35 x 35 x 256
                  net = slim.conv2d(
                      net,
                      256,
                      3,
                      stride=2,
                      padding="VALID",
                      scope="Conv2d_4b_3x3",
                  )
                  end_points["Conv2d_4b_3x3"] = net
  
                  # 5 x Inception-resnet-A
                  net = slim.repeat(net, 5, block35, scale=0.17)
                  end_points["Mixed_5a"] = net
  
                  # Reduction-A
                  with tf.variable_scope("Mixed_6a"):
                      net = reduction_a(net, 192, 192, 256, 384)
                  end_points["Mixed_6a"] = net
  
                  # 10 x Inception-Resnet-B
                  net = slim.repeat(net, 10, block17, scale=0.10)
                  end_points["Mixed_6b"] = net
  
                  # Reduction-B
                  with tf.variable_scope("Mixed_7a"):
                      net = reduction_b(net)
                  end_points["Mixed_7a"] = net
  
                  # 5 x Inception-Resnet-C
                  net = slim.repeat(net, 5, block8, scale=0.20)
                  end_points["Mixed_8a"] = net
  
                  net = block8(net, activation_fn=None)
                  end_points["Mixed_8b"] = net
  
                  with tf.variable_scope("Logits"):
                      end_points["PrePool"] = net
                      # pylint: disable=no-member
                      net = slim.avg_pool2d(
                          net,
                          net.get_shape()[1:3],
                          padding="VALID",
                          scope="AvgPool_1a_8x8",
                      )
                      net = slim.flatten(net)
  
                      net = slim.dropout(
                          net,
                          dropout_keep_prob,
                          is_training=is_training,
                          scope="Dropout",
                      )
  
                      end_points["PreLogitsFlatten"] = net
  
                  # net = slim.fully_connected(net, bottleneck_layer_size, activation_fn=None,
                  #         scope='Bottleneck', reuse=False)
  
      return net, end_points
  
file_path: MMdnn/mmdnn/conversion/examples/tensorflow/models/inception_resnet_v1.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import tensorflow
  import tensorflow.contrib.slim
label_desc: Use image node_id 7 for calling a global function with example usage: inception_resnet_v1(inputs, num_classes, is_training, dropout_keep_prob, bottleneck_layer_size, reuse, scope) and returns: net,  end_points