class_docstr: Simple recurrent neural network.
  
  Parameters
  ----------
  n_epochs : int, default = 100
      the number of epochs to train the model
  batch_size : int, default = 1
      the number of samples per gradient update.
  units : int, default = 6
      number of units in the network
  callbacks : list of tf.keras.callbacks.Callback objects, default = None
  add_default_callback : bool, default = True
      whether to add default callback
  random_state : int or None, default=0
      Seed for random number generation.
  verbose : boolean, default = False
      whether to output extra information
  loss : string, default="mean_squared_error"
      fit parameter for the keras model
  metrics : list of strings, default=["accuracy"]
      metrics to use in fitting the neural network
  activation : string or a tf callable, default="sigmoid"
      Activation function used in the output layer.
      List of available activation functions: https://keras.io/api/layers/activations/
  use_bias : boolean, default = True
      whether the layer uses a bias vector.
  optimizer : keras.optimizers object, default = RMSprop(lr=0.001)
      specify the optimizer and the learning rate to be used.
  
  References
  ----------
  ..[1] benchmark forecaster in M4 forecasting competition:
  https://github.com/Mcompetitions/M4-methods
docstr: Fit the classifier on the training set (X, y).
  
  Parameters
  ----------
  X : a nested pd.Dataframe, or (if input_checks=False) array-like of
  shape = (n_instances, series_length, n_dimensions)
      The training input samples. If a 2D array-like is passed,
      n_dimensions is assumed to be 1.
  y : array-like, shape = [n_instances]
      The training data class labels.
  
  Returns
  -------
  self : object
code: def _fit(self, X, y):
      """Fit the classifier on the training set (X, y).
  
      Parameters
      ----------
      X : a nested pd.Dataframe, or (if input_checks=False) array-like of
      shape = (n_instances, series_length, n_dimensions)
          The training input samples. If a 2D array-like is passed,
          n_dimensions is assumed to be 1.
      y : array-like, shape = [n_instances]
          The training data class labels.
  
      Returns
      -------
      self : object
      """
      from tensorflow import keras
  
      y_onehot = self.convert_y_to_keras(y)
      X = X.transpose(0, 2, 1)
  
      check_random_state(self.random_state)
      self.input_shape = X.shape[1:]
  
      self.model_ = self.build_model(self.input_shape, self.n_classes_)
  
      if self.verbose:
          self.model_.summary()
  
      # add a ReduceLROnPlateau callback is default is enabled
      # if an instance of ReduceLROnPlateau is already present
      # then don't add it again.
      if self.add_default_callback:
          reduce_lr = keras.callbacks.ReduceLROnPlateau(
              monitor="loss",
              factor=0.5,
              patience=50,
              min_lr=0.0001,
          )
          if self.callbacks is None:
              self.callbacks_ = [
                  reduce_lr,
              ]
          elif isinstance(self.callbacks, keras.callbacks.Callback):
              self.callbacks_ = [
                  self.callbacks,
                  reduce_lr,
              ]
          elif isinstance(self.callbacks, tuple):
              self.callbacks_ = deepcopy([i for i in self.callbacks])
              if not any(
                  isinstance(
                      callback, keras.callbacks.ReduceLROnPlateau
                  )
                  for callback in self.callbacks
              ):
                  self.callbacks_.append(reduce_lr)
          else:
              raise TypeError(
                  "`callback` can either be None, an instance "
                  "of keras.callbacks.Callback or a tuple containing "
                  "keras.callbacks.Callback objects. "
                  f"But found {type(self.callbacks)} instead."
              )
      else:
          self.callbacks_ = deepcopy(self.callbacks)
  
      self.history = self.model_.fit(
          X,
          y_onehot,
          batch_size=self.batch_size,
          epochs=self._n_epochs,
          verbose=self.verbose,
          callbacks=self.callbacks_,
      )
      return self
  
file_path: sktime/sktime/classification/deep_learning/rnn.py
imports: from copy import deepcopy
  from sklearn.utils import check_random_state
  from sktime.classification.deep_learning.base import BaseDeepClassifier
  from sktime.networks.rnn import RNNNetwork
  from sktime.utils.validation._dependencies import _check_dl_dependencies
  from sktime.utils.warnings import warn
label_desc: Use image node_id 3 for calling the SimpleRNNClassifier obj's underlying member method code with example usage: obj._fit(X, y) and returns: self