class_docstr: InceptionTime Deep Learning Classifier.
  
  Parameters
  ----------
  n_epochs : int, default=1500
  batch_size : int, default=64
      the number of samples per gradient update
  kernel_size : int, default=40
      specifying the length of the 1D convolution window
  n_filters : int, default=32
  use_residual : boolean, default=True
  use_bottleneck : boolean, default=True
  bottleneck_size : int, default=32
  depth : int, default=6
  callbacks : list of tf.keras.callbacks.Callback objects
  random_state: int, optional, default=None
      random seed for internal random number generator
  verbose: boolean, default=False
      whether to print runtime information
  loss: str, default="categorical_crossentropy"
  metrics: optional
  
  Notes
  -----
  ..[1] Fawaz et. al, InceptionTime: Finding AlexNet for Time Series
  Classification, Data Mining and Knowledge Discovery, 34, 2020
  
  Adapted from the implementation from Fawaz et. al
  https://github.com/hfawaz/InceptionTime/blob/master/classifiers/inception.py
docstr: Construct a compiled, un-trained, keras model that is ready for training.
  
  Parameters
  ----------
  input_shape : tuple
      The shape of the data fed into the input layer
  n_classes: int
      The number of classes, which shall become the size of the output
       layer
  
  Returns
  -------
  output : a compiled Keras Model
code: def build_model(self, input_shape, n_classes, **kwargs):
      """Construct a compiled, un-trained, keras model that is ready for training.
  
      Parameters
      ----------
      input_shape : tuple
          The shape of the data fed into the input layer
      n_classes: int
          The number of classes, which shall become the size of the output
           layer
  
      Returns
      -------
      output : a compiled Keras Model
      """
      from tensorflow import keras
  
      input_layer, output_layer = self._network.build_network(
          input_shape, **kwargs
      )
  
      output_layer = keras.layers.Dense(
          n_classes, activation="softmax"
      )(output_layer)
  
      model = keras.models.Model(
          inputs=input_layer, outputs=output_layer
      )
  
      # if user hasn't provided own metrics use accuracy
      if self.metrics is None:
          metrics = ["accuracy"]
      else:
          metrics = self.metrics
  
      model.compile(
          loss=self.loss,
          optimizer=keras.optimizers.Adam(),
          metrics=metrics,
      )
  
      return model
  
file_path: sktime/sktime/classification/deep_learning/inceptiontime.py
imports: from copy import deepcopy
  from sklearn.utils import check_random_state
  from sktime.classification.deep_learning.base import BaseDeepClassifier
  from sktime.networks.inceptiontime import InceptionTimeNetwork
  from sktime.utils.validation._dependencies import _check_dl_dependencies
label_desc: Use image node_id 2 for calling the InceptionTimeClassifier obj's underlying member method code with example usage: obj.build_model(input_shape, n_classes) and returns: model