def after_epoch(self, epoch_id: int, epoch_data: EpochData):
        """
        Check termination conditions.

        :param epoch_id: number of the processed epoch
        :param epoch_data: epoch data to be checked
        :raise KeyError: if the stream of variable was not found in ``epoch_data``
        :raise TypeError: if the monitored variable is not a scalar or scalar ``mean`` aggregation
        :raise ValueError: if the specified number of epochs exceeded
        :raise TrainingTerminated: if the monitor variable is above the required level
        """

        if self._stream not in epoch_data:
            raise KeyError('The hook could not determine whether the threshold was exceeded as the stream `{}`'
                           'was not found in the epoch data'.format(self._stream))

        if self._variable not in epoch_data[self._stream]:
            raise KeyError('The hook could not determine whether the threshold was exceeded as the variable `{}`'
                           'was not found in the epoch data stream `{}`'.format(self._variable, self._stream))

        value = epoch_data[self._stream][self._variable]
        if isinstance(value, dict) and 'mean' in value:
            value = value['mean']

        if not np.isscalar(value):
            raise TypeError('The value to be checked has to be either a scalar or a dict with `mean` key. '
                            'Got `{}` instead.'.format(type(value).__name__))

        if value > self._required_min_value:
            raise TrainingTerminated('{} {} level matched (current {} is greater than required {}).'
                                     .format(self._stream, self._variable, value, self._required_min_value))
        elif epoch_id >= self._max_epoch:
            raise ValueError('{} {} was only {} in epoch {}, but {} was required. Training failed.'
                             .format(self._stream, self._variable, value, epoch_id, self._required_min_value))
Check termination conditions.

        :param epoch_id: number of the processed epoch
        :param epoch_data: epoch data to be checked
        :raise KeyError: if the stream of variable was not found in ``epoch_data``
        :raise TypeError: if the monitored variable is not a scalar or scalar ``mean`` aggregation
        :raise ValueError: if the specified number of epochs exceeded
        :raise TrainingTerminated: if the monitor variable is above the required level