monai-weekly 1.5.dev2506__py3-none-any.whl → 1.5.dev2508__py3-none-any.whl

tests/handlers/test_handler_decollate_batch.py

@@ -0,0 +1,66 @@
+# Copyright (c) MONAI Consortium
+# 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 __future__ import annotations
+
+import unittest
+
+import torch
+
+from monai.engines import SupervisedEvaluator
+from monai.handlers import DecollateBatch, PostProcessing
+from monai.transforms import Activationsd, AsDiscreted, Compose, CopyItemsd
+from tests.test_utils import assert_allclose
+
+
+class TestHandlerDecollateBatch(unittest.TestCase):
+    def test_compute(self):
+        data = [
+            {"image": torch.tensor([[[[2.0], [3.0]]]]), "filename": ["test1"]},
+            {"image": torch.tensor([[[[6.0], [8.0]]]]), "filename": ["test2"]},
+        ]
+
+        handlers = [
+            DecollateBatch(event="MODEL_COMPLETED"),
+            PostProcessing(
+                transform=Compose(
+                    [
+                        Activationsd(keys="pred", sigmoid=True),
+                        CopyItemsd(keys="filename", times=1, names="filename_bak"),
+                        AsDiscreted(keys="pred", threshold=0.5, to_onehot=2),
+                    ]
+                )
+            ),
+        ]
+        # set up engine, PostProcessing handler works together with postprocessing transforms of engine
+        engine = SupervisedEvaluator(
+            device=torch.device("cpu:0"),
+            val_data_loader=data,
+            epoch_length=2,
+            network=torch.nn.PReLU(),
+            # set decollate=False and execute some postprocessing first, then decollate in handlers
+            postprocessing=lambda x: dict(pred=x["pred"] + 1.0),
+            decollate=False,
+            val_handlers=handlers,
+        )
+        engine.run()
+
+        expected = torch.tensor([[[[1.0], [1.0]], [[0.0], [0.0]]]])
+
+        for o, e in zip(engine.state.output, expected):
+            assert_allclose(o["pred"], e)
+            filename = o.get("filename_bak")
+            if filename is not None:
+                self.assertEqual(filename, "test2")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_early_stop.py

@@ -0,0 +1,68 @@
+# Copyright (c) MONAI Consortium
+# 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 __future__ import annotations
+
+import unittest
+
+from ignite.engine import Engine, Events
+
+from monai.handlers import EarlyStopHandler
+
+
+class TestHandlerEarlyStop(unittest.TestCase):
+
+    def test_early_stop_train_loss(self):
+
+        def _train_func(engine, batch):
+            return {"loss": 1.5}
+
+        trainer = Engine(_train_func)
+        EarlyStopHandler(
+            patience=5, score_function=lambda x: x.state.output["loss"], trainer=trainer, epoch_level=False
+        ).attach(trainer)
+
+        trainer.run(range(4), max_epochs=2)
+        self.assertEqual(trainer.state.iteration, 6)
+        self.assertEqual(trainer.state.epoch, 2)
+
+    def test_early_stop_val_metric(self):
+
+        def _train_func(engine, batch):
+            pass
+
+        trainer = Engine(_train_func)
+        validator = Engine(_train_func)
+        validator.state.metrics["val_acc"] = 0.90
+
+        @trainer.on(Events.EPOCH_COMPLETED)
+        def run_validation(engine):
+            validator.state.metrics["val_acc"] += 0.01
+            validator.run(range(3))
+
+        handler = EarlyStopHandler(
+            patience=3,
+            score_function=lambda x: x.state.metrics["val_acc"],
+            trainer=None,
+            min_delta=0.1,
+            cumulative_delta=True,
+            epoch_level=True,
+        )
+        handler.attach(validator)
+        handler.set_trainer(trainer=trainer)
+
+        trainer.run(range(3), max_epochs=5)
+        self.assertEqual(trainer.state.iteration, 12)
+        self.assertEqual(trainer.state.epoch, 4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_garbage_collector.py

@@ -0,0 +1,73 @@
+# Copyright (c) MONAI Consortium
+# 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 __future__ import annotations
+
+import gc
+import unittest
+from unittest import skipUnless
+
+import torch
+from ignite.engine import Engine
+from parameterized import parameterized
+
+from monai.data import Dataset
+from monai.handlers import GarbageCollector
+from monai.utils import IgniteInfo, min_version, optional_import
+
+Events, has_ignite = optional_import("ignite.engine", IgniteInfo.OPT_IMPORT_VERSION, min_version, "Events")
+
+TEST_CASE_0 = [[0, 1, 2], "epoch"]
+
+TEST_CASE_1 = [[0, 1, 2], "iteration"]
+
+TEST_CASE_2 = [[0, 1, 2], Events.EPOCH_COMPLETED]
+
+
+class TestHandlerGarbageCollector(unittest.TestCase):
+
+    @skipUnless(has_ignite, "Requires ignite")
+    @parameterized.expand([TEST_CASE_0, TEST_CASE_1, TEST_CASE_2])
+    def test_content(self, data, trigger_event):
+        # set up engine
+        gb_count_dict = {}
+
+        def _train_func(engine, batch):
+            # store garbage collection counts
+            if trigger_event == Events.EPOCH_COMPLETED or trigger_event.lower() == "epoch":
+                if engine.state.iteration % engine.state.epoch_length == 1:
+                    gb_count_dict[engine.state.epoch] = gc.get_count()
+            elif trigger_event.lower() == "iteration":
+                gb_count_dict[engine.state.iteration] = gc.get_count()
+
+        engine = Engine(_train_func)
+
+        # set up testing handler
+        dataset = Dataset(data, transform=None)
+        data_loader = torch.utils.data.DataLoader(dataset, batch_size=1)
+        GarbageCollector(trigger_event=trigger_event, log_level=30).attach(engine)
+
+        engine.run(data_loader, max_epochs=5)
+
+        first_count = 0
+        for iter, gb_count in gb_count_dict.items():
+            # At least one zero-generation object is collected
+            # self.assertGreaterEqual(gb_count[0], 0)
+            if iter > 1:
+                # Since we are collecting all objects from all generations manually at each call,
+                # starting from the second call, there shouldn't be any 1st and 2nd
+                # generation objects available to collect.
+                self.assertEqual(gb_count[1], first_count)
+                self.assertEqual(gb_count[2], first_count)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_hausdorff_distance.py

@@ -0,0 +1,111 @@
+# Copyright (c) MONAI Consortium
+# 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 __future__ import annotations
+
+import unittest
+
+import numpy as np
+import torch
+from ignite.engine import Engine
+
+from monai.handlers import HausdorffDistance
+from tests.test_utils import assert_allclose
+
+
+def create_spherical_seg_3d(
+    radius: float = 20.0, centre: tuple[int, int, int] = (49, 49, 49), im_shape: tuple[int, int, int] = (99, 99, 99)
+) -> np.ndarray:
+    """
+    Return a 3D image with a sphere inside. Voxel values will be
+    1 inside the sphere, and 0 elsewhere.
+
+    Args:
+        radius: radius of sphere (in terms of number of voxels, can be partial)
+        centre: location of sphere centre.
+        im_shape: shape of image to create
+
+    See also:
+        :py:meth:`~create_test_image_3d`
+    """
+    # Create image
+    image = np.zeros(im_shape, dtype=np.int32)
+    spy, spx, spz = np.ogrid[
+        -centre[0] : im_shape[0] - centre[0], -centre[1] : im_shape[1] - centre[1], -centre[2] : im_shape[2] - centre[2]
+    ]
+    circle = (spx * spx + spy * spy + spz * spz) <= radius * radius
+
+    image[circle] = 1
+    image[~circle] = 0
+    return image
+
+
+sampler_sphere = torch.Tensor(create_spherical_seg_3d(radius=20, centre=(20, 20, 20))).unsqueeze(0).unsqueeze(0)
+# test input a list of channel-first tensor
+sampler_sphere_gt = [torch.Tensor(create_spherical_seg_3d(radius=20, centre=(10, 20, 20))).unsqueeze(0)]
+sampler_sphere_zeros = torch.zeros_like(sampler_sphere)
+
+TEST_SAMPLE_1 = [sampler_sphere, sampler_sphere_gt]
+TEST_SAMPLE_2 = [sampler_sphere_gt, sampler_sphere_gt]
+TEST_SAMPLE_3 = [sampler_sphere_zeros, sampler_sphere_gt]
+TEST_SAMPLE_4 = [sampler_sphere_zeros, sampler_sphere_zeros]
+
+
+class TestHandlerHausdorffDistance(unittest.TestCase):
+    # TODO test multi node Hausdorff Distance
+
+    def test_compute(self):
+        hd_metric = HausdorffDistance(include_background=True)
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        hd_metric.attach(engine, "hausdorff_distance")
+
+        y_pred, y = TEST_SAMPLE_1
+        hd_metric.update([y_pred, y])
+        self.assertEqual(hd_metric.compute(), 10)
+        y_pred, y = TEST_SAMPLE_2
+        hd_metric.update([y_pred, y])
+        self.assertEqual(hd_metric.compute(), 5)
+        y_pred, y = TEST_SAMPLE_3
+        hd_metric.update([y_pred, y])
+        self.assertEqual(hd_metric.compute(), float("inf"))
+        y_pred, y = TEST_SAMPLE_4
+        hd_metric.update([y_pred, y])
+        self.assertEqual(hd_metric.compute(), float("inf"))
+
+    def test_shape_mismatch(self):
+        hd_metric = HausdorffDistance(include_background=True)
+        with self.assertRaises((AssertionError, ValueError)):
+            y_pred = TEST_SAMPLE_1[0]
+            y = torch.ones((1, 1, 10, 10, 10))
+            hd_metric.update([y_pred, y])
+
+    def test_reduction(self):
+        hd_metric = HausdorffDistance(include_background=True, reduction="mean_channel")
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        hd_metric.attach(engine, "hausdorff_distance")
+
+        y_pred, y = TEST_SAMPLE_1
+        hd_metric.update([y_pred, y])
+        y_pred, y = TEST_SAMPLE_2
+        hd_metric.update([y_pred, y])
+        assert_allclose(hd_metric.compute().float(), torch.tensor([10.0, 0.0]))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_ignite_metric.py

@@ -0,0 +1,191 @@
+# Copyright (c) MONAI Consortium
+# 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 __future__ import annotations
+
+import unittest
+
+import torch
+from parameterized import parameterized
+
+from monai.handlers import IgniteMetricHandler, from_engine
+from monai.losses import DiceLoss
+from monai.metrics import LossMetric
+from tests.test_utils import SkipIfNoModule, assert_allclose, optional_import
+
+try:
+    _, has_ignite = optional_import("ignite")
+    from ignite.engine import Engine, Events
+except ImportError:
+    has_ignite = False
+
+TEST_CASE_1 = [
+    {"reduction": "none", "include_background": True},
+    {},
+    {"output_transform": from_engine(["pred", "label"])},
+    0.25,
+]
+TEST_CASE_2 = [
+    {"reduction": "mean", "include_background": False},
+    {},
+    {"output_transform": from_engine(["pred", "label"])},
+    0.5,
+]
+TEST_CASE_3 = [
+    {"reduction": "none"},
+    {"reduction": "mean_channel"},
+    {"output_transform": from_engine(["pred", "label"])},
+    torch.Tensor([0.5, 0]),
+]
+
+TEST_CASES = [
+    [
+        {"include_background": True, "smooth_nr": 1e-6, "smooth_dr": 1e-6},
+        {
+            "input": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]]),
+            "target": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]]),
+        },
+        0,
+    ],
+    [
+        {"include_background": False, "smooth_nr": 1e-6, "smooth_dr": 1e-6},
+        {
+            "input": torch.tensor([[[[0.0, 0.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]]]]),
+            "target": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]]),
+        },
+        0,
+    ],
+    [
+        {"include_background": True, "smooth_nr": 1e-6, "smooth_dr": 1e-6},
+        {
+            "input": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]]),
+            "target": torch.tensor([[[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]]]),
+        },
+        1,
+    ],
+    [
+        {"include_background": False, "smooth_nr": 1e-6, "smooth_dr": 1e-6},
+        {
+            "input": torch.tensor([[[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]]]),
+            "target": torch.tensor([[[[0.0, 0.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]]]]),
+        },
+        1,
+    ],
+    [
+        {"include_background": True, "smooth_nr": 1e-6, "smooth_dr": 1e-6},
+        {
+            "input": torch.tensor([[[[0.0, 1.0], [0.0, 1.0]], [[0.0, 1.0], [0.0, 1.0]]]]),
+            "target": torch.tensor([[[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]]),
+        },
+        0.333333,
+    ],
+    [
+        {"include_background": False, "smooth_nr": 1e-6, "smooth_dr": 1e-6},
+        {
+            "input": torch.tensor([[[[0.0, 1.0], [0.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]]),
+            "target": torch.tensor([[[[1.0, 0.0], [1.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]]]]),
+        },
+        0,
+    ],
+]
+
+
+class TestHandlerIgniteMetricHandler(unittest.TestCase):
+    @SkipIfNoModule("ignite")
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_metric_fn(self, loss_params, metric_params, handler_params, expected_avg):
+        loss_fn = DiceLoss(**loss_params)
+        metric_fn = LossMetric(loss_fn=loss_fn, **metric_params)
+        ignite_metric = IgniteMetricHandler(metric_fn=metric_fn, **handler_params)
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        ignite_metric.attach(engine=engine, name="ignite_dice_loss")
+        y_pred = torch.tensor([[[[0.0, 1.0]], [[1.0, 0.0]]]])
+        y = torch.tensor([[[[0.0, 1.0]], [[0.0, 1.0]]]])
+        engine.state.output = {"pred": y_pred, "label": y}
+        engine.fire_event(Events.ITERATION_COMPLETED)
+
+        y_pred = torch.tensor([[[[0.0, 1.0]], [[1.0, 0.0]]]])
+        y = torch.tensor([[[[0.0, 1.0]], [[1.0, 0.0]]]])
+        engine.state.output = {"pred": y_pred, "label": y}
+        engine.fire_event(Events.ITERATION_COMPLETED)
+
+        engine.fire_event(Events.EPOCH_COMPLETED)
+        assert_allclose(engine.state.metrics["ignite_dice_loss"], expected_avg, atol=1e-4, rtol=1e-4, type_test=False)
+
+    @SkipIfNoModule("ignite")
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_loss_fn(self, loss_params, metric_params, handler_params, expected_avg):
+        loss_fn = DiceLoss(**loss_params)
+        ignite_metric = IgniteMetricHandler(loss_fn=loss_fn, **handler_params, **metric_params)
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        ignite_metric.attach(engine=engine, name="ignite_dice_loss")
+        y_pred = torch.tensor([[[[0.0, 1.0]], [[1.0, 0.0]]]])
+        y = torch.tensor([[[[0.0, 1.0]], [[0.0, 1.0]]]])
+        engine.state.output = {"pred": y_pred, "label": y}
+        engine.fire_event(Events.ITERATION_COMPLETED)
+
+        y_pred = torch.tensor([[[[0.0, 1.0]], [[1.0, 0.0]]]])
+        y = torch.tensor([[[[0.0, 1.0]], [[1.0, 0.0]]]])
+        engine.state.output = {"pred": y_pred, "label": y}
+        engine.fire_event(Events.ITERATION_COMPLETED)
+
+        engine.fire_event(Events.EPOCH_COMPLETED)
+        assert_allclose(engine.state.metrics["ignite_dice_loss"], expected_avg, atol=1e-4, rtol=1e-4, type_test=False)
+
+    @SkipIfNoModule("ignite")
+    @parameterized.expand(TEST_CASES)
+    def test_dice_loss(self, input_param, input_data, expected_val):
+        loss_fn = DiceLoss(**input_param)
+        ignite_metric = IgniteMetricHandler(loss_fn=loss_fn, output_transform=from_engine(["pred", "label"]))
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        ignite_metric.attach(engine=engine, name="ignite_dice_loss")
+        y_pred = input_data["input"]
+        y = input_data["target"]
+        engine.state.output = {"pred": y_pred, "label": y}
+        engine.fire_event(Events.ITERATION_COMPLETED)
+
+        engine.fire_event(Events.EPOCH_COMPLETED)
+        assert_allclose(engine.state.metrics["ignite_dice_loss"], expected_val, atol=1e-4, rtol=1e-4, type_test=False)
+
+    @SkipIfNoModule("ignite")
+    @parameterized.expand(TEST_CASES[0:2])
+    def test_old_ignite_metric(self, input_param, input_data, expected_val):
+        loss_fn = DiceLoss(**input_param)
+        ignite_metric = IgniteMetricHandler(loss_fn=loss_fn, output_transform=from_engine(["pred", "label"]))
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        ignite_metric.attach(engine=engine, name="ignite_dice_loss")
+        y_pred = input_data["input"]
+        y = input_data["target"]
+        engine.state.output = {"pred": y_pred, "label": y}
+        engine.fire_event(Events.ITERATION_COMPLETED)
+
+        engine.fire_event(Events.EPOCH_COMPLETED)
+        assert_allclose(engine.state.metrics["ignite_dice_loss"], expected_val, atol=1e-4, rtol=1e-4, type_test=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_lr_scheduler.py

@@ -0,0 +1,94 @@
+# Copyright (c) MONAI Consortium
+# 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 __future__ import annotations
+
+import logging
+import os
+import re
+import tempfile
+import unittest
+
+import numpy as np
+import torch
+from ignite.engine import Engine, Events
+
+from monai.handlers import LrScheduleHandler
+
+
+class TestHandlerLrSchedule(unittest.TestCase):
+
+    def test_content(self):
+        data = [0] * 8
+        test_lr = 0.1
+        gamma = 0.1
+
+        # set up engine
+        def _train_func(engine, batch):
+            pass
+
+        val_engine = Engine(_train_func)
+        train_engine = Engine(_train_func)
+
+        @train_engine.on(Events.EPOCH_COMPLETED)
+        def run_validation(engine):
+            val_engine.run(data)
+            val_engine.state.metrics["val_loss"] = 1
+
+        # set up testing handler
+        net = torch.nn.PReLU()
+
+        def _reduce_lr_on_plateau():
+            optimizer = torch.optim.SGD(net.parameters(), test_lr)
+            lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=1)
+            handler = LrScheduleHandler(lr_scheduler, step_transform=lambda x: val_engine.state.metrics["val_loss"])
+            handler.attach(train_engine)
+            return handler
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            key_to_handler = "test_log_lr"
+            key_to_print = "Current learning rate"
+            filename = os.path.join(tempdir, "test_lr.log")
+            # test with additional logging handler
+            file_saver = logging.FileHandler(filename, mode="w")
+            file_saver.setLevel(logging.INFO)
+            logger = logging.getLogger(key_to_handler)
+            logger.setLevel(logging.INFO)
+            logger.addHandler(file_saver)
+
+            def _reduce_on_step():
+                optimizer = torch.optim.SGD(net.parameters(), test_lr)
+                lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=2, gamma=gamma)
+                handler = LrScheduleHandler(lr_scheduler, name=key_to_handler)
+                handler.attach(train_engine)
+                return handler
+
+            schedulers = _reduce_lr_on_plateau(), _reduce_on_step()
+
+            train_engine.run(data, max_epochs=5)
+            file_saver.close()
+            logger.removeHandler(file_saver)
+
+            with open(filename) as f:
+                output_str = f.read()
+                has_key_word = re.compile(f".*{key_to_print}.*")
+                content_count = 0
+                for line in output_str.split("\n"):
+                    if has_key_word.match(line):
+                        content_count += 1
+                self.assertTrue(content_count > 0)
+
+        for scheduler in schedulers:
+            np.testing.assert_allclose(scheduler.lr_scheduler._last_lr[0], 0.001)
+
+
+if __name__ == "__main__":
+    unittest.main()