Breaking News: Grepper is joining You.com. Read the official announcement!

googlenet keras implementation

VVY answered on March 31, 2023 Popularity 5/10 Helpfulness 6/10

answer googlenet keras implementation

googlenet keras implementation

Comment

import tensorflow as tf
keras = tf.keras
from functools import partial

class GoogleNet(keras.Model):
  """ return => main_output, aux_output2, aux_output1 """

  ###################################### Inception Code Starts from here ##############################################
  class Inception(keras.layers.Layer):
    """ input: inception_layer => [1,2,3,4,5,6,7,8,9] """
    def __init__(self, inception_layer):
      super().__init__()
      self.layer = inception_layer
      arr = [
          [96, 16, 64, 128, 32, 32],
          [128, 32, 128, 192, 96, 64],
          [96, 16, 192, 208, 48, 64],
          [112, 24, 160, 224, 64, 64],
          [128, 24, 128, 256, 64, 64],
          [144, 32, 112, 288, 64, 64],
          [160, 32, 256, 320, 128, 128],
          [160, 32, 256, 320, 128, 128],
          [192, 48, 384, 384, 128, 128]
          ]
      self.conv1 = keras.layers.Conv2D(filters=arr[self.layer-1][1-1], kernel_size=1, activation="relu")
      self.conv2 = keras.layers.Conv2D(arr[self.layer-1][2-1], 1, activation="relu")
      self.conv3 = keras.layers.Conv2D(arr[self.layer-1][3-1], 1, activation="relu")
      self.conv4 = keras.layers.Conv2D(arr[self.layer-1][4-1], 3, activation="relu")
      self.conv5 = keras.layers.Conv2D(arr[self.layer-1][5-1], 5, activation="relu")
      self.conv6 = keras.layers.Conv2D(arr[self.layer-1][6-1], 1, activation="relu")

      self.maxpool = keras.layers.MaxPool2D(pool_size=3, strides=2)
      self.cancat = keras.layers.Concatenate(axis=3) # concat through depth

    def call(self, inputs):
      x1 = self.conv1(inputs)
      x2 = self.conv2(inputs)
      x3 = self.conv3(inputs)
      x4 = self.maxpool(inputs)
      # x1 --> conv4, x2 --> conv5, x3 --> concat_final, x4 --> conv6
      y1 = self.conv4(x1)
      y2 = self.conv5(x2)
      y3 = self.conv6(x4)
      # concat x3, y1, y2, y3
      concat = self.concat([x3, y1, y2, y3])
      return concat
  ############################################Inception Code Ends here#######################################################    

  ###################################### Auxilary_layer Code Starts from here ##############################################
  class Auxilary_layer(keras.layers.Layer):
    """Only while Training """
    def __init__(self):
      super().__init__()
      self.avg_pool = keras.layers.AveragePooling2D(pool_size=5, strides=3)
      self.conv = keras.layers.Conv2D(filters=128, kernel_size=1, padding="same", activation="relu")
      self.dense1 = keras.layers.Dense(1024, activation="relu")
      self.dropout = keras.layers.Dropout(0.7)
      self.dense2 = keras.layers.Dense(1000, activation="softmax")

    def call(self, inputs, training=True):
      x = self.avg_pool(inputs)
      x = self.conv(x)
      x = self.dropout(self.dense1(x))
      x = self.dense2(x)
      return x
  ######################################### Auxilary_layer Code Ends here###################################################    

  ######################################### GoogleNet Code starts from here ##################################################
  def __init__(self):
    super().__init__()
    self.conv_sz7 = keras.layers.Conv2D(filters=64, kernel_size=7, strides=2, padding="same", activation="relu")
    self.maxpool = keras.layers.MaxPool2D(pool_size=3, padding="same", strides=2)
    self.lrn = keras.layers.Lambda(tf.nn.local_response_normalization)
    self.conv_sz1 = keras.layers.Conv2D(filters=64, kernel_size=1, activation="relu") # padding="valid"
    self.conv_sz3 = keras.layers.Conv2D(filters=192, kernel_size=3, padding="same", activation="relu")

    self.inception = partial(self.Inception(inception_layer=1))
    self.auxlayer = self.Auxilary_layer()

    self.avg_pool = keras.layers.AveragePooling2D(pool_size=7, strides=1)
    self.dropout = keras.layers.Dropout(0.4)
    self.dense = keras.layers.Dense(1000, activation="softmax") 

  def call(self, inputs):
    x = self.conv_sz7(inputs)
    x = self.maxpool(x)
    x = self.lrn(x)
    x = self.conv_sz1(x)
    x = self.conv_sz3(x)
    x = self.lrn(x)
    x = self.maxpool(x)
    for i in range(1,2+1):
      x = self.inception(inception_layer=i)(x)
    x = self.maxpool(x)
    x1 = self.inception(inception_layer=3)(x)
    aux_output1 = self.auxlayer(x1)
    x = self.inception(inception_layer=4)(x1)
    x = self.inception(inception_layer=5)(x)
    x2 = self.inception(inception_layer=6)(x)
    aux_output2 = self.auxlayer(x2)
    x = self.inception(inception_layer=7)(x2)
    x = self.maxpool(x)
    for i in range(8,9+1):
      x = self.inception(inception_layer=i)(x)
    x = self.dropout(self.avg_pool(x))
    main_output = self.dense(x)
    return main_output, aux_output2, aux_output1
  ########################################GoogleNet Code ends here ####################################################

Popularity 5/10 Helpfulness 6/10 Language python

Source: arxiv.org

Tags: implementation keras python

Link to this answer
Share Copy Link

Contributed on Mar 31 2023

VVY

0 Answers Avg Quality 2/10

googlenet keras implementation

Contents

More Related Answers

googlenet keras implementation

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.