Tensorflow importing custom layers, runs training of custom model

My use case is the following: I am creating a dimensionality reducing AutoEncoder with Tensorflow. I have implemented three custom layers and with that a model

class ConvLayer(Layer):       
 def __init__(self, filter, kernel, act, **kwargs):
    super().__init__()
    self.filter = filter
    self.kernel = kernel
    self.act = act
    super(ConvLayer, self).__init__(**kwargs)    

 def build(self, input_shape):
      self.conv = Conv1D(self.filter, self.kernel, padding='same')
      self.norm = BatchNormalization()
      self.acti = Activation(self.act)

 def get_config(self):
    config = super(ConvLayer, self).get_config()
    config.update({
        "filter": self.filter,
        "kernel": self.kernel,
        "act"   : self.act
    })
    return config


  def call(self, inputs):
      x = self.conv(inputs)
      x = self.norm(x)
      return self.acti(x)

class _Conv1DTranspose(Layer):   
  def __init__(self,  filter, kernel, **kwargs):
    super().__init__()
    self.filter = filter
    self.kernel = kernel
    super(_Conv1DTranspose, self).__init__(**kwargs)

  def build(self, input_shape):
    self.first  = Lambda(lambda x: K.expand_dims(x, axis=2))
    self.conv   = Conv2DTranspose(self.filter, (self.kernel, 1), padding='same')
    self.second = Lambda(lambda x: K.squeeze(x, axis=2))
  
  def get_config(self):
    config = super(_Conv1DTranspose, self).get_config()
    config.update({
        "filter": self.filter,
        "kernel": self.kernel
    })
    return config

  def call(self, inputs):
    x = self.first(inputs)
    x = self.conv(x)
    return self.second(x)

class DeconvLayer(Layer):   
   def __init__(self, filter, kernel, act, **kwargs):
      super().__init__()

      self.filter = filter
      self.kernel = kernel
      self.act = act

      super(DeconvLayer, self).__init__(**kwargs)

  def build(self, input_shape):
    self.conv = _Conv1DTranspose(self.filter, self.kernel)
    self.norm = BatchNormalization()
    self.acti = Activation(self.act)

  def get_config(self):
      config = super(DeconvLayer, self).get_config()
      config.update({
          "filter": self.filter,
          "kernel": self.kernel,
          "act"   : self.act
      })
      return config

  def call(self, inputs):
    x = self.conv(inputs)
    x = self.norm(x)
    return self.acti(x)

def create_model(latent_dim):       
   encoder = Sequential([   
      ConvLayer(128, 2, 'selu'),   
      ConvLayer(128, 2, 'selu'),   
      ConvLayer(128, 2, 'selu'),   
      ConvLayer(128, 2, 'selu'),  
      MaxPooling1D(5),   
      ConvLayer(64, 2, 'selu'),   
      ConvLayer(64, 2, 'selu'),   
      ConvLayer(64, 2, 'selu'),   
      ConvLayer(64, 2, 'selu'),   
      MaxPooling1D(2),   
      ConvLayer(32, 2, 'selu'),   
      ConvLayer(32, 2, 'selu'),   
      ConvLayer(32, 2, 'selu'),   
      ConvLayer(32, 2, 'selu'),   
      MaxPooling1D(2),   
      Flatten(),   
      Dense(latent_dim, activation='selu') ], name='Encoder') 

  decoder = Sequential([
    Dense((latent_dim * 32), activation='selu'),
    Reshape((50, 32)),
    UpSampling1D(2),
    DeconvLayer(32, 2, 'selu'),
    DeconvLayer(32, 2, 'selu'),
    DeconvLayer(32, 2, 'selu'),
    DeconvLayer(32, 2, 'selu'),
    UpSampling1D(2),
    DeconvLayer(64, 2, 'selu'),
    DeconvLayer(64, 2, 'selu'),
    DeconvLayer(64, 2, 'selu'),
    DeconvLayer(64, 2, 'selu'),
    UpSampling1D(5),
    DeconvLayer(128, 2, 'selu'),
    DeconvLayer(128, 2, 'selu'),
    DeconvLayer(128, 2, 'selu'),
    DeconvLayer(128, 2, 'selu'),
    DeconvLayer(1, 2, 'sigmoid')   ], name='Decoder')

  return encoder, decoder

I am training and saving the encoder part in a separate file, autoencoder.py, with encoder.save("encoder_dim_50.h5") Now in my main.py I want to load in my model and use it to reduce some dimensions.

Here starts my issue, I am importing the custom layers from autoencoder import _Conv1DTranspose, ConvLayer, DeconvLayer and while importing, it start to run the whole training sequence again?!

The code does not even reach the loading of the model

self.Encoder = tf.keras.models.load_model(model_path, custom_objects={'_Conv1DTranspose': _Conv1DTranspose,
                                                                              'ConvLayer'       : ConvLayer,
                                                                              'DeconvLayer'     : DeconvLayer})

Am I missing some glaring issue here, or should I implement my custom layers in the main.py as well?

Thank you for your time

>Solution :

To stop your code from automatically running, convert your code in the following format, it always prevents the code from auto running.

def __main__(): 
   #do whatever you want in this function as this will run if you run this file directly
   print('hello world')

if __name__ == "__main__" 
   __main__() 

This way, your code should never run on its own and you can use your function the way you want.