Create loggers property for Trainer and LightningModule

CHANGELOG.md

@@ -80,6 +80,13 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/).
 
 - Added a `MisconfigurationException` if user provided `opt_idx` in scheduler config doesn't match with actual optimizer index of its respective optimizer ([#11247](https://github.com/PyTorchLightning/pytorch-lightning/pull/11247))
 
+
+- Added a `loggers` property to `Trainer` which returns a list of loggers provided by the user ([#11683](https://github.com/PyTorchLightning/pytorch-lightning/pull/11683))
+
+
+- Added a `loggers` property to `LightningModule` which retrieves the `loggers` property from `Trainer` ([#11683](https://github.com/PyTorchLightning/pytorch-lightning/pull/11683))
+
+
 - Added support for DDP when using a `CombinedLoader` for the training data ([#11648](https://github.com/PyTorchLightning/pytorch-lightning/pull/11648))
 
 

docs/source/common/lightning_module.rst

@@ -983,6 +983,17 @@ The current logger being used (tensorboard or other supported logger)
         # the particular logger
         tensorboard_logger = self.logger.experiment
 
+loggers
+~~~~~~~
+
+The list of loggers currently being used.
+
+.. code-block:: python
+
+    def training_step(self, batch, batch_idx):
+        # List of LightningLoggerBase objects
+        self.loggers
+
 local_rank
 ~~~~~~~~~~~
 

docs/source/common/trainer.rst

@@ -1741,9 +1741,21 @@ The current logger being used. Here's an example using tensorboard
 
 .. code-block:: python
 
-    def training_step(self, batch, batch_idx):
-        logger = self.trainer.logger
-        tensorboard = logger.experiment
+    logger = trainer.logger
+    tensorboard = logger.experiment
+
+
+loggers (p)
+***********
+
+The list of loggers currently being used.
+
+.. code-block:: python
+
+    # List of LightningLoggerBase objects
+    loggers = trainer.loggers
+    for logger in loggers:
+        logger.log_metrics({"foo": 1.0})
 
 
 logged_metrics

pytorch_lightning/core/lightning.py

@@ -37,6 +37,7 @@
 from pytorch_lightning.core.mixins import DeviceDtypeModuleMixin, HyperparametersMixin
 from pytorch_lightning.core.optimizer import LightningOptimizer
 from pytorch_lightning.core.saving import ModelIO
+from pytorch_lightning.loggers import LightningLoggerBase
 from pytorch_lightning.trainer.connectors.logger_connector.fx_validator import _FxValidator
 from pytorch_lightning.utilities import (
     _IS_WINDOWS,
@@ -80,6 +81,7 @@ class LightningModule(
             "global_rank",
             "local_rank",
             "logger",
+            "loggers",
             "model_size",
             "automatic_optimization",
             "truncated_bptt_steps",
@@ -252,10 +254,15 @@ def truncated_bptt_steps(self, truncated_bptt_steps: int) -> None:
         self._truncated_bptt_steps = truncated_bptt_steps
 
     @property
-    def logger(self):
+    def logger(self) -> Optional[LightningLoggerBase]:
         """Reference to the logger object in the Trainer."""
         return self.trainer.logger if self.trainer else None
 
+    @property
+    def loggers(self) -> List[LightningLoggerBase]:
+        """Reference to the loggers object in the Trainer."""
+        return self.trainer.loggers if self.trainer else []
+
     def _apply_batch_transfer_handler(
         self, batch: Any, device: Optional[torch.device] = None, dataloader_idx: int = 0
     ) -> Any:

pytorch_lightning/trainer/trainer.py

@@ -563,7 +563,8 @@ def __init__(
         self.__init_profiler(profiler)
 
         # init logger flags
-        self.logger: Optional[LightningLoggerBase]
+        self._logger: Optional[LightningLoggerBase]
+        self._loggers: List[LightningLoggerBase]
         self.logger_connector.on_trainer_init(logger, flush_logs_every_n_steps, log_every_n_steps, move_metrics_to_cpu)
 
         # init debugging flags
@@ -2475,6 +2476,33 @@ def _active_loop(self) -> Optional[Union[FitLoop, EvaluationLoop, PredictionLoop
     Logging properties
     """
 
+    @property
+    def logger(self) -> Optional[LightningLoggerBase]:
+        return self._logger
+
+    @logger.setter
+    def logger(self, new_logger: Optional[LightningLoggerBase]) -> None:
+        self._logger = new_logger
+        if not new_logger:
+            self._loggers = []
+        elif isinstance(new_logger, LoggerCollection):
+            self._loggers = list(new_logger)
+        else:
+            self._loggers = [new_logger]
+
+    @property
+    def loggers(self) -> List[LightningLoggerBase]:
+        return self._loggers
+
+    @loggers.setter
+    def loggers(self, new_loggers: Optional[List[LightningLoggerBase]]) -> None:
+        if new_loggers:
+            self._loggers = new_loggers
+            self._logger = self._loggers[0] if len(self._loggers) == 1 else LoggerCollection(self._loggers)
+        else:
+            self._loggers = []
+            self._logger = None
+
     @property
     def callback_metrics(self) -> dict:
         return self.logger_connector.callback_metrics

tests/core/test_lightning_module.py

@@ -76,6 +76,17 @@ def test_property_logger(tmpdir):
     assert model.logger == logger
 
 
+def test_property_loggers(tmpdir):
+    """Test that loggers in LightningModule is accessible via the Trainer."""
+    model = BoringModel()
+    assert model.loggers == []
+
+    logger = TensorBoardLogger(tmpdir)
+    trainer = Trainer(logger=logger)
+    model.trainer = trainer
+    assert model.loggers == [logger]
+
+
 def test_params_groups_and_state_are_accessible(tmpdir):
     class TestModel(BoringModel):
         def training_step(self, batch, batch_idx, optimizer_idx):

tests/trainer/properties/test_loggers.py

@@ -0,0 +1,85 @@
+# Copyright The PyTorch Lightning team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pytorch_lightning import Trainer
+from pytorch_lightning.loggers import LoggerCollection, TensorBoardLogger
+from tests.loggers.test_base import CustomLogger
+
+
+def test_trainer_loggers_property():
+    """Test for correct initialization of loggers in Trainer."""
+    logger1 = CustomLogger()
+    logger2 = CustomLogger()
+
+    # trainer.loggers should be a copy of the input list
+    trainer = Trainer(logger=[logger1, logger2])
+
+    assert trainer.loggers == [logger1, logger2]
+
+    # trainer.loggers should create a list of size 1
+    trainer = Trainer(logger=logger1)
+
+    assert trainer.loggers == [logger1]
+
+    # trainer.loggers should be an empty list
+    trainer = Trainer(logger=False)
+
+    assert trainer.loggers == []
+
+    # trainer.loggers should be a list of size 1 holding the default logger
+    trainer = Trainer(logger=True)
+
+    assert trainer.loggers == [trainer.logger]
+    assert type(trainer.loggers[0]) == TensorBoardLogger
+
+
+def test_trainer_loggers_setters():
+    """Test the behavior of setters for trainer.logger and trainer.loggers."""
+    logger1 = CustomLogger()
+    logger2 = CustomLogger()
+    logger_collection = LoggerCollection([logger1, logger2])
+
+    trainer = Trainer()
+    assert type(trainer.logger) == TensorBoardLogger
+    assert trainer.loggers == [trainer.logger]
+
+    # Test setters for trainer.logger
+    trainer.logger = logger1
+    assert trainer.logger == logger1
+    assert trainer.loggers == [logger1]
+
+    trainer.logger = logger_collection
+    assert trainer.logger._logger_iterable == logger_collection._logger_iterable
+    assert trainer.loggers == [logger1, logger2]
+
+    trainer.logger = None
+    assert trainer.logger is None
+    assert trainer.loggers == []
+
+    # Test setters for trainer.loggers
+    trainer.loggers = [logger1, logger2]
+    assert trainer.loggers == [logger1, logger2]
+    assert trainer.logger._logger_iterable == logger_collection._logger_iterable
+
+    trainer.loggers = [logger1]
+    assert trainer.loggers == [logger1]
+    assert trainer.logger == logger1
+
+    trainer.loggers = []
+    assert trainer.loggers == []
+    assert trainer.logger is None
+
+    trainer.loggers = None
+    assert trainer.loggers == []
+    assert trainer.logger is None