class_docstr: Logistic regression classifier.
  
  Note that this implementation of Logistic Regression
  expects binary class labels in {0, 1}.
  
  Parameters
  ------------
  eta : float (default: 0.01)
      Learning rate (between 0.0 and 1.0)
  
  epochs : int (default: 50)
      Passes over the training dataset.
      Prior to each epoch, the dataset is shuffled
      if `minibatches > 1` to prevent cycles in stochastic gradient descent.
  
  l2_lambda : float
      Regularization parameter for L2 regularization.
      No regularization if l2_lambda=0.0.
  
  minibatches : int (default: 1)
      The number of minibatches for gradient-based optimization.
      If 1: Gradient Descent learning
      If len(y): Stochastic Gradient Descent (SGD) online learning
      If 1 < minibatches < len(y): SGD Minibatch learning
  
  random_seed : int (default: None)
      Set random state for shuffling and initializing the weights.
  
  print_progress : int (default: 0)
      Prints progress in fitting to stderr.
      0: No output
      1: Epochs elapsed and cost
      2: 1 plus time elapsed
      3: 2 plus estimated time until completion
  
  Attributes
  -----------
  w_ : 2d-array, shape={n_features, 1}
    Model weights after fitting.
  
  b_ : 1d-array, shape={1,}
    Bias unit after fitting.
  
  cost_ : list
      List of floats with cross_entropy cost (sgd or gd) for every
      epoch.
  
  Examples
  -----------
  For usage examples, please see
  https://rasbt.github.io/mlxtend/user_guide/classifier/LogisticRegression/
code: def _fit(self, X, y, init_params=True):
      self._check_target_array(y, allowed={(0, 1)})
  
      if init_params:
          self.b_, self.w_ = self._init_params(
              weights_shape=(X.shape[1], 1),
              bias_shape=(1,),
              random_seed=self.random_seed,
          )
          self.cost_ = []
  
      self.init_time_ = time()
      rgen = np.random.RandomState(self.random_seed)
      for i in range(self.epochs):
          for idx in self._yield_minibatches_idx(
              rgen=rgen,
              n_batches=self.minibatches,
              data_ary=y,
              shuffle=True,
          ):
              y_val = self._forward(X[idx])
              grad_loss_wrt_w, grad_loss_wrt_b = self._backward(
                  X[idx], y_true=y[idx], y_probas=y_val
              )
  
              l2_reg = self.l2_lambda * self.w_
              self.w_ += self.eta * (-grad_loss_wrt_w - l2_reg)
              self.b_ += self.eta * -grad_loss_wrt_b.sum()
  
          cost = self._logit_cost(y, self._forward(X))
          self.cost_.append(cost)
          if self.print_progress:
              self._print_progress(
                  iteration=(i + 1), n_iter=self.epochs, cost=cost
              )
      return self
  
file_path: mlxtend/mlxtend/classifier/logistic_regression.py
imports: from time import time
  import numpy
  from .._base import _BaseModel, _Classifier, _IterativeModel
label_desc: Use image node_id 4 for calling the LogisticRegression obj's underlying member method code with example usage: obj._fit(X, y, init_params) and returns: self