code: def get_errors(self, x, t):
      # back propogate the loc and conf losses
      if getattr(self, "loc_deltas", None) is None:
          self.loc_deltas = np.zeros((self.be.bsz, self.num_priors, 4))
      else:
          self.loc_deltas[:] = 0.0
  
      if getattr(self, "conf_deltas", None) is None:
          self.conf_deltas = np.zeros(
              (self.be.bsz, self.num_priors, self.num_classes)
          )
      else:
          self.conf_deltas[:] = 0.0
  
      loc_deltas = self.loc_deltas
      conf_deltas = self.conf_deltas
  
      num_matches = self.num_matches
      matches = self.matches
  
      if num_matches > 0:
          # backprop the smooth L1 loss first
          loc_diff = (
              self.loc_diff_data
          )  # this is the errors calculated above
          loc_diff[self.inds_more] = np.sign(loc_diff[self.inds_more])
  
          # backprop the loc loss
          # sclae the loc_predictions by num_matches
          loc_diff /= float(num_matches)
  
          count = 0
          for batch, match in enumerate(matches):
              match_inds = match["inds"]
              # load up the errors to the proper prior box location
              # in the loc network outputs matches the diffs up with
              # the correct location in loc_deltas which is the full
              # length of all the location predictions concated together
              inds_ = np.where(match_inds > -1)[0]
              loc_deltas[batch, inds_, :] = loc_diff[
                  range(count, count + len(inds_)), :
              ]
              count += len(inds_)
      else:
          loc_deltas[:] = 0.0
  
      # first bprop the softmax
      conf_diff = (
          self.probs.copy()
      )  # may not need copy, could do in place?
      for ind in range(len(self.labels)):
          conf_diff[ind, self.labels[ind]] -= 1.0
  
      conf_diff /= float(self.num_matches)
  
      count = 0
      for batch, match in enumerate(matches):
          match_inds = match["inds"]
          inds_ = np.where(match_inds > -1)[0]
          self.conf_deltas[batch, :, :] = 0.0
          self.conf_deltas[batch, inds_, :] = conf_diff[
              range(count, count + len(inds_)), :
          ]
          count += len(inds_)
  
          inds_ = self.all_neg_inds[batch]
          assert np.all(inds_ < self.num_priors)
          self.conf_deltas[batch, inds_, :] = conf_diff[
              range(count, count + len(inds_)), :
          ]
          count += len(inds_)
  
      # for now, to match rest of the network, transpose from (N, K, 4) to (K4, N)
      # and load onto device
      loc_deltas = np.ascontiguousarray(
          self.loc_deltas.reshape((self.be.bsz, -1)).transpose((1, 0))
      )
      conf_deltas = np.ascontiguousarray(
          self.conf_deltas.reshape((self.be.bsz, -1)).transpose((1, 0))
      )
      if self.conf_deltas_dev is None:
          self.conf_deltas_dev = self.be.array(conf_deltas)
      else:
          self.conf_deltas_dev.set(conf_deltas)
  
      if self.loc_deltas_dev is None:
          self.loc_deltas_dev = self.be.array(loc_deltas)
      else:
          self.loc_deltas_dev.set(loc_deltas)
  
      return (self.loc_deltas_dev, self.conf_deltas_dev)
  
imports: from neon import NervanaObject
  import numpy
  from util import util
  from neon.transforms import Softmax
label_desc: Use image node_id 4 for calling the MBoxLoss obj's underlying member method code with example usage: obj.get_errors(x, t) and returns: self,  self