docs: def calc_log_likes_for_replicates(self,
                                        replicates='bootstrap',
                                        num_draws=None,
                                        seed=None):
          """
          Calculate the log-likelihood value of one's replicates, given one's
          dataset.
  
          Parameters
          ----------
          replicates : str in {'bootstrap', 'jackknife'}.
              Denotes which set of replicates should have their log-likelihoods
              calculated.
          num_draws : int greater than zero or None, optional.
              Denotes the number of random draws for mixed logit estimation. If
              None, then no random draws will be made. Default == None.
          seed : int greater than zero or None, optional.
              Denotes the random seed to be used for mixed logit estimation.
              If None, then no random seed will be set. Default == None.
  
          Returns
          -------
          log_likelihoods : 1D ndarray.
              Each element stores the log-likelihood of the associated parameter
              values on the model object's dataset. The log-likelihoods are also
              stored on the `replicates + '_log_likelihoods'` attribute.
          """
          # Check the validity of the kwargs
          ensure_replicates_kwarg_validity(replicates)
  
          # Get the desired type of replicates
          replicate_vec = getattr(self, replicates + "_replicates").values
  
          # Determine the choice column
          choice_col = self.model_obj.choice_col
  
          # Split the control flow based on whether we're using a Nested Logit
          current_model_type = self.model_obj.model_type
          non_2d_predictions =\
              [model_type_to_display_name["Nested Logit"],
               model_type_to_display_name["Mixed Logit"]]
          if current_model_type not in non_2d_predictions:
              # Get the param list for this set of replicates
              param_list =\
                  get_param_list_for_prediction(self.model_obj, replicate_vec)
  
              # Get the 'chosen_probs' using the desired set of replicates
              chosen_probs =\
                  self.model_obj.predict(self.model_obj.data,
                                         param_list=param_list,
                                         return_long_probs=False,
                                         choice_col=choice_col)
          else:
              # Initialize a list of chosen probs
              chosen_probs_list = []
  
              # Create an iterable for iteration
              iterable_for_iteration = PROGRESS(xrange(replicate_vec.shape[0]),
                                                desc="Calculate Gradient Norms",
                                                total=replicate_vec.shape[0])
  
              # Populate the list of chosen probabilities for each vector of
              # parameter values
              for idx in iterable_for_iteration:
                  # Get the param list for this set of replicates
                  param_list =\
                      get_param_list_for_prediction(self.model_obj,
                                                    replicate_vec[idx][None, :])
                  # Use 1D parameters in the prediction function
                  param_list =\
                      [x.ravel() if x is not None else x for x in param_list]
  
                  # Get the 'chosen_probs' using the desired set of replicates
                  chosen_probs =\
                      self.model_obj.predict(self.model_obj.data,
                                             param_list=param_list,
                                             return_long_probs=False,
                                             choice_col=choice_col,
                                             num_draws=num_draws,
                                             seed=seed)
  
                  # store those chosen prob_results
                  chosen_probs_list.append(chosen_probs[:, None])
  
              # Get the final array of chosen probs
              chosen_probs = np.concatenate(chosen_probs_list, axis=1)
  
          # Calculate the log_likelihood
          log_likelihoods = np.log(chosen_probs).sum(axis=0)
  
          # Store the log-likelihood values
          attribute_name = replicates + "_log_likelihoods"
          log_like_series = pd.Series(log_likelihoods, name=attribute_name)
          setattr(self, attribute_name, log_like_series)
          return log_likelihoods