docs: def calc_gradient_norm_for_replicates(self,
                                            replicates='bootstrap',
                                            ridge=None,
                                            constrained_pos=None,
                                            weights=None):
          """
          Calculate the Euclidean-norm of the gradient 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.
          ridge : float or None, optional.
              Denotes the ridge penalty used when estimating the replicates, and
              to be used when calculating the gradient. If None, no ridge penalty
              is used. 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
              `self.mle_params` Default == None.
          weights : 1D ndarray or None, optional.
              Allows for the calculation of weighted log-likelihoods. The weights
              can represent various things. In stratified samples, the weights
              may be the proportion of the observations in a given strata for a
              sample in relation to the proportion of observations in that strata
              in the population. In latent class models, the weights may be the
              probability of being a particular class.
  
          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)
          # Create the estimation object
          estimation_obj =\
              create_estimation_obj(self.model_obj,
                                    self.mle_params.values,
                                    ridge=ridge,
                                    constrained_pos=constrained_pos,
                                    weights=weights)
          # Prepare the estimation object to calculate the gradients
          if hasattr(estimation_obj, "set_derivatives"):
              estimation_obj.set_derivatives()
          # Get the array of parameter replicates
          replicate_array = getattr(self, replicates + "_replicates").values
          # Determine the number of replicates
          num_reps = replicate_array.shape[0]
          # Initialize an empty array to store the gradient norms
          gradient_norms = np.empty((num_reps,), dtype=float)
  
          # Create an iterable for iteration
          iterable_for_iteration = PROGRESS(xrange(num_reps),
                                            desc="Calculating Gradient Norms",
                                            total=num_reps)
  
          # Iterate through the rows of the replicates and calculate and store
          # the gradient norm for each replicated parameter vector.
          for row in iterable_for_iteration:
              current_params = replicate_array[row]
              gradient = estimation_obj.convenience_calc_gradient(current_params)
              gradient_norms[row] = np.linalg.norm(gradient)
          return gradient_norms