docs: def train_local(self, closest_point, label_vector_description=None, N=None,
          pivot=True, **kwargs):
          """
          Train the model in a Cannon-like fashion using the grid points as labels
          and the intensities as normalsied rest-frame fluxes within some local
          regime.
          """
  
          lv = self._cannon_label_vector if label_vector_description is None else\
              self._interpret_label_vector(label_vector_description)
  
          # By default we will train to the nearest 10% of the grid.
          # If grid subset is a fraction, scale it to real numbers.
          if N is None:
              N = self._configuration.get("settings", {}).get("grid_subset",
                  0.10)
              if 1 >= N > 0:
                  N = int(np.round(N * self.grid_points.size))
  
          logger.debug("Using {} nearest points for local Cannon model".format(N))
  
          # Use closest N points.
          dtype = [(name, '<f8') for name in self.grid_points.dtype.names]
          grid_points \
              = self.grid_points.astype(dtype).view(float).reshape(-1, len(dtype))
  
          distance = np.sum(np.abs(grid_points - np.array(closest_point))/
              np.ptp(grid_points, axis=0), axis=1)
          grid_indices = np.argsort(distance)[:N]
          
          lv_array, _, offsets = _build_label_vector_array(
              self.grid_points[grid_indices], lv, pivot=pivot)
          return self._train(lv_array, grid_indices, offsets, lv, **kwargs)