bci_essentials.bci_controller

  1"""Module for managing BCI data.
  2
  3This module provides data classes for different BCI paradigms.
  4
  5It includes the loading of offline data in `xdf` format
  6or the live streaming of LSL data.
  7
  8The loaded/streamed data is added to a buffer such that offline and
  9online processing pipelines are identical.
 10
 11Data is pre-processed (using the `signal_processing` module), divided into trials,
 12and classified (using one of the `classification` sub-modules).
 13
 14Classes
 15-------
 16- `BciController` : For processing continuous data in trials of a defined length.
 17
 18"""
 19
 20import time
 21import os
 22import numpy as np
 23from enum import Enum
 24
 25from .paradigm.paradigm import Paradigm
 26from .data_tank.data_tank import DataTank
 27from .classification.generic_classifier import GenericClassifier
 28from .io.sources import EegSource, MarkerSource
 29from .io.messenger import Messenger
 30from .utils.logger import Logger
 31
 32# Instantiate a logger for the module at the default level of logging.INFO
 33# Logs to bci_essentials.__module__) where __module__ is the name of the module
 34logger = Logger(name=__name__)
 35
 36
 37class MarkerTypes(Enum):
 38    TRIAL_STARTED = "Trial Started"
 39    TRIAL_ENDS = "Trial Ends"
 40    TRAINING_COMPLETE = "Training Complete"
 41    TRAIN_CLASSIFIER = "Train Classifier"
 42    DONE_RS_COLLECTION = "Done with all RS collection"
 43    UPDATE_CLASSIFIER = "Update Classifier"
 44
 45
 46# EEG data
 47class BciController:
 48    """
 49    Class that holds, trials, processes, and classifies EEG data.
 50    This class is used for processing of continuous EEG data in trials of a defined length.
 51    """
 52
 53    # 0. Special methods (e.g. __init__)
 54    def __init__(
 55        self,
 56        classifier: GenericClassifier,
 57        eeg_source: EegSource,
 58        marker_source: MarkerSource | None = None,
 59        paradigm: Paradigm | None = None,
 60        data_tank: DataTank | None = None,
 61        messenger: Messenger | None = None,
 62    ):
 63        """Initializes `BciController` class.
 64
 65        Parameters
 66        ----------
 67        classifier : GenericClassifier
 68            The classifier used by BciController.
 69        eeg_source : EegSource
 70            Source of EEG data and timestamps, this could be from a file or headset via LSL, etc.
 71        marker_source : EegSource
 72            Source of Marker/Control data and timestamps, this could be from a file or Unity via LSL, etc.
 73            - Default is `None`.
 74        paradigm : Paradigm
 75            The paradigm used by BciController. This defines the processing and reshaping steps for the EEG data.
 76        data_tank : DataTank
 77            DataTank object to handle the storage of EEG trials and labels.
 78            - Default is `None`.
 79        messenger: Messenger
 80            Messenger object to handle events from BciController, ex: acknowledging markers and
 81            predictions.
 82            - Default is `None`.
 83
 84        """
 85
 86        # Ensure the incoming dependencies are the right type
 87        assert isinstance(classifier, GenericClassifier)
 88        assert isinstance(eeg_source, EegSource)
 89        assert isinstance(marker_source, MarkerSource | None)
 90        assert isinstance(paradigm, Paradigm | None)
 91        assert isinstance(data_tank, DataTank | None)
 92        assert isinstance(messenger, Messenger | None)
 93
 94        self._classifier = classifier
 95        self.__eeg_source = eeg_source
 96        self.__marker_source = marker_source
 97        self.__paradigm = paradigm
 98        self.__data_tank = data_tank
 99        self._messenger = messenger
100
101        self.headset_string = self.__eeg_source.name
102        self.fsample = self.__eeg_source.fsample
103        self.n_channels = self.__eeg_source.n_channels
104        self.ch_type = self.__eeg_source.channel_types
105        self.ch_units = self.__eeg_source.channel_units
106        self.channel_labels = self.__eeg_source.channel_labels
107
108        # Emily EGI fix
109        # Set default channel types if none
110        if self.ch_type is None:
111            logger.warning("Channel types are none, setting all to 'eeg'")
112            self.ch_type = ["eeg"] * self.n_channels
113
114        self.__data_tank.set_source_data(
115            self.headset_string,
116            self.fsample,
117            self.n_channels,
118            self.ch_type,
119            self.ch_units,
120            self.channel_labels,
121        )
122
123        # Switch any trigger channels to stim, this is for mne/bids export (?)
124        self.ch_type = [type.replace("trg", "stim") for type in self.ch_type]
125
126        self._classifier.channel_labels = self.channel_labels
127
128        logger.info(self.headset_string)
129        logger.info(self.channel_labels)
130
131        # Initialize data and timestamp arrays to the right dimensions, but zero elements
132        self.marker_data = np.zeros((0, 1))
133        self.marker_timestamps = np.zeros((0))
134        self.bci_controller = np.zeros((0, self.n_channels))
135        self.eeg_timestamps = np.zeros((0))
136
137        # Initialize marker methods dictionary
138        self.marker_methods = {
139            MarkerTypes.DONE_RS_COLLECTION.value: self.__process_resting_state_data,
140            MarkerTypes.TRIAL_STARTED.value: self.__log_trial_start,
141            MarkerTypes.TRIAL_ENDS.value: self.__handle_trial_end,
142            MarkerTypes.TRAINING_COMPLETE.value: self.__update_and_train_classifier,
143            MarkerTypes.TRAIN_CLASSIFIER.value: self.__update_and_train_classifier,
144            MarkerTypes.UPDATE_CLASSIFIER.value: self.__update_and_train_classifier,
145        }
146
147        self.step_count = 0
148        self.ping_interval = 1000
149        self.n_samples = 0
150        self.time_units = ""
151
152    # 1. Core public API methods
153    def setup(
154        self,
155        online=True,
156        train_complete=False,
157        train_lock=False,
158        auto_save_epochs=True,
159    ):
160        """Configure processing loop.
161
162        This should be called before starting the loop with run() or step().
163
164        Calling after will reset the loop state.
165
166        The processing loop reads in EEG and marker data and processes it.
167        The loop can be run in "offline" or "online" modes:
168        - If in `online` mode, then the loop will continuously try to read
169        in data from the `BciController` object and process it. The loop will
170        terminate when `max_loops` is reached, or when manually terminated.
171        - If in `offline` mode, then the loop will read in all of the data
172        at once, process it, and then terminate.
173
174        Parameters
175        ----------
176        online : bool, *optional*
177            Flag to indicate if the data will be processed in `online` mode.
178            - `True`: The data will be processed in `online` mode.
179            - `False`: The data will be processed in `offline` mode.
180            - Default is `True`.
181        train_complete : bool, *optional*
182            Flag to indicate if the classifier has been trained.
183            - `True`: The classifier has been trained.
184            - `False`: The classifier has not been trained.
185            - Default is `False`.
186        train_lock : bool, *optional*
187            Flag to indicate if the classifier is locked (ie. no more training).
188            - `True`: The classifier is locked.
189            - `False`: The classifier is not locked.
190            - Default is `False`.
191        auto_save_epochs : bool, *optional*
192            Flag to indicate if labeled epochs should be automatically saved to a temp file so they can be reloaded if Bessy crashes.
193            - `True`: Epochs will be saved to a temp file.
194            - `False`: Epochs will not be saved to a temp file.
195
196
197        Returns
198        -------
199        `None`
200
201        """
202        self.online = online
203        self.train_complete = train_complete
204        self.train_lock = train_lock
205        self.auto_save_epochs = auto_save_epochs
206
207        # initialize the numbers of markers and trials to zero
208        self.marker_count = 0
209        self.current_num_trials = 0
210        self.n_trials = 0
211
212        self.num_online_selections = 0
213        self.online_selection_indices = []
214        self.online_selections = []
215
216        # Check for a temp_epochs file
217        if online:
218            self.__load_temp_epochs_if_available()
219
220    def step(self):
221        """Runs a single BciController processing step.
222
223        See setup() for configuration of processing.
224
225        The method:
226        1. Pulls data from sources (EEG and markers).
227        2. Run a while loop to process markers as long as there are unprocessed markers.
228        3. The while loop processes the markers in the following order:
229            - First checks if the marker is a known command marker from self.marker_methods.
230            - Then checks if it's an event marker (contains commas)
231            - If neither, logs a warning about unknown marker type
232        3. If the marker is a command marker, handles it by calling __handle_command_marker().
233        4. If the marker is an event marker, handles it by calling __handle_event_marker().
234        5. If the command or event marker handling return continue_flag as True, increment the marker count and process the next marker.
235            - Note: If there is an unknown marker type, the marker count is still incremented and processing continues.
236        6. If the command or event marker handling return continue_flag as False, break out of the while loop and end the step.
237
238        Parameters
239        ----------
240        `None`
241
242        Returns
243        ------
244        `None`
245
246        """
247        # read from sources to get new data.
248        # This puts command markers in the marker_data array and
249        # event markers in the event_marker_strings array
250        self._pull_data_from_sources()
251
252        # Process markers while there are unprocessed markers
253        # REMOVE COMMENT: check if there is an available command marker, if not, break and wait for more data
254        while len(self.marker_timestamps) > self.marker_count:
255            # Get the current marker
256            current_step_marker = self.marker_data[self.marker_count]  # String
257            current_timestamp = self.marker_timestamps[self.marker_count]  # Float
258
259            # If marker is empty, skip it
260            if not current_step_marker:
261                logger.warning("Empty marker received")
262                self.marker_count += 1
263                continue
264
265            # If messenger is available, send feedback for each marker received
266            if self._messenger is not None:
267                self._messenger.marker_received(current_step_marker)
268
269            # Process markers in order specified in the docstrings
270            # First check if it's a known command marker
271            if current_step_marker in self.marker_methods:
272                continue_flag = self.__handle_command_marker(current_step_marker)
273            # Then check if it's an event marker (contains commas)
274            elif "," in current_step_marker:
275                continue_flag = self.__handle_event_marker(
276                    current_step_marker, current_timestamp
277                )
278            # Otherwise, log a warning about unknown marker type
279            else:
280                # Log warning for unknown marker types
281                logger.warning("Unknown marker type received: %s", current_step_marker)
282                continue_flag = True
283
284            # Check if we should continue processing markers in the while loop
285            # if continue_flag is False, then break out of the while loop
286            # else, increment the marker count and process the next marker
287            if continue_flag is False:
288                break
289            else:
290                logger.info("Processed Marker: %s", current_step_marker)
291                self.marker_count += 1
292
293        self.step_count += 1
294        if self.step_count % self.ping_interval == 0:
295            if self._messenger is not None:
296                self._messenger.ping()
297
298    def run(self, max_loops: int = 1000000, ping_interval: int = 100):
299        """Runs BciController processing in a loop.
300
301        See setup() for configuration of processing.
302
303        Parameters
304        ----------
305        max_loops : int, *optional*
306            Maximum number of loops to run, default is `1000000`.
307        ping_interval : int, *optional*
308            Number of steps between each messenger ping.
309
310        Returns
311        ------
312        `None`
313
314        """
315        # if offline, then all data is already loaded, only need to loop once
316        if self.online is False:
317            self.loops = max_loops - 1
318        else:
319            self.loops = 0
320
321        self.ping_interval = ping_interval
322
323        # Initialize the event marker buffer
324        self.event_marker_buffer = []
325        self.event_timestamp_buffer = []
326
327        # start the main loop, stops after pulling new data, max_loops times
328        while self.loops < max_loops:
329            # print out loop status
330            if self.loops % 100 == 0:
331                logger.debug(self.loops)
332
333            if self.loops == max_loops - 1:
334                logger.debug("last loop")
335
336            # read from sources and process
337            self.step()
338
339            # Wait a short period of time and then try to pull more data
340            if self.online:
341                time.sleep(0.00001)
342
343            self.loops += 1
344
345    # 2. Protected methods (single underscore)
346    def _pull_data_from_sources(self):
347        """Get pull data from EEG and optionally, the marker source.
348
349        This method will fill up the marker_data, bci_controller and corresponding timestamp arrays.
350
351        Parameters
352        ----------
353        `None`
354
355        Returns
356        -------
357        `None`
358
359        """
360        # Get new data from source, whatever it is
361        self.__pull_marker_data_from_source()
362        self.__pull_eeg_data_from_source()
363
364    # 3. Private methods (double underscore)
365    # 3a. Private methods for retrieving data from sources
366    def __pull_marker_data_from_source(self):
367        """Pulls marker samples from source, sanity checks and appends to buffer.
368
369        Parameters
370        ----------
371        `None`
372
373        Returns
374        -------
375        `None`
376
377        """
378
379        # if there isn't a marker source, abort
380        if self.__marker_source is None:
381            return
382
383        # read in the data
384        markers, timestamps = self.__marker_source.get_markers()
385        markers = np.array(markers)
386        timestamps = np.array(timestamps)
387
388        if markers.size == 0:
389            return
390
391        if markers.ndim != 2:
392            logger.warning("discarded invalid marker data")
393            return
394
395        # apply time correction
396        time_correction = self.__marker_source.time_correction()
397        timestamps = [timestamps[i] + time_correction for i in range(len(timestamps))]
398
399        for i, marker in enumerate(markers):
400            marker = marker[0]
401            if "Ping" in marker:
402                continue
403
404            # Add all markers to the controller
405            self.marker_data = np.append(self.marker_data, marker)
406            self.marker_timestamps = np.append(self.marker_timestamps, timestamps[i])
407
408            # Add all markers to the data tank
409            self.__data_tank.add_raw_markers(
410                np.array([marker]), np.array([timestamps[i]])
411            )
412
413    def __pull_eeg_data_from_source(self):
414        """Pulls eeg samples from source, sanity checks and appends to buffer.
415
416        Parameters
417        ----------
418        `None`
419
420        Returns
421        -------
422        `None`
423
424        """
425
426        # read in the data
427        eeg, timestamps = self.__eeg_source.get_samples()
428        eeg = np.array(eeg)
429        timestamps = np.array(timestamps)
430
431        if eeg.size == 0:
432            return
433
434        if eeg.ndim != 2:
435            logger.warning("discarded invalid eeg data")
436            return
437
438        # if time is in milliseconds, divide by 1000, works for sampling rates above 10Hz
439        try:
440            if self.time_units == "milliseconds":
441                timestamps = [(timestamps[i] / 1000) for i in range(len(timestamps))]
442
443        # If time units are not defined then define them
444        except Exception:
445            dif_low = -2
446            dif_high = -1
447            while timestamps[dif_high] - timestamps[dif_low] == 0:
448                dif_low -= 1
449                dif_high -= 1
450
451            if timestamps[dif_high] - timestamps[dif_low] > 0.1:
452                timestamps = [(timestamps[i] / 1000) for i in range(len(timestamps))]
453                self.time_units = "milliseconds"
454            else:
455                self.time_units = "seconds"
456
457        # apply time correction, this is essential for headsets like neurosity which have their own clock
458        time_correction = self.__eeg_source.time_correction()
459        timestamps = [timestamps[i] + time_correction for i in range(len(timestamps))]
460
461        self.__data_tank.add_raw_eeg(eeg.T, timestamps)
462
463        # Update latest EEG timestamp
464        self.latest_eeg_timestamp = timestamps[-1]
465
466    # 3b. Private methods for data processing and classification
467    def __process_resting_state_data(self):
468        """Handles the resting state data by packaging it and adding it to the data tank.
469
470        Parameters
471        ----------
472        `None`
473
474        Returns
475        ------
476        continue_flag : bool
477            Flag indicating to continue the while loop in step().
478
479        """
480        (
481            self.bci_controller,
482            self.eeg_timestamps,
483        ) = self.__data_tank.get_raw_eeg()
484
485        resting_state_data = self.__paradigm.package_resting_state_data(
486            self.marker_data,
487            self.marker_timestamps,
488            self.bci_controller,
489            self.eeg_timestamps,
490            self.fsample,
491        )
492
493        self.__data_tank.add_resting_state_data(resting_state_data)
494
495        return True  # Continue processing
496
497    def __process_and_classify(self):
498        """Process the markers and classify the data.
499
500        Parameters
501        ----------
502        `None`
503
504        Returns
505        -------
506        success_string : str
507            String indicating if the processing and classification was successful.
508            Potential values are "Success", "Skip", "Wait".
509            - "Success": The processing and classification was successful.
510            - "Skip": EEG is either absent entirely or contains lost packets.
511            - "Wait": The processing is waiting for more data.
512
513        """
514
515        eeg_start_time, eeg_end_time = self.__paradigm.get_eeg_start_and_end_times(
516            self.event_marker_buffer, self.event_timestamp_buffer
517        )
518
519        # No we actually need to wait until we have all the data for these markers
520        eeg, timestamps = self.__data_tank.get_raw_eeg()
521
522        # Check if there is available EEG data
523        if len(eeg) == 0:
524            logger.warning("No EEG data available")
525            return "Skip"
526
527        # If the last timestamp is less than the end time, then we don't have the necessary EEG to process
528        if timestamps[-1] < eeg_end_time:
529            return "Wait"
530
531        # Check if EEG sampling is continuous over this time period
532        start_indices = np.where(timestamps > eeg_start_time)[0]
533        if len(start_indices) == 0:
534            logger.warning("No timestamps exceed eeg_start_time")
535            return "Skip"
536        start_index = start_indices[0]
537        end_index = np.where(timestamps < eeg_end_time)[0][-1]
538
539        time_diffs = np.diff(timestamps[start_index:end_index])
540        if np.any(time_diffs > 2 / self.fsample):
541            logger.warning("Time gaps in EEG data")
542            return "Skip"
543
544        X, y = self.__paradigm.process_markers(
545            self.event_marker_buffer,
546            self.event_timestamp_buffer,
547            eeg,
548            timestamps,
549            self.fsample,
550        )
551
552        sum_new_labeled_trials = np.sum(y != -1)
553
554        # Add the epochs to the data tank
555        self.__data_tank.add_epochs(X, y)
556
557        # Save epochs to temp_epochs file
558        if self.auto_save_epochs and self.online and sum_new_labeled_trials > 0:
559            paradigm_str = self.__paradigm.paradigm_name
560
561            with open(self.temp_epochs, "wb") as f:
562                np.savez(
563                    f,
564                    X=self.__data_tank.epochs,
565                    y=self.__data_tank.labels,
566                    paradigm=paradigm_str,
567                )
568
569        # If either there are no labels OR iterative training is on, then make a prediction
570        if self.train_complete:
571            if -1 in y or self.__paradigm.iterative_training:
572                prediction = self._classifier.predict(X)
573                self.__send_prediction(prediction)
574
575        self.event_marker_buffer = []
576        self.event_timestamp_buffer = []
577
578        return "Success"
579
580    def __update_and_train_classifier(self):
581        """Updates the classifier if required.
582
583        Parameters
584        ----------
585        `None`
586
587        Returns
588        -------
589        continue_flag : bool
590            Flag indicating to continue the while loop in step().
591        """
592        if self.train_lock is False:
593            # Pull the epochs from the data tank and pass them to the classifier
594            X, y = self.__data_tank.get_epochs(latest=True)
595
596            # Remove epochs with label -1
597            ind_to_remove = []
598            for i, label in enumerate(y):
599                if label == -1:
600                    ind_to_remove.append(i)
601            X = np.delete(X, ind_to_remove, axis=0)
602            y = np.delete(y, ind_to_remove, axis=0)
603
604            # Check that there are epochs
605            if len(y) > 0:
606                self._classifier.add_to_train(X, y)
607
608            if self._classifier._check_ready_for_fit():
609                self._classifier.fit()
610                self.train_complete = True
611
612        return True
613
614    # 3c. Private methods for event handling (trial and markers) and messaging
615    def __log_trial_start(self):
616        """Logs the start of a trial.
617
618        Parameters
619        ----------
620        `None`
621
622        Returns
623        -------
624        continue_flag : bool
625            Flag indicating to continue the while loop in step().
626
627        """
628        logger.debug("Trial started, incrementing marker count and continuing")
629        # Note that a marker occured, but do nothing else
630        return True  # Continue processing
631
632    def __handle_trial_end(self):
633        """Handles the end of a trial. Processes and classifies trial data if required.
634
635        Parameters
636        ----------
637        `None`
638
639        Returns
640        ------
641        success_flag : bool
642            Flag indicating if the processing and classification was successful.
643            - Returns `True` if not classifying.
644        """
645        # If we are classifying based on trials, then process the trial,
646        if self.__paradigm.classify_each_trial:
647            success_string = self.__process_and_classify()
648            if success_string == "Wait":
649                logger.debug("Processing of trial not run: waiting for more data")
650                return False
651            if success_string == "Skip":
652                logger.warning("Processing of trial failed: skipping trial")
653                self.event_marker_buffer = []
654                self.event_timestamp_buffer = []
655                self.marker_count += 1
656                return False
657
658        return True  # Return True by default if not classifying
659
660    def __handle_event_marker(self, marker, timestamp):
661        """Processes and classifies event markers.
662
663        Parameters
664        ----------
665        marker : str
666            Event marker string containing comma-separated values.
667            - Format depends on paradigm implementation.
668        timestamp : float
669            Timestamp of the marker in seconds (after time correction).
670
671
672        Returns
673        ------
674        continue_flag : bool
675            Flag indicating to continue the while loop in step().
676
677        """
678        # Add the marker to the event marker buffer
679        self.event_marker_buffer.append(marker)
680        self.event_timestamp_buffer.append(timestamp)
681
682        # If classification is on epochs, then update epochs, maybe classify, and clear the buffer
683        if self.__paradigm.classify_each_epoch:
684            success_string = self.__process_and_classify()
685            if success_string == "Wait":
686                logger.debug("Processing of epoch not run: waiting for more data")
687                self.event_marker_buffer = []
688                self.event_timestamp_buffer = []
689                return False  # Stop processing
690            elif success_string == "Skip":
691                logger.warning("Processing of epoch failed: skipping epoch")
692                self.event_marker_buffer = []
693                self.event_timestamp_buffer = []
694
695                self.marker_count += 1
696                return False  # Stop processing
697
698        return True  # Continue processing
699
700    def __handle_command_marker(self, marker: str) -> bool:
701        """Processes a command marker by invoking its associated method.
702
703        The command marker string is assumed to be in the self.marker_methods dictionary.
704        The associated method is retrieved and called.
705        The return value of the method is used to determine if processing should continue.
706
707        Parameters
708        ----------
709        marker : str
710            A command marker string (assumed to be in self.marker_methods).
711
712        Returns
713        -------
714        bool
715            A flag indicating if the processing should continue.
716
717        """
718        command_marker_method = self.marker_methods[marker]  # Retrieve method
719        continue_flag = command_marker_method()  # Call method
720
721        # Debug level logging if continue_flag is FALSE
722        if continue_flag is False:
723            logger.debug("Command marker '%s' set continue_flag to FALSE", marker)
724
725        return continue_flag
726
727    def __send_prediction(self, prediction):
728        """Send a prediction to the messenger object.
729
730        Parameters
731        ----------
732        `None`
733
734        Returns
735        -------
736        `None`
737
738        """
739        if self._messenger is not None:
740            logger.debug("Sending prediction: %s", prediction)
741            self._messenger.prediction(prediction)
742        elif self._messenger is None and self.online is True:
743            # If running in online mode and messenger is not available, log a warning
744            logger.warning(
745                "Messenger not available (self._messenger is None). Prediction not sent: %s",
746                prediction,
747            )
748
749    def __load_temp_epochs_if_available(self, reload_data_time: int = 300):
750        """Load temp_epochs if available and valid.
751
752        Parameters
753        ----------
754        reload_data_time : int, *optional*
755            Time in seconds of the last temp_epochs file to reload the data from.
756            Default is `300` seconds (5 minutes).
757
758        Returns
759        -------
760        `None`
761
762        """
763        self.temp_epochs = os.path.join(
764            os.path.dirname(os.path.dirname(__file__)), "temp_epochs.npz"
765        )
766
767        if not os.path.exists(self.temp_epochs):
768            return
769
770        # If temp_epochs is older than `reload_data_time`, delete it
771        if os.path.getmtime(self.temp_epochs) < (time.time() - reload_data_time):
772            os.remove(self.temp_epochs)
773            logger.info("Deleted old temp_epochs file.")
774            return
775
776        # Load the temp_epochs file
777        with open(self.temp_epochs, "rb") as f:
778            npz = np.load(f, allow_pickle=True)
779            X = npz["X"]
780            y = npz["y"]
781            paradigm_str = npz["paradigm"].item()
782
783        # If the paradigm is different, delete the file
784        if self.__paradigm.paradigm_name != paradigm_str:
785            logger.warning(
786                "Paradigm in temp_epochs file does not match current paradigm. Deleting file."
787            )
788            os.remove(self.temp_epochs)
789            return
790
791        # If the paradigm is the same, then add the epochs to the data tank
792        logger.info("Loading epochs from temp_epochs file.")
793        logger.info("X shape: %s", X.shape)
794        logger.info("y shape: %s", y.shape)
795        self.__data_tank.add_epochs(X, y)
796
797        # If there are epochs in the data tank, then train the classifier
798        if len(self.__data_tank.labels) > 0:
799            self.__update_and_train_classifier()