docs: def fit(self,
              X,
              num_epochs=10,
              updates_epoch=None,
              stop_param_updates=dict(),
              batch_size=1,
              show_progressbar=False,
              show_epoch=False,
              refit=True):
          """
          Fit the learner to some data.
  
          Parameters
          ----------
          X : numpy array.
              The input data.
          num_epochs : int, optional, default 10
              The number of epochs to train for.
          updates_epoch : int, optional, default 10
              The number of updates to perform on the learning rate and
              neighborhood per epoch. 10 suffices for most problems.
          stop_param_updates : dict
              The epoch at which to stop updating each param. This means
              that the specified parameter will be reduced to 0 at the specified
              epoch.
          batch_size : int, optional, default 100
              The batch size to use. Warning: batching can change your
              performance dramatically, depending on the task.
          show_progressbar : bool, optional, default False
              Whether to show a progressbar during training.
          show_epoch : bool, optional, default False
              Whether to print the epoch number to stdout
  
          """
          if self.data_dimensionality is None:
              self.data_dimensionality = X.shape[-1]
              self.weights = np.zeros((self.num_neurons,
                                       self.data_dimensionality))
          X = self._check_input(X)
          if not self.trained or refit:
              X = self._init_weights(X)
          else:
              if self.scaler is not None:
                  self.weights = self.scaler.transform(self.weights)
  
          if updates_epoch is None:
              X_len = X.shape[0]
              updates_epoch = np.min([50, X_len // batch_size])
  
          constants = self._pre_train(stop_param_updates,
                                      num_epochs,
                                      updates_epoch)
          start = time.time()
          for epoch in tqdm(range(num_epochs), disable=not show_epoch):
              logger.info("Epoch {0} of {1}".format(epoch+1, num_epochs))
  
              self._epoch(X,
                          epoch,
                          batch_size,
                          updates_epoch,
                          constants,
                          show_progressbar)
  
          self.trained = True
          if self.scaler is not None:
              self.weights = self.scaler.inverse_transform(self.weights)
          logger.info("Total train time: {0}".format(time.time() - start))