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
code: def __init__(
      self,
      n_epochs=1500,
      batch_size=64,
      kernel_size=40,
      n_filters=32,
      use_residual=True,
      use_bottleneck=True,
      bottleneck_size=32,
      depth=6,
      callbacks=None,
      random_state=None,
      verbose=False,
      loss="categorical_crossentropy",
      metrics=None,
  ):
      _check_dl_dependencies(severity="error")
      super().__init__()
  
      self.verbose = verbose
  
      # predefined
      self.batch_size = batch_size
      self.bottleneck_size = bottleneck_size
      self.callbacks = callbacks
      self.depth = depth
      self.kernel_size = kernel_size
      self.loss = loss
      self.metrics = metrics
      self.n_epochs = n_epochs
      self.n_filters = n_filters
      self.random_state = random_state
      self.use_bottleneck = use_bottleneck
      self.use_residual = use_residual
      self.verbose = verbose
      self._is_fitted = False
  
      network_params = {
          "n_filters": n_filters,
          "use_residual": use_residual,
          "use_bottleneck": use_bottleneck,
          "bottleneck_size": bottleneck_size,
          "depth": depth,
          "kernel_size": kernel_size,
          "random_state": random_state,
      }
  
      self._network = InceptionTimeNetwork(**network_params)
  
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 1 to create a new InceptionTimeClassifier object from inherited base classes: BaseDeepClassifier with example: obj = InceptionTimeClassifier(n_epochs, batch_size, kernel_size, n_filters, use_residual, use_bottleneck, bottleneck_size, depth, callbacks, random_state, verbose, loss, metrics)