class_docstr: _dlm includes all basic functions for building dlm model.
  
  Attributes:
      data: the observed time series data
      n: the length of the time series data
      result: the inner class that records the filtered and smoothed results
      builder: the @builder that is used for providing the modeling
      functionality. For details please refer to @builder
      Filter: the filter used for filtering time series data using the model.
              For details please refer to @kalmanFilter
      initialized: indicates whether the dynamic linear model has been
                   initialized
      options: model options, including initial guess of the observational
               variance.
               More is going to be added (plot options and shrinkage options)
      time: the time label, used for plotting
  
  
  Methods:
      _initialize: initialize the dlm (builder and kalmanFilter)
      _forwardFilter: run forward filter for a specific start and end date
      _backwardSmoother: run backward smooth for a specific start and end
                         date
      _predictInSample: predict the latent state and observation for a given
                        period of time (deprecated)
      _resetModelStatus: reset the model status to its prior status
      _setModelStatus: set the model status to a specific date
      _defaultOptions: a class to store and set default options
      _result: a class to store the results
      _copy: copy the result from the model to the _result class
      _reverseCopy: copy the result from the _result class to the model
      _checkFeatureSize: check whether the features's n matches the data's n
      _checkComponent: check whether a component is in dlm
      _checkPlotOptions: set the correct options according to the fit
      _checkAndGetWorkingDates: get the correct filtering dates
docstr: Backward smooth over filtered results for a specific start
      and number of days
  
  Args:
      start: the start date
      days: number of days to be smoothed starting from start towards
            zero
      ignoreFuture: indicate whether the smoothed should start as if the
                    future data was not observed or using the future data
                    as the initial smoothing status.
docstr_tok: ["Backward","smooth","over","filtered","results","for","a","specific","start","and","number","of","days","Args",":","start",":","the","start","date","days",":","number","of","days","to","be","smoothed","starting","from","start","towards","zero","ignoreFuture",":","indicate","whether","the","smoothed","should","start","as","if","the","future","data","was","not","observed","or","using","the","future","data","as","the","initial","smoothing","status","."]
code: def _backwardSmoother(
      self, start=None, days=None, ignoreFuture=False
  ):
      """Backward smooth over filtered results for a specific start
          and number of days
  
      Args:
          start: the start date
          days: number of days to be smoothed starting from start towards
                zero
          ignoreFuture: indicate whether the smoothed should start as if the
                        future data was not observed or using the future data
                        as the initial smoothing status.
      """
      # the default start date is the most recent date
      if start is None:
          start = self.n - 1
  
      # the default backward days number is the total length
      if days is None:
          end = 0
      else:
          end = max(start - days + 1, 0)
  
      # the forwardFilter has to be run before the smoother
      if self.result.filteredSteps[1] < start:
          raise valueError(
              "The last day has to be filtered before smoothing!"
              "check the <filteredSteps> in <result> object."
          )
  
      # and we record the most recent day which does not need to be smooth
      if start == self.n - 1 or ignoreFuture is True:
          self.result.smoothedState[start] = self.result.filteredState[
              start
          ]
          self.result.smoothedObs[start] = self.result.filteredObs[
              start
          ]
          self.result.smoothedCov[start] = self.result.filteredCov[
              start
          ]
          self.result.smoothedObsVar[
              start
          ] = self.result.filteredObsVar[start]
          self.builder.model.noiseVar = self.result.noiseVar[start]
          start -= 1
      else:
          self.builder.model.noiseVar = self.result.noiseVar[self.n - 1]
  
      # empty smoothing chain, return None
      if start < end:
          return None
  
      # insert the previous smoothed dates
      self.builder.model.state = self.result.smoothedState[start + 1]
      self.builder.model.sysVar = self.result.smoothedCov[start + 1]
  
      # we smooth the result sequantially from start - 1 to end
      dates = list(range(end, start + 1))
      dates.reverse()
      for day in dates:
          # we first update the model to be correct status before smooth
          self.builder.model.prediction.state = (
              self.result.predictedState[day + 1]
          )
          self.builder.model.prediction.sysVar = (
              self.result.predictedCov[day + 1]
          )
  
          if (
              len(self.builder.dynamicComponents) > 0
              or len(self.builder.automaticComponents) > 0
          ):
              self.builder.updateEvaluation(day, self.padded_data)
  
          # then we use the backward filter to filter the result
          self.Filter.backwardSmoother(
              model=self.builder.model,
              rawState=self.result.filteredState[day],
              rawSysVar=self.result.filteredCov[day],
          )
  
          # extract the result
          self._copy(
              model=self.builder.model,
              result=self.result,
              step=day,
              filterType="backwardSmoother",
          )
  
imports: from pydlm.base.kalmanFilter import kalmanFilter
  from pydlm.modeler.builder import builder
  from numpy import var
  import logging
label_desc: Use image node_id 6 for calling the _dlm obj's underlying member method code with example usage: obj._backwardSmoother(start, days, ignoreFuture) and returns: None