From f2837dd08b93f76d472b46b69bef4ab8b11cfc0d Mon Sep 17 00:00:00 2001 From: Bjarten Date: Mon, 14 Oct 2024 17:06:01 +0900 Subject: [PATCH 1/7] feat: use val best val loss instaed of best score --- pytorchtools.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/pytorchtools.py b/pytorchtools.py index 4a8db9c..770b1d4 100644 --- a/pytorchtools.py +++ b/pytorchtools.py @@ -3,6 +3,7 @@ import numpy as np import torch + class EarlyStopping: """Early stops the training if validation loss doesn't improve after a given patience.""" def __init__(self, patience=7, verbose=False, delta=0, path='checkpoint.pt', trace_func=print): @@ -10,7 +11,7 @@ def __init__(self, patience=7, verbose=False, delta=0, path='checkpoint.pt', tra Args: patience (int): How long to wait after last time validation loss improved. Default: 7 - verbose (bool): If True, prints a message for each validation loss improvement. + verbose (bool): If True, prints a message for each validation loss improvement. Default: False delta (float): Minimum change in the monitored quantity to qualify as an improvement. Default: 0 @@ -22,26 +23,25 @@ def __init__(self, patience=7, verbose=False, delta=0, path='checkpoint.pt', tra self.patience = patience self.verbose = verbose self.counter = 0 - self.best_score = None + self.best_val_loss = None self.early_stop = False - self.val_loss_min = np.Inf + self.val_loss_min = np.inf self.delta = delta self.path = path self.trace_func = trace_func - def __call__(self, val_loss, model): - score = -val_loss + def __call__(self, val_loss, model): - if self.best_score is None: - self.best_score = score + if self.best_val_loss is None: + self.best_val_loss = val_loss self.save_checkpoint(val_loss, model) - elif score < self.best_score + self.delta: + elif val_loss > self.best_val_loss - self.delta: self.counter += 1 self.trace_func(f'EarlyStopping counter: {self.counter} out of {self.patience}') if self.counter >= self.patience: self.early_stop = True else: - self.best_score = score + self.best_val_loss = val_loss self.save_checkpoint(val_loss, model) self.counter = 0 From 2e6e56a4fb79eaec9af3e7fbe9f21f787803c8a6 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Mon, 14 Oct 2024 18:22:03 +0900 Subject: [PATCH 2/7] ci: add unit tests --- tests/__init__.py | 0 tests/test_early_stopping.py | 333 +++++++++++++++++++++++++++++++++++ 2 files changed, 333 insertions(+) create mode 100644 tests/__init__.py create mode 100644 tests/test_early_stopping.py diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_early_stopping.py b/tests/test_early_stopping.py new file mode 100644 index 0000000..eb75d3d --- /dev/null +++ b/tests/test_early_stopping.py @@ -0,0 +1,333 @@ +# test_early_stopping.py + +import pytest +from unittest.mock import Mock, patch +import torch +import numpy as np + +from pytorchtools import EarlyStopping + +# Fixtures to mock model and temporary checkpoint path + +@pytest.fixture +def mock_model(): + """ + Fixture to create a mock PyTorch model. + + Returns: + Mock: A mocked PyTorch model with a predefined state_dict. + """ + model = Mock(spec=torch.nn.Module) + model.state_dict.return_value = {'param': 'value'} + return model + +@pytest.fixture +def temp_checkpoint_path(tmp_path): + """ + Fixture to create a temporary checkpoint file path. + + Args: + tmp_path (Path): Pytest's built-in fixture providing a temporary directory. + + Returns: + str: String representation of the temporary checkpoint file path. + """ + checkpoint_file = tmp_path / "checkpoint.pt" + return str(checkpoint_file) + +# Tests + +def test_initialization(): + """ + Test the initialization of the EarlyStopping class to ensure all attributes are set correctly. + + This test verifies that upon instantiation, the EarlyStopping object has its parameters and internal + counters initialized as expected. + """ + # Initialize EarlyStopping with specific parameters + early_stopping = EarlyStopping(patience=5, verbose=True, delta=0.01) + + # Assert that all attributes are correctly initialized + assert early_stopping.patience == 5, "Patience should be set to 5" + assert early_stopping.verbose is True, "Verbose should be True" + assert early_stopping.delta == 0.01, "Delta should be set to 0.01" + assert early_stopping.counter == 0, "Counter should be initialized to 0" + assert early_stopping.best_val_loss is None, "Best score should be None initially" + assert early_stopping.early_stop is False, "Early stop flag should be False initially" + assert early_stopping.val_loss_min == np.inf, "Initial val_loss_min should be infinity" + +def test_initial_call_saves_checkpoint(mock_model, temp_checkpoint_path): + """ + Test that the initial call to EarlyStopping saves the model checkpoint and updates best_val_loss. + + This test ensures that when EarlyStopping is called for the first time with a validation loss, + it correctly saves the model's state_dict and updates the best_val_loss accordingly. + + Args: + mock_model (Mock): A mocked PyTorch model. + temp_checkpoint_path (str): Temporary file path for saving the checkpoint. + """ + # Patch the torch.save method used inside EarlyStopping to prevent actual file I/O + with patch('pytorchtools.torch.save') as mock_save: + # Initialize EarlyStopping with specified parameters + early_stopping = EarlyStopping(patience=5, verbose=False, path=temp_checkpoint_path) + + # Simulate the first validation loss + initial_val_loss = 1.0 + early_stopping(initial_val_loss, mock_model) + + # Assert that model.state_dict() was called once + mock_model.state_dict.assert_called_once_with() + # Assert that torch.save was called once with correct arguments + mock_save.assert_called_once_with(mock_model.state_dict(), temp_checkpoint_path) + # Assert that best_val_loss was set correctly + assert early_stopping.best_val_loss == initial_val_loss, "Best score should be set to negative initial_val_loss" + # Assert that early_stop is not triggered + assert not early_stopping.early_stop, "Early stop should not be triggered on initial call" + +def test_validation_loss_improves(mock_model, temp_checkpoint_path): + """ + Test that validation loss improvements trigger checkpoint saving and reset the patience counter. + + This test simulates a sequence of validation losses that consistently improve. It verifies that + EarlyStopping saves the model checkpoint each time an improvement is detected and that the + patience counter remains at zero, indicating no need to stop early. + + Args: + mock_model (Mock): A mocked PyTorch model. + temp_checkpoint_path (str): Temporary file path for saving the checkpoint. + """ + # Patch the torch.save method used inside EarlyStopping + with patch('pytorchtools.torch.save') as mock_save: + # Initialize EarlyStopping with specified parameters + early_stopping = EarlyStopping(patience=5, verbose=False, path=temp_checkpoint_path) + + # Simulate a series of improving validation losses + losses = [1.0, 0.9, 0.8, 0.85, 0.75] + for loss in losses: + early_stopping(loss, mock_model) + + # Assert that torch.save was called once for the initial loss and three times for improvements + assert mock_save.call_count == 4, "Checkpoints should be saved on initial and 3 improvements" + # Assert that the patience counter remains at 0 after each improvement + assert early_stopping.counter == 0, "Counter should be reset to 0 after improvements" + # Assert that early stopping was not triggered + assert not early_stopping.early_stop, "Early stop should not be triggered when losses improve" + +def test_validation_loss_no_improvement_within_delta(mock_model, temp_checkpoint_path): + """ + Test that the patience counter increments when validation loss does not improve beyond delta. + + This test simulates a scenario where validation losses do not improve sufficiently (i.e., the + improvement is less than the specified delta). It verifies that the patience counter increments + correctly and that early stopping is triggered once the patience threshold is exceeded. + + Args: + mock_model (Mock): A mocked PyTorch model. + temp_checkpoint_path (str): Temporary file path for saving the checkpoint. + """ + # Patch the save_checkpoint method to monitor its calls directly + with patch.object(EarlyStopping, 'save_checkpoint') as mock_save_checkpoint: + # Initialize EarlyStopping with specified parameters + early_stopping = EarlyStopping( + patience=3, # Number of epochs to wait for improvement + verbose=False, # Disable verbose output + delta=0.01, # Minimum improvement to qualify as an improvement + path=temp_checkpoint_path # Path to save the checkpoint + ) + + # First sequence of validation losses with sufficient improvements + initial_losses = [1.0, 0.98, 0.97, 0.97, 0.95, 0.95] + for loss in initial_losses: + early_stopping(loss, mock_model) + + # After processing initial_losses: + # - Checkpoints should be saved on initial call and on each improvement (Epochs 1, 2, 3, 5) + # - Total save_checkpoint calls: 2 + # - Patience counter should have incremented to 1 (from Epoch 6) + # - Early stopping should not have been triggered yet + + # Assert that save_checkpoint was called three times: initial call and three improvements + assert mock_save_checkpoint.call_count == 3, "Checkpoints should be saved on initial and three improvements" + + # Assert that the patience counter has incremented to 1 (only Epoch 6 incremented it) + assert early_stopping.counter == 1, "Counter should be incremented to 1" + + # Assert that early stopping has not been triggered yet + assert early_stopping.early_stop is False, "Early stop should not be triggered yet" + + # Second sequence of validation losses that do not improve beyond delta + worsening_losses = [1.0, 1.1] + for loss in worsening_losses: + early_stopping(loss, mock_model) + + # After processing worsening_losses: + # - No checkpoints should be saved since losses are worsening + # - Patience counter should increment by 2 (from 1 to 3) + # - Early stopping should be triggered as patience is exceeded + + # Assert that save_checkpoint was still called three times (no new saves) + assert mock_save_checkpoint.call_count == 3, "No additional checkpoints should be saved as losses worsen" + + # Assert that the patience counter has incremented to 3 + assert early_stopping.counter == 3, "Counter should be incremented to 3" + + # Assert that early stopping was triggered after patience was exceeded + assert early_stopping.early_stop is True, "Early stop should be triggered after patience is exceeded" + + +def test_early_stopping_triggered(mock_model, temp_checkpoint_path): + """ + Test that early stopping is triggered when the patience is exceeded without sufficient improvement. + + This test verifies that when the validation loss does not improve for a number of consecutive epochs + equal to the patience parameter, EarlyStopping sets the early_stop flag to True, indicating that + training should cease. + + Args: + mock_model (Mock): A mocked PyTorch model. + temp_checkpoint_path (str): Temporary file path for saving the checkpoint. + """ + # Patch the save_checkpoint method used inside EarlyStopping to monitor its calls directly + with patch.object(EarlyStopping, 'save_checkpoint') as mock_save_checkpoint: + # Initialize EarlyStopping with specified parameters + early_stopping = EarlyStopping( + patience=2, # Number of epochs to wait for improvement + verbose=True, # Enable verbose output to observe messages + path=temp_checkpoint_path # Path to save the checkpoint + ) + + # Simulate validation losses with no improvement after two patience steps + losses = [1.0, 0.9, 0.85, 0.85, 0.85] + for loss in losses: + early_stopping(loss, mock_model) + + # After processing losses: + # - Checkpoints should be saved on initial call and on each improvement (Epochs 1, 2, 3) + # - Total save_checkpoint calls: 3 + # - Patience counter should have incremented to 2 (from Epochs 4 and 5) + # - Early stopping should be triggered + + # Assert that save_checkpoint was called three times: initial call and two improvements + assert mock_save_checkpoint.call_count == 3, "Checkpoints should be saved on initial and two improvements" + + # Assert that the patience counter has incremented to 2 (from Epochs 4 and 5) + assert early_stopping.counter == 2, "Counter should be incremented to 2" + + # Assert that early stopping was triggered after patience was exceeded + assert early_stopping.early_stop is True, "Early stop should be triggered after patience is exceeded" + +def test_verbose_output(mock_model, temp_checkpoint_path, capsys): + """ + Test that verbose outputs are printed correctly when verbose is enabled. + + This test checks that when the verbose parameter is set to True, EarlyStopping prints + informative messages about validation loss improvements and patience counter increments. + + Args: + mock_model (Mock): A mocked PyTorch model. + temp_checkpoint_path (str): Temporary file path for saving the checkpoint. + capsys: Pytest fixture to capture output to stdout and stderr. + """ + # Patch the torch.save method used inside EarlyStopping to prevent actual file I/O + with patch('pytorchtools.torch.save'): + # Initialize EarlyStopping with verbose enabled + early_stopping = EarlyStopping(patience=2, verbose=True, path=temp_checkpoint_path) + + # Simulate validation losses with and without improvement + losses = [1.0, 0.95, 0.95, 0.95] + for loss in losses: + early_stopping(loss, mock_model) + + # Capture the output printed by the trace_func + captured = capsys.readouterr() + # Check that verbose messages for validation loss decrease are printed + assert 'Validation loss decreased' in captured.out, "Should print validation loss decrease message" + # Check that verbose messages for counter increments are printed + assert 'EarlyStopping counter: 1 out of 2' in captured.out, "Should print first counter increment" + assert 'EarlyStopping counter: 2 out of 2' in captured.out, "Should print second counter increment" + + +def test_no_early_stop_when_validation_improves_within_patience(mock_model, temp_checkpoint_path): + """ + Test that early stopping is not triggered when validation loss continues to improve within patience. + + This test ensures that as long as validation loss keeps improving (even intermittently), the + patience counter does not reach the threshold, and early stopping is not triggered. + + Args: + mock_model (Mock): A mocked PyTorch model. + temp_checkpoint_path (str): Temporary file path for saving the checkpoint. + """ + # Patch the torch.save method used inside EarlyStopping + with patch('pytorchtools.torch.save') as mock_save: + # Initialize EarlyStopping with specified parameters + early_stopping = EarlyStopping(patience=3, verbose=False, path=temp_checkpoint_path) + + # Simulate validation losses with intermittent improvements + losses = [1.0, 0.95, 0.90, 0.85, 0.80, 0.85, 0.80, 0.75] + for loss in losses: + early_stopping(loss, mock_model) + + # Assert that torch.save was called on initial and four improvements + assert mock_save.call_count == 6, "Checkpoints should be saved on initial and five improvements" + # Assert that the patience counter is reset to 0 after each improvement + assert early_stopping.counter == 0, "Counter should be reset to 0 after each improvement" + # Assert that early stopping was not triggered + assert not early_stopping.early_stop, "Early stop should not be triggered when validations continue to improve within patience" + +def test_delta_functionality(mock_model, temp_checkpoint_path): + """ + Test that the delta parameter correctly influences the checkpoint saving behavior. + + This test verifies that when the improvement in validation loss exceeds the delta threshold, + EarlyStopping saves the model checkpoint and resets the patience counter. However, once early stopping is + triggered, the early_stop flag remains True even after a significant improvement. + + Args: + mock_model (Mock): A mocked PyTorch model. + temp_checkpoint_path (str): Temporary file path for saving the checkpoint. + """ + # Patch the save_checkpoint method of EarlyStopping to monitor its calls directly + with patch.object(EarlyStopping, 'save_checkpoint') as mock_save_checkpoint: + # Ensure that the mocked model's state_dict returns a valid state + mock_model.state_dict.return_value = {'layer1.weight': torch.tensor([1, 2, 3])} + + # Initialize EarlyStopping with delta set to 0.1 + early_stopping = EarlyStopping( + patience=3, # Number of epochs to wait for improvement + verbose=False, # Disable verbose output + delta=0.1, # Minimum improvement to qualify as an improvement + path=temp_checkpoint_path # Path to save the checkpoint + ) + + # Simulate validation losses with varying improvements + losses = [1.0, 0.95, 0.91, 0.9, 0.79] + for loss in losses: + early_stopping(loss, mock_model) + + # Expected behavior: + # Initial loss: 1.0 (save) + # 0.95: improvement of 0.05 (less than delta=0.1) -> no save, counter=1 + # 0.91: improvement of 0.04 (less than delta=0.1) -> no save, counter=2 + # 0.9: improvement of 0.01 (less than delta=0.1) -> no save, counter=3 + # 0.79: improvement of 0.11 (larger than delta=0.1) -> save, counter reset to 0, but early_stop still True + + # Assert that save_checkpoint was called on initial and final significant improvement + assert mock_save_checkpoint.call_count == 2, "Checkpoints should be saved on initial and final significant improvements (delta=0.1)" + + # Assert that the patience counter was reset after the final improvement + assert early_stopping.counter == 0, "Counter should be reset after significant improvements" + + # Simulate further validation losses that do not improve beyond delta + worsening_losses = [0.8, 1.1] + for loss in worsening_losses: + early_stopping(loss, mock_model) + + # Since early stop was already triggered earlier, it should remain True + assert early_stopping.early_stop, "Early stop should remain True after it was triggered" + + # Assert no new checkpoints were saved after early stopping was triggered + assert mock_save_checkpoint.call_count == 2, "No additional checkpoints should be saved after early stopping was triggered" + + From eb947c61281a57d530d049f1b656dd81354ab096 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 11:16:37 +0900 Subject: [PATCH 3/7] fix: handle best_val_loss correct --- pytorchtools.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/pytorchtools.py b/pytorchtools.py index 770b1d4..39e6d2f 100644 --- a/pytorchtools.py +++ b/pytorchtools.py @@ -35,18 +35,20 @@ def __call__(self, val_loss, model): if self.best_val_loss is None: self.best_val_loss = val_loss self.save_checkpoint(val_loss, model) - elif val_loss > self.best_val_loss - self.delta: + elif val_loss < self.best_val_loss - self.delta: + # Significant improvement detected + self.best_val_loss = val_loss + self.save_checkpoint(val_loss, model) + self.counter = 0 # Reset counter since improvement occurred + else: + # No significant improvement self.counter += 1 self.trace_func(f'EarlyStopping counter: {self.counter} out of {self.patience}') if self.counter >= self.patience: self.early_stop = True - else: - self.best_val_loss = val_loss - self.save_checkpoint(val_loss, model) - self.counter = 0 def save_checkpoint(self, val_loss, model): - '''Saves model when validation loss decrease.''' + '''Saves model when validation loss decreases.''' if self.verbose: self.trace_func(f'Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}). Saving model ...') torch.save(model.state_dict(), self.path) From 8ff0acde48c4d24764ce1ba3b3eaf523408e16cb Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 11:18:29 +0900 Subject: [PATCH 4/7] ci: add tests workflow --- .github/workflows/release.yml | 2 +- .github/workflows/tests.yml | 41 +++++++++++++++++++++++++++++++++++ requirements-dev.txt | 6 +++++ requirements.txt | 1 + tests/test_early_stopping.py | 4 ++-- 5 files changed, 51 insertions(+), 3 deletions(-) create mode 100644 .github/workflows/tests.yml create mode 100644 requirements-dev.txt diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 9a9c45d..738adb3 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -36,7 +36,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install python-semantic-release==9.11.0 # Locking to a specific version + pip install python-semantic-release - name: Configure Git run: | diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml new file mode 100644 index 0000000..cb4ad4a --- /dev/null +++ b/.github/workflows/tests.yml @@ -0,0 +1,41 @@ +name: Python Application Tests + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +jobs: + test: + runs-on: ubuntu-latest + + strategy: + matrix: + python-version: ['3.9', '3.10', '3.11', '3.12'] + + steps: + # Step 1: Checkout the repository + - name: Checkout repository + uses: actions/checkout@v4 + + # Step 2: Set up Python + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + cache: 'pip' + + # Step 3: Install dependencies + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements.txt + + # Step 4: Install pytest (if not in requirements.txt) + - name: Install pytest + run: pip install pytest + + # Step 5: Run tests + - name: Run tests + run: pytest diff --git a/requirements-dev.txt b/requirements-dev.txt new file mode 100644 index 0000000..0ea841c --- /dev/null +++ b/requirements-dev.txt @@ -0,0 +1,6 @@ +# requirements-dev.txt +-r requirements.txt +pytest +pytest-mock +coverage +flake8 \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 54da486..1848a4e 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,4 @@ +# requirements.txt matplotlib numpy torchvision diff --git a/tests/test_early_stopping.py b/tests/test_early_stopping.py index eb75d3d..cb6fe5e 100644 --- a/tests/test_early_stopping.py +++ b/tests/test_early_stopping.py @@ -220,10 +220,10 @@ def test_early_stopping_triggered(mock_model, temp_checkpoint_path): def test_verbose_output(mock_model, temp_checkpoint_path, capsys): """ Test that verbose outputs are printed correctly when verbose is enabled. - + This test checks that when the verbose parameter is set to True, EarlyStopping prints informative messages about validation loss improvements and patience counter increments. - + Args: mock_model (Mock): A mocked PyTorch model. temp_checkpoint_path (str): Temporary file path for saving the checkpoint. From 2703ca5819753ae790f44ea61262b85d02e82ae5 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 11:25:55 +0900 Subject: [PATCH 5/7] chore: update requirements-dev.txt --- requirements-dev.txt | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/requirements-dev.txt b/requirements-dev.txt index 0ea841c..147b29d 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,6 +1,4 @@ # requirements-dev.txt -r requirements.txt pytest -pytest-mock -coverage -flake8 \ No newline at end of file +pytest-mock \ No newline at end of file From 4be4f6e8606cc905d1a4a6a8d99f215cfe4e19e7 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 11:26:30 +0900 Subject: [PATCH 6/7] refactor: add double newline after imports --- pytorchtools.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pytorchtools.py b/pytorchtools.py index 39e6d2f..40a59ac 100644 --- a/pytorchtools.py +++ b/pytorchtools.py @@ -4,6 +4,7 @@ import numpy as np import torch + class EarlyStopping: """Early stops the training if validation loss doesn't improve after a given patience.""" def __init__(self, patience=7, verbose=False, delta=0, path='checkpoint.pt', trace_func=print): From 348122e032f121c720356e0958df6e4f816c1d30 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 12:18:11 +0900 Subject: [PATCH 7/7] chore: uodate notebook --- MNIST_Early_Stopping_example.ipynb | 197 +++++++++++++++-------------- 1 file changed, 104 insertions(+), 93 deletions(-) diff --git a/MNIST_Early_Stopping_example.ipynb b/MNIST_Early_Stopping_example.ipynb index 7785f52..cf6b430 100644 --- a/MNIST_Early_Stopping_example.ipynb +++ b/MNIST_Early_Stopping_example.ipynb @@ -108,7 +108,7 @@ " (fc1): Linear(in_features=784, out_features=128, bias=True)\n", " (fc2): Linear(in_features=128, out_features=128, bias=True)\n", " (fc3): Linear(in_features=128, out_features=10, bias=True)\n", - " (dropout): Dropout(p=0.5)\n", + " (dropout): Dropout(p=0.5, inplace=False)\n", ")\n" ] } @@ -266,7 +266,7 @@ " break\n", " \n", " # load the last checkpoint with the best model\n", - " model.load_state_dict(torch.load('checkpoint.pt'))\n", + " model.load_state_dict(torch.load('checkpoint.pt', weights_only=True))\n", "\n", " return model, avg_train_losses, avg_valid_losses" ] @@ -280,100 +280,113 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ 1/100] train_loss: 0.84499 valid_loss: 0.29977\n", - "[ 2/100] train_loss: 0.36182 valid_loss: 0.22742\n", - "Validation loss decreased (inf --> 0.227419). Saving model ...\n", - "[ 3/100] train_loss: 0.29205 valid_loss: 0.19163\n", - "Validation loss decreased (0.227419 --> 0.191628). Saving model ...\n", - "[ 4/100] train_loss: 0.25390 valid_loss: 0.16771\n", - "Validation loss decreased (0.191628 --> 0.167714). Saving model ...\n", - "[ 5/100] train_loss: 0.22671 valid_loss: 0.15422\n", - "Validation loss decreased (0.167714 --> 0.154222). Saving model ...\n", - "[ 6/100] train_loss: 0.20862 valid_loss: 0.14546\n", - "Validation loss decreased (0.154222 --> 0.145459). Saving model ...\n", - "[ 7/100] train_loss: 0.19482 valid_loss: 0.13821\n", - "Validation loss decreased (0.145459 --> 0.138206). Saving model ...\n", - "[ 8/100] train_loss: 0.18431 valid_loss: 0.13398\n", - "Validation loss decreased (0.138206 --> 0.133979). Saving model ...\n", - "[ 9/100] train_loss: 0.17554 valid_loss: 0.12953\n", - "Validation loss decreased (0.133979 --> 0.129535). Saving model ...\n", - "[ 10/100] train_loss: 0.16785 valid_loss: 0.12202\n", - "Validation loss decreased (0.129535 --> 0.122023). Saving model ...\n", - "[ 11/100] train_loss: 0.16202 valid_loss: 0.12249\n", + "[ 1/100] train_loss: 0.83783 valid_loss: 0.31137\n", + "Validation loss decreased (inf --> 0.311369). Saving model ...\n", + "[ 2/100] train_loss: 0.37005 valid_loss: 0.23503\n", + "Validation loss decreased (0.311369 --> 0.235031). Saving model ...\n", + "[ 3/100] train_loss: 0.29645 valid_loss: 0.19488\n", + "Validation loss decreased (0.235031 --> 0.194881). Saving model ...\n", + "[ 4/100] train_loss: 0.25427 valid_loss: 0.17373\n", + "Validation loss decreased (0.194881 --> 0.173730). Saving model ...\n", + "[ 5/100] train_loss: 0.23387 valid_loss: 0.15799\n", + "Validation loss decreased (0.173730 --> 0.157987). Saving model ...\n", + "[ 6/100] train_loss: 0.21357 valid_loss: 0.14634\n", + "Validation loss decreased (0.157987 --> 0.146339). Saving model ...\n", + "[ 7/100] train_loss: 0.20209 valid_loss: 0.13834\n", + "Validation loss decreased (0.146339 --> 0.138335). Saving model ...\n", + "[ 8/100] train_loss: 0.18811 valid_loss: 0.13291\n", + "Validation loss decreased (0.138335 --> 0.132905). Saving model ...\n", + "[ 9/100] train_loss: 0.17865 valid_loss: 0.12881\n", + "Validation loss decreased (0.132905 --> 0.128807). Saving model ...\n", + "[ 10/100] train_loss: 0.17079 valid_loss: 0.12113\n", + "Validation loss decreased (0.128807 --> 0.121127). Saving model ...\n", + "[ 11/100] train_loss: 0.16392 valid_loss: 0.11816\n", + "Validation loss decreased (0.121127 --> 0.118159). Saving model ...\n", + "[ 12/100] train_loss: 0.16054 valid_loss: 0.11620\n", + "Validation loss decreased (0.118159 --> 0.116205). Saving model ...\n", + "[ 13/100] train_loss: 0.15220 valid_loss: 0.11247\n", + "Validation loss decreased (0.116205 --> 0.112469). Saving model ...\n", + "[ 14/100] train_loss: 0.14709 valid_loss: 0.11378\n", "EarlyStopping counter: 1 out of 20\n", - "[ 12/100] train_loss: 0.15300 valid_loss: 0.11852\n", - "Validation loss decreased (0.122023 --> 0.118516). Saving model ...\n", - "[ 13/100] train_loss: 0.14965 valid_loss: 0.11560\n", - "Validation loss decreased (0.118516 --> 0.115598). Saving model ...\n", - "[ 14/100] train_loss: 0.14680 valid_loss: 0.11387\n", - "Validation loss decreased (0.115598 --> 0.113867). Saving model ...\n", - "[ 15/100] train_loss: 0.13988 valid_loss: 0.11728\n", + "[ 15/100] train_loss: 0.14460 valid_loss: 0.11054\n", + "Validation loss decreased (0.112469 --> 0.110544). Saving model ...\n", + "[ 16/100] train_loss: 0.13830 valid_loss: 0.10726\n", + "Validation loss decreased (0.110544 --> 0.107258). Saving model ...\n", + "[ 17/100] train_loss: 0.13689 valid_loss: 0.10741\n", "EarlyStopping counter: 1 out of 20\n", - "[ 16/100] train_loss: 0.13641 valid_loss: 0.11269\n", - "Validation loss decreased (0.113867 --> 0.112686). Saving model ...\n", - "[ 17/100] train_loss: 0.12957 valid_loss: 0.11237\n", - "Validation loss decreased (0.112686 --> 0.112374). Saving model ...\n", - "[ 18/100] train_loss: 0.12862 valid_loss: 0.11198\n", - "Validation loss decreased (0.112374 --> 0.111975). Saving model ...\n", - "[ 19/100] train_loss: 0.12581 valid_loss: 0.10924\n", - "Validation loss decreased (0.111975 --> 0.109242). Saving model ...\n", - "[ 20/100] train_loss: 0.12171 valid_loss: 0.10836\n", - "Validation loss decreased (0.109242 --> 0.108363). Saving model ...\n", - "[ 21/100] train_loss: 0.12191 valid_loss: 0.10922\n", + "[ 18/100] train_loss: 0.13122 valid_loss: 0.10676\n", + "Validation loss decreased (0.107258 --> 0.106764). Saving model ...\n", + "[ 19/100] train_loss: 0.12802 valid_loss: 0.10354\n", + "Validation loss decreased (0.106764 --> 0.103535). Saving model ...\n", + "[ 20/100] train_loss: 0.12939 valid_loss: 0.10285\n", + "Validation loss decreased (0.103535 --> 0.102854). Saving model ...\n", + "[ 21/100] train_loss: 0.12022 valid_loss: 0.10037\n", + "Validation loss decreased (0.102854 --> 0.100375). Saving model ...\n", + "[ 22/100] train_loss: 0.12399 valid_loss: 0.09700\n", + "Validation loss decreased (0.100375 --> 0.097001). Saving model ...\n", + "[ 23/100] train_loss: 0.11651 valid_loss: 0.10024\n", "EarlyStopping counter: 1 out of 20\n", - "[ 22/100] train_loss: 0.11935 valid_loss: 0.10976\n", + "[ 24/100] train_loss: 0.11879 valid_loss: 0.09823\n", "EarlyStopping counter: 2 out of 20\n", - "[ 23/100] train_loss: 0.11901 valid_loss: 0.11053\n", + "[ 25/100] train_loss: 0.11619 valid_loss: 0.10081\n", "EarlyStopping counter: 3 out of 20\n", - "[ 24/100] train_loss: 0.11420 valid_loss: 0.10901\n", + "[ 26/100] train_loss: 0.11205 valid_loss: 0.10083\n", "EarlyStopping counter: 4 out of 20\n", - "[ 25/100] train_loss: 0.11089 valid_loss: 0.10837\n", + "[ 27/100] train_loss: 0.11331 valid_loss: 0.10078\n", "EarlyStopping counter: 5 out of 20\n", - "[ 26/100] train_loss: 0.11008 valid_loss: 0.10944\n", + "[ 28/100] train_loss: 0.10997 valid_loss: 0.10114\n", "EarlyStopping counter: 6 out of 20\n", - "[ 27/100] train_loss: 0.10801 valid_loss: 0.10665\n", - "Validation loss decreased (0.108363 --> 0.106647). Saving model ...\n", - "[ 28/100] train_loss: 0.10433 valid_loss: 0.10248\n", - "Validation loss decreased (0.106647 --> 0.102475). Saving model ...\n", - "[ 29/100] train_loss: 0.10323 valid_loss: 0.10621\n", + "[ 29/100] train_loss: 0.10804 valid_loss: 0.09626\n", + "Validation loss decreased (0.097001 --> 0.096262). Saving model ...\n", + "[ 30/100] train_loss: 0.10787 valid_loss: 0.10086\n", "EarlyStopping counter: 1 out of 20\n", - "[ 30/100] train_loss: 0.10484 valid_loss: 0.10775\n", + "[ 31/100] train_loss: 0.10434 valid_loss: 0.09898\n", "EarlyStopping counter: 2 out of 20\n", - "[ 31/100] train_loss: 0.09985 valid_loss: 0.10616\n", + "[ 32/100] train_loss: 0.10322 valid_loss: 0.09699\n", "EarlyStopping counter: 3 out of 20\n", - "[ 32/100] train_loss: 0.09898 valid_loss: 0.10479\n", + "[ 33/100] train_loss: 0.09873 valid_loss: 0.09826\n", "EarlyStopping counter: 4 out of 20\n", - "[ 33/100] train_loss: 0.10062 valid_loss: 0.10576\n", + "[ 34/100] train_loss: 0.10127 valid_loss: 0.09545\n", + "Validation loss decreased (0.096262 --> 0.095453). Saving model ...\n", + "[ 35/100] train_loss: 0.09834 valid_loss: 0.09980\n", + "EarlyStopping counter: 1 out of 20\n", + "[ 36/100] train_loss: 0.09554 valid_loss: 0.10243\n", + "EarlyStopping counter: 2 out of 20\n", + "[ 37/100] train_loss: 0.10178 valid_loss: 0.09873\n", + "EarlyStopping counter: 3 out of 20\n", + "[ 38/100] train_loss: 0.09442 valid_loss: 0.10022\n", + "EarlyStopping counter: 4 out of 20\n", + "[ 39/100] train_loss: 0.09483 valid_loss: 0.09984\n", "EarlyStopping counter: 5 out of 20\n", - "[ 34/100] train_loss: 0.09704 valid_loss: 0.10770\n", + "[ 40/100] train_loss: 0.09673 valid_loss: 0.10122\n", "EarlyStopping counter: 6 out of 20\n", - "[ 35/100] train_loss: 0.09850 valid_loss: 0.10542\n", + "[ 41/100] train_loss: 0.09409 valid_loss: 0.10010\n", "EarlyStopping counter: 7 out of 20\n", - "[ 36/100] train_loss: 0.09561 valid_loss: 0.10619\n", + "[ 42/100] train_loss: 0.08885 valid_loss: 0.09946\n", "EarlyStopping counter: 8 out of 20\n", - "[ 37/100] train_loss: 0.09381 valid_loss: 0.10745\n", + "[ 43/100] train_loss: 0.08923 valid_loss: 0.10062\n", "EarlyStopping counter: 9 out of 20\n", - "[ 38/100] train_loss: 0.09363 valid_loss: 0.10487\n", + "[ 44/100] train_loss: 0.08976 valid_loss: 0.10242\n", "EarlyStopping counter: 10 out of 20\n", - "[ 39/100] train_loss: 0.09263 valid_loss: 0.10763\n", + "[ 45/100] train_loss: 0.09064 valid_loss: 0.09567\n", "EarlyStopping counter: 11 out of 20\n", - "[ 40/100] train_loss: 0.09234 valid_loss: 0.10778\n", + "[ 46/100] train_loss: 0.08339 valid_loss: 0.10048\n", "EarlyStopping counter: 12 out of 20\n", - "[ 41/100] train_loss: 0.08485 valid_loss: 0.10319\n", + "[ 47/100] train_loss: 0.08805 valid_loss: 0.10472\n", "EarlyStopping counter: 13 out of 20\n", - "[ 42/100] train_loss: 0.09105 valid_loss: 0.10305\n", + "[ 48/100] train_loss: 0.08987 valid_loss: 0.10191\n", "EarlyStopping counter: 14 out of 20\n", - "[ 43/100] train_loss: 0.08963 valid_loss: 0.10952\n", + "[ 49/100] train_loss: 0.08727 valid_loss: 0.10311\n", "EarlyStopping counter: 15 out of 20\n", - "[ 44/100] train_loss: 0.08887 valid_loss: 0.10615\n", + "[ 50/100] train_loss: 0.08554 valid_loss: 0.10606\n", "EarlyStopping counter: 16 out of 20\n", - "[ 45/100] train_loss: 0.08704 valid_loss: 0.10870\n", + "[ 51/100] train_loss: 0.08553 valid_loss: 0.10852\n", "EarlyStopping counter: 17 out of 20\n", - "[ 46/100] train_loss: 0.08477 valid_loss: 0.10877\n", + "[ 52/100] train_loss: 0.08444 valid_loss: 0.10410\n", "EarlyStopping counter: 18 out of 20\n", - "[ 47/100] train_loss: 0.08397 valid_loss: 0.10682\n", + "[ 53/100] train_loss: 0.08313 valid_loss: 0.10338\n", "EarlyStopping counter: 19 out of 20\n", - "[ 48/100] train_loss: 0.08630 valid_loss: 0.10565\n", + "[ 54/100] train_loss: 0.08114 valid_loss: 0.10507\n", "EarlyStopping counter: 20 out of 20\n", "Early stopping\n" ] @@ -406,14 +419,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -454,20 +465,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Test Loss: 0.085796\n", + "Test Loss: 0.092734\n", "\n", - "Test Accuracy of 0: 98% (968/979)\n", - "Test Accuracy of 1: 98% (1121/1133)\n", - "Test Accuracy of 2: 97% (1008/1030)\n", - "Test Accuracy of 3: 97% (986/1008)\n", - "Test Accuracy of 4: 97% (955/980)\n", - "Test Accuracy of 5: 97% (867/890)\n", + "Test Accuracy of 0: 98% (969/979)\n", + "Test Accuracy of 1: 98% (1117/1133)\n", + "Test Accuracy of 2: 97% (1004/1030)\n", + "Test Accuracy of 3: 97% (987/1008)\n", + "Test Accuracy of 4: 97% (952/980)\n", + "Test Accuracy of 5: 94% (843/890)\n", "Test Accuracy of 6: 97% (932/956)\n", - "Test Accuracy of 7: 97% (997/1027)\n", - "Test Accuracy of 8: 96% (939/973)\n", - "Test Accuracy of 9: 95% (967/1008)\n", + "Test Accuracy of 7: 97% (1002/1027)\n", + "Test Accuracy of 8: 97% (945/973)\n", + "Test Accuracy of 9: 95% (965/1008)\n", "\n", - "Test Accuracy (Overall): 97% (9740/9984)\n" + "Test Accuracy (Overall): 97% (9716/9984)\n" ] } ], @@ -529,9 +540,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -541,7 +552,7 @@ "source": [ "# obtain one batch of test images\n", "dataiter = iter(test_loader)\n", - "images, labels = dataiter.next()\n", + "images, labels = next(dataiter) # Use the built-in next() function\n", "\n", "# get sample outputs\n", "output = model(images)\n", @@ -553,10 +564,10 @@ "# plot the images in the batch, along with predicted and true labels\n", "fig = plt.figure(figsize=(25, 4))\n", "for idx in np.arange(20):\n", - " ax = fig.add_subplot(2, 20/2, idx+1, xticks=[], yticks=[])\n", + " ax = fig.add_subplot(2, 20 // 2, idx+1, xticks=[], yticks=[])\n", " ax.imshow(np.squeeze(images[idx]), cmap='gray')\n", " ax.set_title(\"{} ({})\".format(str(preds[idx].item()), str(labels[idx].item())),\n", - " color=(\"green\" if preds[idx]==labels[idx] else \"red\"))" + " color=(\"green\" if preds[idx]==labels[idx] else \"red\"))\n" ] }, { @@ -576,7 +587,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -590,9 +601,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.6" + "version": "3.12.6" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }