From 5215b5487e848262fc75f5f1fd393b02ac3a7a3e Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 15:19:58 +0900 Subject: [PATCH 01/13] chore: rename and move pytorchtools --- early_stopping_pytorch/__init__.py | 3 +++ pytorchtools.py => early_stopping_pytorch/early_stopping.py | 0 2 files changed, 3 insertions(+) create mode 100644 early_stopping_pytorch/__init__.py rename pytorchtools.py => early_stopping_pytorch/early_stopping.py (100%) diff --git a/early_stopping_pytorch/__init__.py b/early_stopping_pytorch/__init__.py new file mode 100644 index 0000000..5d6b45d --- /dev/null +++ b/early_stopping_pytorch/__init__.py @@ -0,0 +1,3 @@ +from .early_stopping import EarlyStopping + +__version__ = "0.1.0" diff --git a/pytorchtools.py b/early_stopping_pytorch/early_stopping.py similarity index 100% rename from pytorchtools.py rename to early_stopping_pytorch/early_stopping.py From a687b094aed67f379cc76ca0f95c286cdbb0a99f Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 15:20:19 +0900 Subject: [PATCH 02/13] chore: update requirements-dev.txt --- requirements-dev.txt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/requirements-dev.txt b/requirements-dev.txt index 147b29d..6a95680 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,4 +1,6 @@ # requirements-dev.txt -r requirements.txt pytest -pytest-mock \ No newline at end of file +pytest-mock +build +notebook \ No newline at end of file From 270dade1289131f768f8836f91ca2d074bdcbfe5 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 15:20:43 +0900 Subject: [PATCH 03/13] ci: update tests with new names --- tests/test_early_stopping.py | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/tests/test_early_stopping.py b/tests/test_early_stopping.py index e072bf4..364b1bf 100644 --- a/tests/test_early_stopping.py +++ b/tests/test_early_stopping.py @@ -1,11 +1,10 @@ -# test_early_stopping.py +# tests/test_early_stopping.py import pytest from unittest.mock import Mock, patch import torch import numpy as np - -from pytorchtools import EarlyStopping +from early_stopping_pytorch import EarlyStopping # Fixtures to mock model and temporary checkpoint path @@ -68,7 +67,7 @@ def test_initial_call_saves_checkpoint(mock_model, temp_checkpoint_path): 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: + with patch('early_stopping_pytorch.early_stopping.torch.save') as mock_save: # Initialize EarlyStopping with specified parameters early_stopping = EarlyStopping(patience=5, verbose=False, path=temp_checkpoint_path) @@ -81,7 +80,7 @@ def test_initial_call_saves_checkpoint(mock_model, temp_checkpoint_path): # 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 early_stopping.best_val_loss == initial_val_loss, "Best score should be set to 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" @@ -98,7 +97,7 @@ def test_validation_loss_improves(mock_model, temp_checkpoint_path): 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: + with patch('early_stopping_pytorch.early_stopping.torch.save') as mock_save: # Initialize EarlyStopping with specified parameters early_stopping = EarlyStopping(patience=5, verbose=False, path=temp_checkpoint_path) @@ -143,11 +142,11 @@ def test_validation_loss_no_improvement_within_delta(mock_model, temp_checkpoint # 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 + # - Total save_checkpoint calls: 3 # - 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 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 three improvements" # Assert that the patience counter has incremented to 1 (only Epoch 6 incremented it) @@ -175,7 +174,6 @@ def test_validation_loss_no_improvement_within_delta(mock_model, temp_checkpoint # 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. @@ -230,7 +228,7 @@ def test_verbose_output(mock_model, temp_checkpoint_path, capsys): 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'): + with patch('early_stopping_pytorch.early_stopping.torch.save'): # Initialize EarlyStopping with verbose enabled early_stopping = EarlyStopping(patience=2, verbose=True, path=temp_checkpoint_path) @@ -247,7 +245,6 @@ def test_verbose_output(mock_model, temp_checkpoint_path, capsys): 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. @@ -260,7 +257,7 @@ def test_no_early_stop_when_validation_improves_within_patience(mock_model, temp 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: + with patch('early_stopping_pytorch.early_stopping.torch.save') as mock_save: # Initialize EarlyStopping with specified parameters early_stopping = EarlyStopping(patience=3, verbose=False, path=temp_checkpoint_path) @@ -357,4 +354,4 @@ def test_validation_loss_nan(mock_model, temp_checkpoint_path): assert not early_stopping.early_stop, "Early stop should not be triggered when validations improve" # Assert that the patience counter was not incremented for NaN loss - assert early_stopping.counter == 0, "Counter should remain 0 since NaN loss was ignored" \ No newline at end of file + assert early_stopping.counter == 0, "Counter should remain 0 since NaN loss was ignored" From 1bd4a49923d237c878b3a15ddb3c9a98fd481a4b Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 15:21:13 +0900 Subject: [PATCH 04/13] chore: update MNIST_Early_Stopping_example.ipynb --- MNIST_Early_Stopping_example.ipynb | 184 ++++++++++++++--------------- 1 file changed, 91 insertions(+), 93 deletions(-) diff --git a/MNIST_Early_Stopping_example.ipynb b/MNIST_Early_Stopping_example.ipynb index cf6b430..a1dd0be 100644 --- a/MNIST_Early_Stopping_example.ipynb +++ b/MNIST_Early_Stopping_example.ipynb @@ -176,7 +176,7 @@ "outputs": [], "source": [ "# import EarlyStopping\n", - "from pytorchtools import EarlyStopping" + "from early_stopping_pytorch import EarlyStopping" ] }, { @@ -280,113 +280,111 @@ "name": "stdout", "output_type": "stream", "text": [ - "[ 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", + "[ 1/100] train_loss: 0.82703 valid_loss: 0.30238\n", + "Validation loss decreased (inf --> 0.302376). Saving model ...\n", + "[ 2/100] train_loss: 0.37277 valid_loss: 0.22491\n", + "Validation loss decreased (0.302376 --> 0.224906). Saving model ...\n", + "[ 3/100] train_loss: 0.29670 valid_loss: 0.18630\n", + "Validation loss decreased (0.224906 --> 0.186303). Saving model ...\n", + "[ 4/100] train_loss: 0.25662 valid_loss: 0.16485\n", + "Validation loss decreased (0.186303 --> 0.164847). Saving model ...\n", + "[ 5/100] train_loss: 0.22976 valid_loss: 0.14947\n", + "Validation loss decreased (0.164847 --> 0.149469). Saving model ...\n", + "[ 6/100] train_loss: 0.21193 valid_loss: 0.14102\n", + "Validation loss decreased (0.149469 --> 0.141021). Saving model ...\n", + "[ 7/100] train_loss: 0.19462 valid_loss: 0.13308\n", + "Validation loss decreased (0.141021 --> 0.133076). Saving model ...\n", + "[ 8/100] train_loss: 0.18161 valid_loss: 0.12685\n", + "Validation loss decreased (0.133076 --> 0.126854). Saving model ...\n", + "[ 9/100] train_loss: 0.17665 valid_loss: 0.12394\n", + "Validation loss decreased (0.126854 --> 0.123937). Saving model ...\n", + "[ 10/100] train_loss: 0.16941 valid_loss: 0.11810\n", + "Validation loss decreased (0.123937 --> 0.118096). Saving model ...\n", + "[ 11/100] train_loss: 0.15594 valid_loss: 0.11303\n", + "Validation loss decreased (0.118096 --> 0.113027). Saving model ...\n", + "[ 12/100] train_loss: 0.15550 valid_loss: 0.10889\n", + "Validation loss decreased (0.113027 --> 0.108887). Saving model ...\n", + "[ 13/100] train_loss: 0.14627 valid_loss: 0.11325\n", "EarlyStopping counter: 1 out of 20\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", + "[ 14/100] train_loss: 0.14303 valid_loss: 0.11015\n", + "EarlyStopping counter: 2 out of 20\n", + "[ 15/100] train_loss: 0.13929 valid_loss: 0.10911\n", + "EarlyStopping counter: 3 out of 20\n", + "[ 16/100] train_loss: 0.13594 valid_loss: 0.10694\n", + "Validation loss decreased (0.108887 --> 0.106941). Saving model ...\n", + "[ 17/100] train_loss: 0.13264 valid_loss: 0.10758\n", "EarlyStopping counter: 1 out of 20\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", + "[ 18/100] train_loss: 0.13120 valid_loss: 0.10633\n", + "Validation loss decreased (0.106941 --> 0.106329). Saving model ...\n", + "[ 19/100] train_loss: 0.12495 valid_loss: 0.10490\n", + "Validation loss decreased (0.106329 --> 0.104902). Saving model ...\n", + "[ 20/100] train_loss: 0.12678 valid_loss: 0.10082\n", + "Validation loss decreased (0.104902 --> 0.100817). Saving model ...\n", + "[ 21/100] train_loss: 0.12108 valid_loss: 0.10459\n", "EarlyStopping counter: 1 out of 20\n", - "[ 24/100] train_loss: 0.11879 valid_loss: 0.09823\n", + "[ 22/100] train_loss: 0.11912 valid_loss: 0.10085\n", "EarlyStopping counter: 2 out of 20\n", - "[ 25/100] train_loss: 0.11619 valid_loss: 0.10081\n", - "EarlyStopping counter: 3 out of 20\n", - "[ 26/100] train_loss: 0.11205 valid_loss: 0.10083\n", - "EarlyStopping counter: 4 out of 20\n", - "[ 27/100] train_loss: 0.11331 valid_loss: 0.10078\n", - "EarlyStopping counter: 5 out of 20\n", - "[ 28/100] train_loss: 0.10997 valid_loss: 0.10114\n", - "EarlyStopping counter: 6 out of 20\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", + "[ 23/100] train_loss: 0.11640 valid_loss: 0.10019\n", + "Validation loss decreased (0.100817 --> 0.100187). Saving model ...\n", + "[ 24/100] train_loss: 0.11428 valid_loss: 0.10181\n", + "EarlyStopping counter: 1 out of 20\n", + "[ 25/100] train_loss: 0.11413 valid_loss: 0.10021\n", + "EarlyStopping counter: 2 out of 20\n", + "[ 26/100] train_loss: 0.11314 valid_loss: 0.09910\n", + "Validation loss decreased (0.100187 --> 0.099096). Saving model ...\n", + "[ 27/100] train_loss: 0.10640 valid_loss: 0.10084\n", + "EarlyStopping counter: 1 out of 20\n", + "[ 28/100] train_loss: 0.11099 valid_loss: 0.09766\n", + "Validation loss decreased (0.099096 --> 0.097662). Saving model ...\n", + "[ 29/100] train_loss: 0.10586 valid_loss: 0.09884\n", "EarlyStopping counter: 1 out of 20\n", - "[ 31/100] train_loss: 0.10434 valid_loss: 0.09898\n", + "[ 30/100] train_loss: 0.10330 valid_loss: 0.10240\n", "EarlyStopping counter: 2 out of 20\n", - "[ 32/100] train_loss: 0.10322 valid_loss: 0.09699\n", + "[ 31/100] train_loss: 0.10459 valid_loss: 0.09871\n", "EarlyStopping counter: 3 out of 20\n", - "[ 33/100] train_loss: 0.09873 valid_loss: 0.09826\n", + "[ 32/100] train_loss: 0.10138 valid_loss: 0.09863\n", "EarlyStopping counter: 4 out of 20\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", + "[ 33/100] train_loss: 0.10169 valid_loss: 0.09559\n", + "Validation loss decreased (0.097662 --> 0.095588). Saving model ...\n", + "[ 34/100] train_loss: 0.09978 valid_loss: 0.09849\n", "EarlyStopping counter: 1 out of 20\n", - "[ 36/100] train_loss: 0.09554 valid_loss: 0.10243\n", + "[ 35/100] train_loss: 0.10002 valid_loss: 0.09962\n", "EarlyStopping counter: 2 out of 20\n", - "[ 37/100] train_loss: 0.10178 valid_loss: 0.09873\n", + "[ 36/100] train_loss: 0.09926 valid_loss: 0.10318\n", "EarlyStopping counter: 3 out of 20\n", - "[ 38/100] train_loss: 0.09442 valid_loss: 0.10022\n", + "[ 37/100] train_loss: 0.09605 valid_loss: 0.09884\n", "EarlyStopping counter: 4 out of 20\n", - "[ 39/100] train_loss: 0.09483 valid_loss: 0.09984\n", + "[ 38/100] train_loss: 0.09251 valid_loss: 0.10079\n", "EarlyStopping counter: 5 out of 20\n", - "[ 40/100] train_loss: 0.09673 valid_loss: 0.10122\n", + "[ 39/100] train_loss: 0.09370 valid_loss: 0.10138\n", "EarlyStopping counter: 6 out of 20\n", - "[ 41/100] train_loss: 0.09409 valid_loss: 0.10010\n", + "[ 40/100] train_loss: 0.09134 valid_loss: 0.10156\n", "EarlyStopping counter: 7 out of 20\n", - "[ 42/100] train_loss: 0.08885 valid_loss: 0.09946\n", + "[ 41/100] train_loss: 0.09198 valid_loss: 0.10168\n", "EarlyStopping counter: 8 out of 20\n", - "[ 43/100] train_loss: 0.08923 valid_loss: 0.10062\n", + "[ 42/100] train_loss: 0.09012 valid_loss: 0.10093\n", "EarlyStopping counter: 9 out of 20\n", - "[ 44/100] train_loss: 0.08976 valid_loss: 0.10242\n", + "[ 43/100] train_loss: 0.09017 valid_loss: 0.10074\n", "EarlyStopping counter: 10 out of 20\n", - "[ 45/100] train_loss: 0.09064 valid_loss: 0.09567\n", + "[ 44/100] train_loss: 0.09035 valid_loss: 0.09982\n", "EarlyStopping counter: 11 out of 20\n", - "[ 46/100] train_loss: 0.08339 valid_loss: 0.10048\n", + "[ 45/100] train_loss: 0.08858 valid_loss: 0.09864\n", "EarlyStopping counter: 12 out of 20\n", - "[ 47/100] train_loss: 0.08805 valid_loss: 0.10472\n", + "[ 46/100] train_loss: 0.08830 valid_loss: 0.09890\n", "EarlyStopping counter: 13 out of 20\n", - "[ 48/100] train_loss: 0.08987 valid_loss: 0.10191\n", + "[ 47/100] train_loss: 0.08519 valid_loss: 0.10297\n", "EarlyStopping counter: 14 out of 20\n", - "[ 49/100] train_loss: 0.08727 valid_loss: 0.10311\n", + "[ 48/100] train_loss: 0.08402 valid_loss: 0.10301\n", "EarlyStopping counter: 15 out of 20\n", - "[ 50/100] train_loss: 0.08554 valid_loss: 0.10606\n", + "[ 49/100] train_loss: 0.08680 valid_loss: 0.10121\n", "EarlyStopping counter: 16 out of 20\n", - "[ 51/100] train_loss: 0.08553 valid_loss: 0.10852\n", + "[ 50/100] train_loss: 0.08755 valid_loss: 0.10025\n", "EarlyStopping counter: 17 out of 20\n", - "[ 52/100] train_loss: 0.08444 valid_loss: 0.10410\n", + "[ 51/100] train_loss: 0.08680 valid_loss: 0.10176\n", "EarlyStopping counter: 18 out of 20\n", - "[ 53/100] train_loss: 0.08313 valid_loss: 0.10338\n", + "[ 52/100] train_loss: 0.07961 valid_loss: 0.10526\n", "EarlyStopping counter: 19 out of 20\n", - "[ 54/100] train_loss: 0.08114 valid_loss: 0.10507\n", + "[ 53/100] train_loss: 0.08318 valid_loss: 0.10343\n", "EarlyStopping counter: 20 out of 20\n", "Early stopping\n" ] @@ -419,7 +417,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -465,20 +463,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Test Loss: 0.092734\n", + "Test Loss: 0.085494\n", "\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 1: 98% (1121/1133)\n", + "Test Accuracy of 2: 97% (1006/1030)\n", + "Test Accuracy of 3: 98% (988/1008)\n", + "Test Accuracy of 4: 97% (953/980)\n", + "Test Accuracy of 5: 96% (860/890)\n", + "Test Accuracy of 6: 97% (935/956)\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", + "Test Accuracy of 8: 95% (932/973)\n", + "Test Accuracy of 9: 96% (973/1008)\n", "\n", - "Test Accuracy (Overall): 97% (9716/9984)\n" + "Test Accuracy (Overall): 97% (9739/9984)\n" ] } ], @@ -540,7 +538,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From a74fceb389cdcef2d0561d84ab3c0c7a827c037e Mon Sep 17 00:00:00 2001 From: Bjarten Date: Tue, 15 Oct 2024 15:21:39 +0900 Subject: [PATCH 05/13] chore: add setup dev env script --- setup_dev_env.sh | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100755 setup_dev_env.sh diff --git a/setup_dev_env.sh b/setup_dev_env.sh new file mode 100755 index 0000000..1ee1025 --- /dev/null +++ b/setup_dev_env.sh @@ -0,0 +1,31 @@ +#!/bin/bash + +# Exit immediately if a command exits with a non-zero status. +set -e + +# Create a virtual environment if it doesn't already exist +if [ ! -d ".venv" ]; then + echo "Creating a virtual environment in venv..." + python3 -m venv venv + echo "Virtual environment created." +else + echo "Virtual environment already exists." +fi + +# Activate the virtual environment +source venv/bin/activate + +# Upgrade pip and install dependencies +echo "Upgrading pip..." +pip install --upgrade pip + +echo "Installing development dependencies..." +pip install -r requirements-dev.txt + +echo "Installing runtime dependencies..." +pip install -r requirements.txt + +echo "Development environment is set up and ready to go!" + +# To active the virtual environment, run the following command +echo "source venv/bin/activate" \ No newline at end of file From 8d5babc261a4f9956fb81c186b348deba1100df3 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Wed, 16 Oct 2024 14:04:22 +0900 Subject: [PATCH 06/13] chore: add python 13 to tests --- .github/workflows/tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index cb4ad4a..d8fce0e 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -12,7 +12,7 @@ jobs: strategy: matrix: - python-version: ['3.9', '3.10', '3.11', '3.12'] + python-version: ['3.9', '3.10', '3.11', '3.12', '3.13'] steps: # Step 1: Checkout the repository From cb80355f4aa94f94ecb1054d46c63c847a56abf3 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Wed, 16 Oct 2024 14:20:51 +0900 Subject: [PATCH 07/13] chore: add pip publish workflow --- .github/workflows/publish.yml | 43 +++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 .github/workflows/publish.yml diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..bad7cb3 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,43 @@ +name: Publish Python Package + +on: + push: + tags: + - 'v*.*.*' # Automatically publish when a new version tag is pushed + +jobs: + publish: + runs-on: ubuntu-latest + + steps: + - name: Checkout code + uses: actions/checkout@v3 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.12' + + - name: Cache pip + uses: actions/cache@v3 + with: + path: ~/.cache/pip + key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }} + restore-keys: | + ${{ runner.os }}-pip- + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install build twine + + - name: Build the package + run: | + python -m build + + - name: Publish to PyPI + env: + TWINE_USERNAME: __token__ + TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }} + run: | + python -m twine upload --repository pypi dist/* From 631d961c40945145eeb4c6b8bf517345f18ca7f0 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Wed, 16 Oct 2024 14:22:50 +0900 Subject: [PATCH 08/13] ci: add pip pub stuff --- pyproject.toml | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 1a3ea03..22f9c66 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,26 @@ +[build-system] +requires = ["setuptools>=61.0", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "early-stopping-pytorch" +version = "0.1.0" +description = "A PyTorch utility package for Early Stopping" +readme = "README.md" +authors = [ + { name = "Bjarte Sunde", email = "BjarteSunde@outlook.com" } +] +license = { text = "MIT" } # Update if you use a different license +dependencies = [ + "numpy>=1.21", + "torch>=1.9.0" +] + [tool.semantic_release] version_variable = [ - "pytorchtools.py:__version__", + "early_stopping_pytorch/__init__.py:__version__", + "pyproject.toml:project.version" ] branch = "main" upload_to_pypi = false -build_command = "pip install build && python -m build" \ No newline at end of file +build_command = "pip install build && python -m build" From e8987a370d498c111f7c3c48d2d3d3c5d5feb18c Mon Sep 17 00:00:00 2001 From: Bjarten Date: Wed, 16 Oct 2024 14:23:08 +0900 Subject: [PATCH 09/13] ci: update release.yml --- .github/workflows/release.yml | 46 +++++++++++++++++++---------------- 1 file changed, 25 insertions(+), 21 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 738adb3..15ca261 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -23,28 +23,32 @@ jobs: pull-requests: write steps: - - name: Checkout code - uses: actions/checkout@v4 - with: - fetch-depth: 0 + - name: Checkout code + uses: actions/checkout@v4 + with: + fetch-depth: 0 - - name: Set up Python - uses: actions/setup-python@v4 - with: - python-version: '3.12' # Specifying the latest stable Python version + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.12' - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install python-semantic-release + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install python-semantic-release - - name: Configure Git - run: | - git config user.name "github-actions[bot]" - git config user.email "github-actions[bot]@users.noreply.github.com" + - name: Configure Git + run: | + git config user.name "github-actions[bot]" + git config user.email "github-actions[bot]@users.noreply.github.com" - - name: Run semantic-release - env: - GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: | - semantic-release publish ${{ github.event.inputs.dry-run == true && '--dry-run' || '' }} \ No newline at end of file + - name: Run semantic-release + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + if [ "${{ github.event.inputs.dry-run }}" = "true" ]; then + semantic-release publish --dry-run + else + semantic-release publish + fi From 95c7db00d15e7f245309a049a9c76f2b20809817 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Wed, 16 Oct 2024 14:23:46 +0900 Subject: [PATCH 10/13] fix: .venv -> venv --- setup_dev_env.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup_dev_env.sh b/setup_dev_env.sh index 1ee1025..7096404 100755 --- a/setup_dev_env.sh +++ b/setup_dev_env.sh @@ -4,7 +4,7 @@ set -e # Create a virtual environment if it doesn't already exist -if [ ! -d ".venv" ]; then +if [ ! -d "venv" ]; then echo "Creating a virtual environment in venv..." python3 -m venv venv echo "Virtual environment created." From efeb425f572480f6616a4893cea70e1cda2d0e86 Mon Sep 17 00:00:00 2001 From: Bjarten Date: Wed, 16 Oct 2024 14:24:26 +0900 Subject: [PATCH 11/13] docs: add usage section --- README.md | 51 +++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 49 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 5cad110..4acb591 100644 --- a/README.md +++ b/README.md @@ -7,10 +7,57 @@ Underneath is a plot from the example notebook, which shows the last checkpoint ## Usage -You can run this project directly in the browser by clicking this button: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Bjarten/early-stopping-pytorch/master), or you can clone the project to your computer and install the required pip packages specified in the requirements text file. +### 1. Clone the Repository +```bash +git clone https://github.com/your_username/early-stopping-pytorch.git +cd early-stopping-pytorch ``` -pip install -r requirements.txt + +### 2. Set Up the Virtual Environment +Run the setup script to create a virtual environment and install all necessary dependencies. +```bash +./setup_dev_env.sh +``` + +### 3. Activate the Virtual Environment +Activate the virtual environment: +```bash +source dev-venv/bin/activate +``` + +### 4. Install the Package in Editable Mode +Install the package locally in editable mode so you can use it immediately: +```bash +pip install -e . +``` + +### 5. Use the Package +You can now import and use the package in your Python code: +```python +from early_stopping_pytorch import EarlyStopping +``` + +--- + +### Summary of Commands + +1. Clone the repository: + `git clone https://github.com/your_username/early-stopping-pytorch.git` + +2. Set up the environment: + `./setup_dev_env.sh` + +3. Activate the environment: + `source dev-venv/bin/activate` + +4. Install the package in editable mode: + `pip install -e .` + +5. Optional: Build the package for distribution: + `./build.sh` ``` +You can just copy and paste this into your `README.md`. Let me know if you need any more adjustments! + ## References The ```EarlyStopping``` class in ```pytorchtool.py``` is inspired by the [ignite EarlyStopping class](https://github.com/pytorch/ignite/blob/master/ignite/handlers/early_stopping.py). From 63ebec9150396dd3f7877374b9309de7967a9b9d Mon Sep 17 00:00:00 2001 From: Bjarten Date: Wed, 16 Oct 2024 14:37:59 +0900 Subject: [PATCH 12/13] docs: update readme --- README.md | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 4acb591..0896068 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ # Early Stopping for PyTorch -Early stopping is a form of regularization used to avoid overfitting on the training dataset. Early stopping keeps track of the validation loss, if the loss stops decreasing for several epochs in a row the training stops. The ```EarlyStopping``` class in ```pytorchtool.py``` is used to create an object to keep track of the validation loss while training a [PyTorch](https://pytorch.org/) model. It will save a checkpoint of the model each time the validation loss decrease. We set the ```patience``` argument in the ```EarlyStopping``` class to how many epochs we want to wait after the last time the validation loss improved before breaking the training loop. There is a simple example of how to use the ```EarlyStopping``` class in the [MNIST_Early_Stopping_example](MNIST_Early_Stopping_example.ipynb) notebook. +Early stopping is a form of regularization used to avoid overfitting on the training dataset. Early stopping keeps track of the validation loss, if the loss stops decreasing for several epochs in a row the training stops. The ```EarlyStopping``` class in ```early_stopping_pytorch/early_stopping.py``` is used to create an object to keep track of the validation loss while training a [PyTorch](https://pytorch.org/) model. It will save a checkpoint of the model each time the validation loss decrease. We set the ```patience``` argument in the ```EarlyStopping``` class to how many epochs we want to wait after the last time the validation loss improved before breaking the training loop. There is a simple example of how to use the ```EarlyStopping``` class in the [MNIST_Early_Stopping_example](MNIST_Early_Stopping_example.ipynb) notebook. Underneath is a plot from the example notebook, which shows the last checkpoint made by the EarlyStopping object, right before the model started to overfit. It had patience set to 20. @@ -55,9 +55,6 @@ from early_stopping_pytorch import EarlyStopping 5. Optional: Build the package for distribution: `./build.sh` -``` - -You can just copy and paste this into your `README.md`. Let me know if you need any more adjustments! ## References -The ```EarlyStopping``` class in ```pytorchtool.py``` is inspired by the [ignite EarlyStopping class](https://github.com/pytorch/ignite/blob/master/ignite/handlers/early_stopping.py). +The ```EarlyStopping``` class in ```early_stopping_pytorch/early_stopping.py``` is inspired by the [ignite EarlyStopping class](https://github.com/pytorch/ignite/blob/master/ignite/handlers/early_stopping.py). From 77666af338846b6a5b7e75f4a8a21870f87fe36e Mon Sep 17 00:00:00 2001 From: Bjarten Date: Wed, 16 Oct 2024 14:50:47 +0900 Subject: [PATCH 13/13] fix: remove python 3.13, not supported by torchvision yet --- .github/workflows/tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index d8fce0e..cb4ad4a 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -12,7 +12,7 @@ jobs: strategy: matrix: - python-version: ['3.9', '3.10', '3.11', '3.12', '3.13'] + python-version: ['3.9', '3.10', '3.11', '3.12'] steps: # Step 1: Checkout the repository