docs: def evaluate(self, reference_tag_list, estimated_tag_list=None, estimated_tag_probabilities=None):
          """Evaluate estimated against reference
  
          Parameters
          ----------
  
          reference_tag_list : list of dict or dcase_util.containers.MetaDataContainer
              Reference tag list
  
          estimated_tag_list : list of dict or dcase_util.containers.MetaDataContainer
              Estimated tag list
  
          estimated_tag_probabilities : list of dict or dcase_util.containers.ProbabilityContainer
              Estimated tag probabilities
  
          Returns
          -------
          self
  
          """
  
          if estimated_tag_list is None and estimated_tag_probabilities is None:
              raise ValueError("Nothing to evaluate, give at least estimated_tag_list or estimated_tag_probabilities")
  
          # Make sure reference_tag_list is dcase_util.containers.MetaDataContainer
          if not isinstance(reference_tag_list, dcase_util.containers.MetaDataContainer):
              reference_tag_list = dcase_util.containers.MetaDataContainer(reference_tag_list)
  
          # Make sure estimated_tag_list is dcase_util.containers.MetaDataContainer
          if estimated_tag_list is not None:
              if not isinstance(estimated_tag_list, dcase_util.containers.MetaDataContainer):
                  estimated_tag_list = dcase_util.containers.MetaDataContainer(estimated_tag_list)
  
          # Make sure estimated_tag_probabilities is dcase_util.containers.ProbabilityContainer
          if estimated_tag_probabilities is not None:
              if not isinstance(estimated_tag_probabilities, dcase_util.containers.ProbabilityContainer):
                  estimated_tag_probabilities = dcase_util.containers.ProbabilityContainer(estimated_tag_probabilities)
  
          y_true = []
          y_pred = []
  
          # Go though reference and estimated list label by label, and file by file
          for label in self.tag_label_list:
              for filename in reference_tag_list.unique_files:
                  reference_item = reference_tag_list.filter(filename=filename)[0]
  
                  # Populate y_true based on reference_item
                  if label in reference_item.tags:
                      self.y_true[label].append(1)
                      y_true.append(1)
  
                  else:
                      self.y_true[label].append(0)
                      y_true.append(0)
  
                  if estimated_tag_list is not None:
                      # Evaluate based on estimated tags
  
                      estimated_item = estimated_tag_list.filter(filename=filename)[0]
  
                      if not estimated_item:
                          raise ValueError(
                              "Not all reference files estimated, please check [{file}]".format(
                                  file=filename
                              )
                          )
                      # Store nref
                      if label in reference_item.tags:
                          self.tag_wise[label]['Nref'] += 1
  
                      # Populate y_pred based estimated_item
                      if label in estimated_item.tags:
                          self.y_pred[label].append(1)
                          y_pred.append(1)
                          self.tag_wise[label]['Nsys'] += 1
  
                      else:
                          self.y_pred[label].append(0)
                          y_pred.append(0)
  
                      # Accumulate intermediate values
                      # True positives (TP)
                      if label in reference_item.tags and label in estimated_item.tags:
                          self.tag_wise[label]['Ntp'] += 1
  
                      # True negatives (TN)
                      if label not in reference_item.tags and label not in estimated_item.tags:
                          self.tag_wise[label]['Ntn'] += 1
  
                      # False positives (FP)
                      if label not in reference_item.tags and label in estimated_item.tags:
                          self.tag_wise[label]['Nfp'] += 1
  
                      # False negatives (FN)
                      if label in reference_item.tags and label not in estimated_item.tags:
                          self.tag_wise[label]['Nfn'] += 1
  
                  if estimated_tag_probabilities is not None:
                      # Evaluate based on per tag probabilities
  
                      estimated_item = estimated_tag_probabilities.filter(filename=filename, label=label)[0]
                      self.y_pred_score[label].append(float(estimated_item['probability']))
  
          if estimated_tag_list is not None:
              # Evaluate based on estimated tags
  
              self.overall['Nref'] += sum(y_true)
              self.overall['Nsys'] += sum(y_pred)
  
              y_true = numpy.array(y_true)
              y_pred = numpy.array(y_pred)
  
              self.overall['Ntp'] += sum(y_pred + y_true > 1)
              self.overall['Ntn'] += sum(y_pred + y_true == 0)
              self.overall['Nfp'] += sum(y_pred - y_true > 0)
              self.overall['Nfn'] += sum(y_true - y_pred > 0)
  
          return self