Clears out the tracked metrics, but keeps the patience and should_decrease settings.
329064
def clear(self) -> None:
        
        self._best_so_far = None
        self._epochs_with_no_improvement = 0
        self._is_best_so_far = True
        self._epoch_number = 0
        self.best_epoch = None
564412
public static void flushAll(long now) {
        if (MetricsManager.instance != null) {
            MetricsManager.instance.metricsLoggers.values().forEach(MetricsManager::flushMetricsLogger);
            flushToServer(now);
        }
    }
350584
def clear(self):
        '''

        '''
        self.samples.clear()
        self.weights.clear()
        if self.target_values is not None:
            self.target_values.clear()
91358
public void cleanUp() {
    m_Owner     = null;
    m_Train     = null;
    m_Test      = null;
    m_Generator = null;
    m_Values    = null;
  }
1215003
def clean(self):

        

        self.closing = True # schedule for closing.

        if not self.fds:
            self.data.close()
1087285
def clear_to_reset(self, config_vars):
        """"""

        self._logger.info("Config vars in sensor log reset: %s", config_vars)
        super(SensorLogSubsystem, self).clear_to_reset(config_vars)

        self.storage.destroy_all_walkers()
        self.dump_walker = None

        if config_vars.get('storage_fillstop', False):
            self._logger.debug("Marking storage log fill/stop")
            self.storage.set_rollover('storage', False)

        if config_vars.get('streaming_fillstop', False):
            self._logger.debug("Marking streaming log fill/stop")
            self.storage.set_rollover('streaming', False)
765101
def clear(self):
        
        self.problems = []
        self.details = []
        self.suggestions = []
        self.tracebacks = []
1215476
public void release()
    {
        for(String name : allMetrics) 
        {
            Metrics.defaultRegistry().removeMetric(factory.createMetricName(name));
        }
        // latency metrics contain multiple metrics internally and need to be released manually
        readLatency.release();
        writeLatency.release();
        rangeLatency.release();
    }
320968
def clear_measurements(self):
        
        keys = list(self.measurements.keys())
        for key in keys:
            del(self.measurements[key])
        self.meas_counter = -1
499401
public synchronized void clearMemory() {
    Collection<TraceObject> traceObjects = values();
    for (TraceObject traceObject : traceObjects) {
      traceObject.remove();
    }
    this.clear();
  }
806687
def clear(self):
        
        self._lock.acquire()
        try:
            self._cache = []
            self._updated = False
        finally:
            self._lock.release()
284995
def _clean(self):
        """"""
        if self._workers:
            for url in self._workers.copy():
                w = self._workers[url]
                if w.is_finished():
                    self._workers.pop(url)
                    self._paths.pop(url)
                    if url in self._get_requests:
                        self._get_requests.pop(url)

        else:
            self._timer.stop()
56322
public void clear() {
        synchronized (mLock) {
            if (mOriginalValues != null) {
                mOriginalValues.clear();
            } else {
                mObjects.clear();
            }
        }
        if (mNotifyOnChange) notifyDataSetChanged();
    }
999947
def clear(self):
        
        self.__values.clear()
        self.__access_keys = []
        self.__modified_times.clear()
989947
private void cleanup() {
        StatsDataReference ref = null;
        while ((ref = (StatsDataReference) statisticsReferenceQueue.poll()) != null) {
            StatsData oldStats = null;
            StatsData updatedStats = null;
            do {
                oldStats = terminatedThreadStats.get();
                updatedStats = aggregateStats(oldStats, ref.statsData);
            } while (!terminatedThreadStats.compareAndSet(oldStats, updatedStats));
            allReferences.remove(ref);
        }
    }
1297476
public void clear() {
        sourceWaterMarkMap.clear();
        flush();
        if (fileOriginal != null && fileOriginal.exists()) {
            fileOriginal.delete();
        }
    }
24321
def _reset(self):
        

        # Checking one attribute is enough, because they are all set together
        # in partial_fit
        if hasattr(self, 'scale_'):
            del self.scale_
            del self.n_samples_seen_
            del self.mean_
            del self.var_