code: def inception_v1(
      inputs,
      num_classes=1000,
      is_training=True,
      dropout_keep_prob=0.8,
      prediction_fn=slim.softmax,
      spatial_squeeze=True,
      reuse=None,
      scope="InceptionV1",
      global_pool=False,
  ):
      """Defines the Inception V1 architecture.
  
      This architecture is defined in:
  
        Going deeper with convolutions
        Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed,
        Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, Andrew Rabinovich.
        http://arxiv.org/pdf/1409.4842v1.pdf.
  
      The default image size used to train this network is 224x224.
  
      Args:
        inputs: a tensor of size [batch_size, height, width, channels].
        num_classes: number of predicted classes. If 0 or None, the logits layer
          is omitted and the input features to the logits layer (before dropout)
          are returned instead.
        is_training: whether is training or not.
        dropout_keep_prob: the percentage of activation values that are retained.
        prediction_fn: a function to get predictions out of logits.
        spatial_squeeze: if True, logits is of shape [B, C], if false logits is of
            shape [B, 1, 1, C], where B is batch_size and C is number of classes.
        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.
        global_pool: Optional boolean flag to control the avgpooling before the
          logits layer. If false or unset, pooling is done with a fixed window
          that reduces default-sized inputs to 1x1, while larger inputs lead to
          larger outputs. If true, any input size is pooled down to 1x1.
  
      Returns:
        net: a Tensor with the logits (pre-softmax activations) if num_classes
          is a non-zero integer, or the non-dropped-out input to the logits layer
          if num_classes is 0 or None.
        end_points: a dictionary from components of the network to the corresponding
          activation.
      """
      # Final pooling and prediction
      with tf.variable_scope(
          scope, "InceptionV1", [inputs], reuse=reuse
      ) as scope:
          with slim.arg_scope(
              [slim.batch_norm, slim.dropout], is_training=is_training
          ):
              net, end_points = inception_v1_base(inputs, scope=scope)
              with tf.variable_scope("Logits"):
                  if global_pool:
                      # Global average pooling.
                      net = tf.reduce_mean(
                          net,
                          [1, 2],
                          keep_dims=True,
                          name="global_pool",
                      )
                      end_points["global_pool"] = net
                  else:
                      # Pooling with a fixed kernel size.
                      net = slim.avg_pool2d(
                          net, [7, 7], stride=1, scope="AvgPool_0a_7x7"
                      )
                      end_points["AvgPool_0a_7x7"] = net
                  if not num_classes:
                      return net, end_points
                  net = slim.dropout(
                      net, dropout_keep_prob, scope="Dropout_0b"
                  )
                  logits = slim.conv2d(
                      net,
                      num_classes,
                      [1, 1],
                      activation_fn=None,
                      normalizer_fn=None,
                      scope="Conv2d_0c_1x1",
                  )
                  if spatial_squeeze:
                      logits = tf.squeeze(
                          logits, [1, 2], name="SpatialSqueeze"
                      )
  
                  end_points["Logits"] = logits
                  end_points["Predictions"] = prediction_fn(
                      logits, scope="Predictions"
                  )
      return logits, end_points
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import tensorflow
  from nets import inception_utils
label_desc: Use image node_id 2 for calling a global function with example usage: inception_v1(inputs, num_classes, is_training, dropout_keep_prob, prediction_fn, spatial_squeeze, reuse, scope, global_pool) and returns: logits,  end_points, net,  end_points