stouputils 1.12.1__py3-none-any.whl

stouputils/data_science/models/keras_utils/callbacks/colored_progress_bar.py

@@ -0,0 +1,219 @@
+
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from typing import Any
+
+import tensorflow as tf
+from keras.callbacks import Callback
+from keras.models import Model
+from tqdm.auto import tqdm
+
+from .....print import MAGENTA
+from .....parallel import BAR_FORMAT
+
+class ColoredProgressBar(Callback):
+	""" Progress bar using tqdm for Keras training.
+
+	A callback that displays a progress bar using tqdm during model training.
+	Shows the training progress across steps with a customized format
+	instead of the default Keras one showing multiple lines.
+	"""
+	def __init__(
+		self,
+		desc: str = "Training",
+		track_epochs: bool = False,
+		show_lr: bool = False,
+		update_frequency: int = 1,
+		color: str = MAGENTA
+	) -> None:
+		""" Initialize the progress bar callback.
+
+		Args:
+			desc             (str):   Custom description for the progress bar.
+			track_epochs     (bool):  Whether to track epochs instead of batches.
+			show_lr          (bool):  Whether to show the learning rate.
+			update_frequency (int):   How often to update the progress bar (every N batches).
+			color            (str):   Color of the progress bar.
+		"""
+		super().__init__()
+		self.desc: str = desc
+		""" Description of the progress bar. """
+		self.track_epochs: bool = track_epochs
+		""" Whether to track epochs instead of batches. """
+		self.show_lr: bool = show_lr
+		""" Whether to show the learning rate. """
+		self.latest_val_loss: float = 0.0
+		""" Latest validation loss, updated at the end of each epoch. """
+		self.latest_lr: float = 0.0
+		""" Latest learning rate, updated during batch and epoch processing. """
+		self.batch_count: int = 0
+		""" Counter to update the progress bar less frequently. """
+		self.update_frequency: int = max(1, update_frequency) # Ensure frequency is at least 1
+		""" How often to update the progress bar (every N batches). """
+		self.color: str = color
+		""" Color of the progress bar. """
+		self.pbar: tqdm[Any] | None = None
+		""" The tqdm progress bar instance. """
+		self.epochs: int = 0
+		""" Total number of epochs. """
+		self.steps: int = 0
+		""" Number of steps per epoch. """
+		self.total: int = 0
+		""" Total number of steps/epochs to track. """
+		self.params: dict[str, Any]
+		""" Training parameters. """
+		self.model: Model
+
+	def on_train_begin(self, logs: dict[str, Any] | None = None) -> None:
+		""" Initialize the progress bar at the start of training.
+
+		Args:
+			logs (dict | None): Training logs.
+		"""
+		# Get training parameters
+		self.epochs = self.params.get("epochs", 0)
+		self.steps = self.params.get("steps", 0)
+
+		# Determine total units and initial description
+		if self.track_epochs:
+			desc: str = f"{self.color}{self.desc} (Epochs)"
+			self.total = self.epochs
+		else:
+			desc: str = f"{self.color}{self.desc} (Epoch 1/{self.epochs})"
+			self.total = self.epochs * self.steps
+
+		# Initialize tqdm bar
+		self.pbar = tqdm(
+			total=self.total,
+			desc=desc,
+			position=0,
+			leave=True,
+			bar_format=BAR_FORMAT,
+			ascii=False
+		)
+		# Reset state variables
+		self.latest_val_loss = 0.0
+		self.latest_lr = 0.0
+		self.batch_count = 0
+
+	def on_batch_end(self, batch: int, logs: dict[str, Any] | None = None) -> None:
+		""" Update the progress bar after each batch, based on update frequency.
+
+		Args:
+			batch (int): Current batch number (0-indexed).
+			logs (dict | None): Dictionary of logs containing metrics for the batch.
+		"""
+		# Skip updates if tracking epochs, pbar isn't initialized, or steps are unknown
+		if self.track_epochs or self.pbar is None or self.steps == 0:
+			return
+
+		self.batch_count += 1
+		is_last_batch: bool = (batch + 1) == self.steps
+
+		# Update only every `update_frequency` batches or on the last batch
+		if self.batch_count % self.update_frequency == 0 or is_last_batch:
+			increment: int = self.batch_count
+			self.batch_count = 0 # Reset counter
+
+			# Calculate current epoch (1-based) based on the progress bar's state *before* this update
+			# Ensure epoch doesn't exceed total epochs in description
+			current_epoch: int = min(self.epochs, self.pbar.n // self.steps + 1)
+			current_step: int = batch + 1  # Convert to 1-indexed for display
+			self.pbar.set_description(
+				f"{self.color}{self.desc} (Epoch {current_epoch}/{self.epochs}, Step {current_step}/{self.steps})"
+			)
+
+			# Update learning rate if model and optimizer are available
+			if self.model and hasattr(self.model, "optimizer"):
+				self.latest_lr = float(tf.keras.backend.get_value(self.model.optimizer.learning_rate)) # type: ignore
+
+			# Update postfix with batch loss and the latest known validation loss
+			if logs and "loss" in logs:
+				loss: float = logs["loss"]
+				val_loss_str: str = ""
+				if self.latest_val_loss != 0.0:
+					if self.latest_val_loss < 1e-3:
+						val_loss_str = f", val_loss: {self.latest_val_loss:.2e}"
+					else:
+						val_loss_str = f", val_loss: {self.latest_val_loss:.5f}"
+
+				# Format learning rate string
+				lr_str: str = ""
+				if self.show_lr and self.latest_lr != 0.0:
+					if self.latest_lr < 1e-3:
+						lr_str = f", lr: {self.latest_lr:.2e}"
+					else:
+						lr_str = f", lr: {self.latest_lr:.5f}"
+
+				if loss < 1e-3:
+					self.pbar.set_postfix_str(f"loss: {loss:.2e}{val_loss_str}{lr_str}", refresh=False)
+				else:
+					self.pbar.set_postfix_str(f"loss: {loss:.5f}{val_loss_str}{lr_str}", refresh=False)
+
+			# Update progress bar position, ensuring not to exceed total
+			actual_increment: int = min(increment, self.total - self.pbar.n)
+			if actual_increment > 0:
+				self.pbar.update(actual_increment)
+
+	def on_epoch_end(self, epoch: int, logs: dict[str, Any] | None = None) -> None:
+		""" Update metrics and progress bar position at the end of each epoch.
+
+		Args:
+			epoch (int): Current epoch number (0-indexed).
+			logs (dict | None): Dictionary of logs containing metrics for the epoch.
+		"""
+		if self.pbar is None:
+			return
+
+		# Update the latest validation loss from epoch logs
+		if logs:
+			current_val_loss: float = logs.get("val_loss", 0.0)
+			if current_val_loss != 0.0:
+				self.latest_val_loss = current_val_loss
+
+			# Update learning rate if model and optimizer are available
+			if self.model and hasattr(self.model, "optimizer"):
+				self.latest_lr = float(tf.keras.backend.get_value(self.model.optimizer.learning_rate)) # type: ignore
+
+			# Update postfix string with final epoch metrics
+			loss: float = logs.get("loss", 0.0)
+			val_loss_str: str = f", val_loss: {self.latest_val_loss:.5f}" if self.latest_val_loss != 0.0 else ""
+
+			# Format learning rate string
+			lr_str: str = ""
+			if self.show_lr and self.latest_lr != 0.0:
+				if self.latest_lr < 1e-3:
+					lr_str = f", lr: {self.latest_lr:.2e}"
+				else:
+					lr_str = f", lr: {self.latest_lr:.5f}"
+
+			if loss != 0.0: # Only update if loss is available
+				self.pbar.set_postfix_str(f"loss: {loss:.5f}{val_loss_str}{lr_str}", refresh=True)
+
+		# Update progress bar position
+		if self.track_epochs:
+			# Increment by 1 epoch if not already at total
+			if self.pbar.n < self.total:
+				self.pbar.update(1)
+		else:
+			# Ensure the progress bar is exactly at the end of the current epoch
+			expected_position: int = min(self.total, (epoch + 1) * self.steps)
+			increment: int = expected_position - self.pbar.n
+			if increment > 0:
+				self.pbar.update(increment)
+
+	def on_train_end(self, logs: dict[str, Any] | None = None) -> None:
+		""" Close the progress bar when training is complete.
+
+		Args:
+			logs (dict | None): Training logs.
+		"""
+		if self.pbar is not None:
+			# Ensure the bar reaches 100%
+			increment: int = self.total - self.pbar.n
+			if increment > 0:
+				self.pbar.update(increment)
+			self.pbar.close()
+			self.pbar = None # Reset pbar instance
+

stouputils/data_science/models/keras_utils/callbacks/learning_rate_finder.py

@@ -0,0 +1,148 @@
+
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from typing import Any
+
+import tensorflow as tf
+from keras.callbacks import Callback
+from keras.models import Model
+
+
+class LearningRateFinder(Callback):
+	""" Callback to find optimal learning rate by increasing LR during training.
+
+	Sources:
+	- Inspired by: https://github.com/WittmannF/LRFinder
+	- Cyclical Learning Rates for Training Neural Networks: https://arxiv.org/abs/1506.01186 (first description of the method)
+
+	This callback gradually increases the learning rate from a minimum to a maximum value
+	during training, allowing you to identify the optimal learning rate range for your model.
+
+	It works by:
+
+	1. Starting with a very small learning rate
+	2. Exponentially increasing it after each batch or epoch
+	3. Recording the loss at each learning rate
+	4. Restoring the model's initial weights after training
+
+	The optimal learning rate is typically found where the loss is decreasing most rapidly
+	before it starts to diverge.
+
+	.. image:: https://blog.dataiku.com/hubfs/training%20loss.png
+		:alt: Learning rate finder curve example
+	"""
+
+	def __init__(
+		self,
+		min_lr: float,
+		max_lr: float,
+		steps_per_epoch: int,
+		epochs: int,
+		update_per_epoch: bool = False,
+		update_interval: int = 5
+	) -> None:
+		""" Initialize the learning rate finder.
+
+		Args:
+			min_lr           (float): Minimum learning rate
+			max_lr           (float): Maximum learning rate
+			steps_per_epoch  (int):   Steps per epoch
+			epochs           (int):   Number of epochs
+			update_per_epoch (bool):  If True, update LR once per epoch instead of every batch.
+			update_interval  (int):   Number of steps between each lr increase, bigger value means more stable loss.
+		"""
+		super().__init__()
+		self.min_lr: float = min_lr
+		""" Minimum learning rate. """
+		self.max_lr: float = max_lr
+		""" Maximum learning rate. """
+		self.total_updates: int = (epochs if update_per_epoch else steps_per_epoch * epochs) // update_interval
+		""" Total number of update steps (considering update_interval). """
+		self.update_per_epoch: bool = update_per_epoch
+		""" Whether to update learning rate per epoch instead of per batch. """
+		self.update_interval: int = max(1, int(update_interval))
+		""" Number of steps between each lr increase, bigger value means more stable loss. """
+		self.lr_mult: float = (max_lr / min_lr) ** (1 / self.total_updates)
+		""" Learning rate multiplier. """
+		self.learning_rates: list[float] = []
+		""" List of learning rates. """
+		self.losses: list[float] = []
+		""" List of losses. """
+		self.best_lr: float = min_lr
+		""" Best learning rate. """
+		self.best_loss: float = float("inf")
+		""" Best loss. """
+		self.model: Model
+		""" Model to apply the learning rate finder to. """
+		self.initial_weights: list[Any] | None = None
+		""" Stores the initial weights of the model. """
+
+	def on_train_begin(self, logs: dict[str, Any] | None = None) -> None:
+		""" Set initial learning rate and save initial model weights at the start of training.
+
+		Args:
+			logs (dict | None): Training logs.
+		"""
+		self.initial_weights = self.model.get_weights()
+		tf.keras.backend.set_value(self.model.optimizer.learning_rate, self.min_lr) # type: ignore
+
+	def _update_lr_and_track_metrics(self, logs: dict[str, Any] | None = None) -> None:
+		""" Update learning rate and track metrics.
+
+		Args:
+			logs (dict | None): Logs from training
+		"""
+		if logs is None:
+			return
+
+		# Get current learning rate and loss
+		current_lr: float = float(tf.keras.backend.get_value(self.model.optimizer.learning_rate)) # type: ignore
+		current_loss: float = logs["loss"]
+
+		# Record values
+		self.learning_rates.append(current_lr)
+		self.losses.append(current_loss)
+
+		# Track best values
+		if current_loss < self.best_loss:
+			self.best_loss = current_loss
+			self.best_lr = current_lr
+
+		# Update learning rate
+		new_lr: float = current_lr * self.lr_mult
+		tf.keras.backend.set_value(self.model.optimizer.learning_rate, new_lr) # type: ignore
+
+	def on_batch_end(self, batch: int, logs: dict[str, Any] | None = None) -> None:
+		""" Record loss and increase learning rate after each batch if not updating per epoch.
+
+		Args:
+			batch (int): Current batch index.
+			logs (dict | None): Training logs.
+		"""
+		if self.update_per_epoch:
+			return
+		if batch % self.update_interval == 0:
+			self._update_lr_and_track_metrics(logs)
+
+	def on_epoch_end(self, epoch: int, logs: dict[str, Any] | None = None) -> None:
+		""" Record loss and increase learning rate after each epoch if updating per epoch.
+
+		Args:
+			epoch (int): Current epoch index.
+			logs (dict | None): Training logs.
+		"""
+		if not self.update_per_epoch:
+			return
+		if epoch % self.update_interval == 0:
+			self._update_lr_and_track_metrics(logs)
+
+	def on_train_end(self, logs: dict[str, Any] | None = None) -> None:
+		""" Restore initial model weights at the end of training.
+
+		Args:
+			logs (dict | None): Training logs.
+		"""
+		if self.initial_weights is not None:
+			self.model.set_weights(self.initial_weights) # pyright: ignore [reportUnknownMemberType]
+

stouputils/data_science/models/keras_utils/callbacks/model_checkpoint_v2.py

@@ -0,0 +1,31 @@
+
+# pyright: reportMissingTypeStubs=false
+# pyright: reportUnknownMemberType=false
+
+# Imports
+from typing import Any
+
+from keras.callbacks import ModelCheckpoint
+
+
+class ModelCheckpointV2(ModelCheckpoint):
+	""" Model checkpoint callback but only starts after a given number of epochs.
+
+	Args:
+		epochs_before_start (int): Number of epochs before starting the checkpointing
+	"""
+
+	def __init__(self, epochs_before_start: int = 3, *args: Any, **kwargs: Any) -> None:
+		super().__init__(*args, **kwargs)
+		self.epochs_before_start = epochs_before_start
+		self.current_epoch = 0
+
+	def on_batch_end(self, batch: int, logs: dict[str, Any] | None = None) -> None:
+		if self.current_epoch >= self.epochs_before_start:
+			super().on_batch_end(batch, logs)
+
+	def on_epoch_end(self, epoch: int, logs: dict[str, Any] | None = None) -> None:
+		self.current_epoch = epoch
+		if epoch >= self.epochs_before_start:
+			super().on_epoch_end(epoch, logs)
+

stouputils/data_science/models/keras_utils/callbacks/progressive_unfreezing.py

@@ -0,0 +1,249 @@
+
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from collections.abc import Callable
+from typing import Any
+
+from keras.callbacks import Callback
+from keras.models import Model
+from keras.optimizers import Optimizer
+
+
+class ProgressiveUnfreezing(Callback):
+	""" Callback inspired by the Learning Rate Finder to progressively unfreeze model layers during training.
+
+	Warning: This callback is not compatible with model.fit() as it modifies the trainable state of the model.
+	Prefer doing your own training loop instead.
+
+	This callback can operate in two modes:
+	1. Start with all layers frozen and incrementally unfreeze them from 0% to 100% (progressive_freeze=False)
+	2. Start with all layers unfrozen and incrementally freeze them from 100% to 0% (progressive_freeze=True)
+	"""
+
+	def __init__(
+		self,
+		base_model: Model,
+		steps_per_epoch: int,
+		epochs: int,
+		reset_weights: bool = False,
+		reset_optimizer_function: Callable[[], Optimizer] | None = None,
+		update_per_epoch: bool = True,
+		update_interval: int = 5,
+		progressive_freeze: bool = False
+	) -> None:
+		""" Initialize the progressive unfreezing callback.
+
+		Args:
+			base_model         (Model):   Base model to unfreeze.
+			steps_per_epoch    (int):     Number of steps per epoch.
+			epochs             (int):     Total number of epochs.
+			reset_weights      (bool):    If True, reset weights after each unfreeze.
+			reset_optimizer_function (Callable | None):
+				If set, use this function to reset the optimizer every update_interval.
+				The function should return a compiled optimizer, e.g. `lambda: model._get_optimizer(AdamW(...))`.
+			update_per_epoch   (bool):    If True, unfreeze per epoch, else per batch.
+			update_interval    (int):     Number of steps between each unfreeze to allow model to stabilize.
+			progressive_freeze (bool):    If True, start with all layers unfrozen and progressively freeze them.
+		"""
+		super().__init__()
+		self.base_model: Model = base_model
+		""" Base model to unfreeze. """
+		self.model: Model
+		""" Model to apply the progressive unfreezing to. """
+		self.steps_per_epoch: int = int(steps_per_epoch)
+		""" Number of steps per epoch. """
+		self.epochs: int = int(epochs)
+		""" Total number of epochs. """
+		self.reset_weights: bool = bool(reset_weights)
+		""" If True, reset weights after each unfreeze. """
+		self.reset_optimizer_function: Callable[[], Optimizer] | None = reset_optimizer_function
+		""" If reset_weights is True and this is not None, use this function to get a new optimizer. """
+		self.update_per_epoch: bool = bool(update_per_epoch)
+		""" If True, unfreeze per epoch, else per batch. """
+		self.update_interval: int = max(1, int(update_interval))
+		""" Number of steps between each unfreeze to allow model to stabilize. """
+		self.progressive_freeze: bool = bool(progressive_freeze)
+		""" If True, start with all layers unfrozen and progressively freeze them. """
+
+		# If updating per epoch, remove to self.epochs the update interval to allow the last step to train with 100% unfreeze
+		if self.update_per_epoch:
+			self.epochs -= self.update_interval
+
+		# Calculate total steps considering the update interval
+		total_steps_raw: int = self.epochs if self.update_per_epoch else self.steps_per_epoch * self.epochs
+		self.total_steps: int = total_steps_raw // self.update_interval
+		""" Total number of update steps (considering update_interval). """
+
+		self.fraction_unfrozen: list[float] = []
+		""" Fraction of layers unfrozen. """
+		self.losses: list[float] = []
+		""" Losses. """
+		self._all_layers: list[Any] = []
+		""" All layers. """
+		self._initial_trainable: list[bool] = []
+		""" Initial trainable states. """
+		self._initial_weights: list[Any] | None = None
+		""" Initial weights of the model. """
+		self._last_update_step: int = -1
+		""" Last step when layers were unfrozen. """
+		self.params: dict[str, Any]
+
+	def on_train_begin(self, logs: dict[str, Any] | None = None) -> None:
+		""" Set initial layer trainable states at the start of training and store initial states and weights.
+
+		Args:
+			logs (dict | None): Training logs.
+		"""
+		# Collect all layers from the model and preserve their original trainable states for potential restoration
+		self._all_layers = self.base_model.layers
+		self._initial_trainable = [bool(layer.trainable) for layer in self._all_layers]
+
+		# Store initial weights to reset after each unfreeze
+		if self.reset_weights:
+			self._initial_weights = self.model.get_weights()
+
+		# Set initial trainable state based on mode
+		for layer in self._all_layers:
+			layer.trainable = self.progressive_freeze  # If progressive_freeze, start with all layers unfrozen
+
+	def _update_layers(self, step: int) -> None:
+		""" Update layer trainable states based on the current step and mode.
+		Reset weights after each update to prevent bias in the results.
+
+		Args:
+			step (int): Current training step.
+		"""
+		# Calculate the effective step considering the update interval
+		effective_step: int = step // self.update_interval
+
+		# Skip if we haven't reached the next update interval
+		if effective_step <= self._last_update_step:
+			return
+		self._last_update_step = effective_step
+
+		# Calculate the number of layers to unfreeze based on current effective step
+		n_layers: int = len(self._all_layers)
+
+		if self.progressive_freeze:
+			# For progressive freezing, start at 1.0 (all unfrozen) and decrease to 0.0
+			fraction: float = max(0.0, 1.0 - (effective_step + 1) / self.total_steps)
+		else:
+			# For progressive unfreezing, start at 0.0 (all frozen) and increase to 1.0
+			fraction: float = min(1.0, (effective_step + 1) / self.total_steps)
+
+		n_unfreeze: int = int(n_layers * fraction)  # Number of layers to keep unfrozen
+		self.fraction_unfrozen.append(fraction)
+
+		# Set trainable state for each layer based on position
+		# For both modes, we unfreeze from the top (output layers) to the bottom (input layers)
+		for i, layer in enumerate(self._all_layers):
+			layer.trainable = i >= (n_layers - n_unfreeze)
+
+		# Reset weights to initial state to prevent bias and reset optimizer
+		if self._initial_weights is not None:
+			self.model.set_weights(self._initial_weights) # pyright: ignore [reportUnknownMemberType]
+		if self.reset_optimizer_function is not None:
+			self.model.optimizer = self.reset_optimizer_function()
+			self.model.optimizer.build(self.model.trainable_variables) # pyright: ignore [reportUnknownMemberType]
+
+	def _track_loss(self, logs: dict[str, Any] | None = None) -> None:
+		""" Track the current loss.
+
+		Args:
+			logs (dict | None): Training logs containing loss information.
+		"""
+		if logs and "loss" in logs:
+			self.losses.append(logs["loss"])
+
+	def on_batch_begin(self, batch: int, logs: dict[str, Any] | None = None) -> None:
+		""" Update layer trainable states at the start of each batch if not updating per epoch.
+
+		Args:
+			batch (int): Current batch index.
+			logs (dict | None): Training logs.
+		"""
+		# Skip if we're updating per epoch instead of per batch
+		if self.update_per_epoch:
+			return
+
+		# Calculate the current step across all epochs and update layers
+		step: int = self.params.get("steps", self.steps_per_epoch) * self.params.get("epoch", 0) + batch
+		self._update_layers(step)
+
+	def on_batch_end(self, batch: int, logs: dict[str, Any] | None = None) -> None:
+		""" Track loss at the end of each batch if not updating per epoch.
+
+		Args:
+			batch (int): Current batch index.
+			logs (dict | None): Training logs.
+		"""
+		# Skip if we're updating per epoch instead of per batch
+		if self.update_per_epoch:
+			return
+
+		# Record the loss if update interval is reached
+		if batch % self.update_interval == 0:
+			self._track_loss(logs)
+
+	def on_epoch_begin(self, epoch: int, logs: dict[str, Any] | None = None) -> None:
+		""" Update layer trainable states at the start of each epoch if updating per epoch.
+
+		Args:
+			epoch (int): Current epoch index.
+			logs (dict | None): Training logs.
+		"""
+		# Skip if we're updating per batch instead of per epoch
+		if not self.update_per_epoch:
+			return
+
+		# Update layers based on current epoch
+		self._update_layers(epoch)
+
+	def on_epoch_end(self, epoch: int, logs: dict[str, Any] | None = None) -> None:
+		""" Track loss at the end of each epoch if updating per epoch.
+
+		Args:
+			epoch (int): Current epoch index.
+			logs (dict | None): Training logs.
+		"""
+		# Skip if we're updating per batch instead of per epoch
+		if not self.update_per_epoch:
+			return
+
+		# Record the loss if update interval is reached
+		if epoch % self.update_interval == 0:
+			self._track_loss(logs)
+
+	def on_train_end(self, logs: dict[str, Any] | None = None) -> None:
+		""" Restore original trainable states at the end of training.
+
+		Args:
+			logs (dict | None): Training logs.
+		"""
+		# Restore each layer's original trainable state
+		for layer, trainable in zip(self._all_layers, self._initial_trainable, strict=False):
+			layer.trainable = trainable
+
+	def get_results(self, multiply_by_100: bool = True) -> tuple[list[float], list[float]]:
+		""" Get the results of the progressive unfreezing from 0% to 100% even if progressive_freeze is True.
+
+		Args:
+			multiply_by_100 (bool): If True, multiply the fractions by 100 to get percentages.
+
+		Returns:
+			tuple[list[float], list[float]]: fractions of layers unfrozen, and losses.
+		"""
+		fractions: list[float] = self.fraction_unfrozen
+
+		# Reverse the order if progressive_freeze is True
+		if self.progressive_freeze:
+			fractions = fractions[::-1]
+
+		# Multiply by 100 if requested
+		if multiply_by_100:
+			fractions = [x * 100 for x in fractions]
+
+		# Return the results
+		return fractions, self.losses
+