docs: def fit_mle(self,
                  init_vals,
                  print_res=True,
                  method="BFGS",
                  loss_tol=1e-06,
                  gradient_tol=1e-06,
                  maxiter=1000,
                  ridge=None,
                  constrained_pos=None,
                  just_point=False,
                  **kwargs):
          """
          Parameters
          ----------
          init_vals : 1D ndarray.
              The initial values to start the optimization process with. There
              should be one value for each utility coefficient being estimated.
          print_res : bool, optional.
              Determines whether the timing and initial and final log likelihood
              results will be printed as they they are determined.
          method : str, optional.
              Should be a valid string that can be passed to
              scipy.optimize.minimize. Determines the optimization algorithm that
              is used for this problem. If 'em' is passed, a custom coded EM
              algorithm will be used. Default `== 'newton-cg'`.
          loss_tol : float, optional.
              Determines the tolerance on the difference in objective function
              values from one iteration to the next that is needed to determine
              convergence. Default `== 1e-06`.
          gradient_tol : float, optional.
              Determines the tolerance on the difference in gradient values from
              one iteration to the next which is needed to determine convergence.
          ridge : int, float, long, or None, optional.
              Determines whether or not ridge regression is performed. If a
              scalar is passed, then that scalar determines the ridge penalty for
              the optimization. Default `== None`.
          constrained_pos : list or None, optional.
              Denotes the positions of the array of estimated parameters that are
              not to change from their initial values. If a list is passed, the
              elements are to be integers where no such integer is greater than
              `init_vals.size.` Default == None.
          just_point : bool, optional.
              Determines whether (True) or not (False) calculations that are non-
              critical for obtaining the maximum likelihood point estimate will
              be performed. If True, this function will return the results
              dictionary from scipy.optimize. Default == False.
  
          Returns
          -------
          None or dict.
              If `just_point` is False, None is returned and the estimation
              results are saved to the model instance. If `just_point` is True,
              then the results dictionary from scipy.optimize() is returned.
          """
          # Check integrity of passed arguments
          kwargs_to_be_ignored = ["init_shapes", "init_intercepts", "init_coefs"]
          if any([x in kwargs for x in kwargs_to_be_ignored]):
              msg = "MNL model does not use of any of the following kwargs:\n{}"
              msg_2 = "Remove such kwargs and pass a single init_vals argument"
              raise ValueError(msg.format(kwargs_to_be_ignored) + msg_2)
  
          if ridge is not None:
              warnings.warn(_ridge_warning_msg)
  
          # Store the optimization method
          self.optimization_method = method
  
          # Store the ridge parameter
          self.ridge_param = ridge
  
          # Construct the mappings from alternatives to observations and from
          # chosen alternatives to observations
          mapping_res = self.get_mappings_for_fit()
  
          # Create the estimation object
          zero_vector = np.zeros(init_vals.shape)
          mnl_estimator = MNLEstimator(self,
                                       mapping_res,
                                       ridge,
                                       zero_vector,
                                       split_param_vec,
                                       constrained_pos=constrained_pos)
          # Set the derivative functions for estimation
          mnl_estimator.set_derivatives()
  
          # Perform one final check on the length of the initial values
          mnl_estimator.check_length_of_initial_values(init_vals)
  
          # Get the estimation results
          estimation_res = estimate(init_vals,
                                    mnl_estimator,
                                    method,
                                    loss_tol,
                                    gradient_tol,
                                    maxiter,
                                    print_res,
                                    just_point=just_point)
  
          if not just_point:
              # Store the estimation results
              self.store_fit_results(estimation_res)
  
              return None
          else:
              return estimation_res