code: def fit(self, X, y):
          
          X, event_num, time = self._pre_fit(X, y)
          create_path, alphas, penalty = self._check_params(X.shape[1])
  
          coef, alphas, deviance_ratio, n_iter = call_fit_coxnet(
              X, time, event_num, penalty, alphas, create_path,
              self.alpha_min_ratio, self.l1_ratio, int(self.max_iter),
              self.tol, self.verbose)
          assert numpy.isfinite(coef).all()
  
          if numpy.all(numpy.absolute(coef) < numpy.finfo(numpy.float).eps):
              warnings.warn('all coefficients are zero, consider decreasing alpha.',
                            stacklevel=2)
  
          if n_iter >= self.max_iter:
              warnings.warn('Optimization terminated early, you might want'
                            ' to increase the number of iterations (max_iter=%d).'
                            % self.max_iter,
                            category=ConvergenceWarning,
                            stacklevel=2)
  
          if self.fit_baseline_model:
              self._baseline_models = tuple(
                  BreslowEstimator().fit(numpy.dot(X, coef[:, i]), event_num, time)
                  for i in range(coef.shape[1])
              )
          else:
              self._baseline_models = None
  
          self.alphas_ = alphas
          self.penalty_factor_ = penalty
          self.coef_ = coef
          self.deviance_ratio_ = deviance_ratio
          return self
docs: Fit estimator.
  
          Parameters
          ----------
          X : array-like, shape = (n_samples, n_features)
              Data matrix
  
          y : structured array, shape = (n_samples,)
              A structured array containing the binary event indicator
              as first field, and time of event or time of censoring as
              second field.
  
          Returns
          -------
          self