Added Ptv Transforms Resize node to resize image data. Added workflows and PyTorch model training tutorials.

tests/pytorch_wrapper/pt_evaluate_classification_conv_model_test2.py

@@ -9,17 +9,19 @@ MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
 sys.path.append(MODULE_ROOT)
 from pytorch_wrapper.ptn_conv_model import PtnConvModel
 from pytorch_wrapper.ptv_image_folder_dataset import PtvImageFolderDataset
-from pytorch_wrapper.ptv_transforms_to_tensor import PtvTransformsToTensor
+from pytorch_wrapper.ptv_transforms_resize import PtvTransformsResize
 from pytorch_wrapper.pt_data_loader import PtDataLoader
 from pytorch_wrapper.pt_evaluate_classification_model import PtEvaluateClassificationModel
 from pytorch_wrapper.pt_load_model import PtLoadModel
  
 class TestPtEvaluate(unittest.TestCase):
+
+    @unittest.skipIf(os.getenv("RUN_SKIPPED_TESTS") != "1", "Skipping unless explicitly enabled")
     def setUp(self):
         """Set up test instance."""
         # Transform
-        compose_node = PtvTransformsToTensor()
-        transform = compose_node.f()[0]
+        compose_node = PtvTransformsResize()
+        transform = compose_node.f(256, 256)[0]
         
         # Dataset
         self.node = PtvImageFolderDataset()
@@ -38,10 +40,10 @@ class TestPtEvaluate(unittest.TestCase):
         # Model
         self.model_node = PtnConvModel()
         self.model = self.model_node.f(
-                 input_dim="(3, 512, 512)",
+                 input_dim="(3, 256, 256)",
                  penultimate_dim=0,
                  output_dim=2,
-                 channel_list="[32,64,128,256,512]", # To 256, 128, 64, 32, 16
+                 channel_list="[32,64,128,256,512]", # To 128, 64, 32, 16, 8
                  kernel_size_list="[3,3,3,3,3]",
                  padding_list="[1,1,1,1,1]",
                  downsample_list="[True,True,True,True,True]"
@@ -49,12 +51,13 @@ class TestPtEvaluate(unittest.TestCase):
 
         # Load weights
         self.load_model = PtLoadModel()
-        epochs = 7
+        epochs = 20
         self.loaded_model = self.load_model.f(self.model,f"dog_cat_{epochs}_epochs_conv.pt")
 
         # Instantiates evaluation node
         self.evaluate = PtEvaluateClassificationModel()
 
+    @unittest.skipIf(os.getenv("RUN_SKIPPED_TESTS") != "1", "Skipping unless explicitly enabled")
     def test_evaluation(self):
         """
         Tests evaluation.  

tests/pytorch_wrapper/pt_train_classification_conv_model_test2.py

@@ -11,23 +11,34 @@ sys.path.append(MODULE_ROOT)
 from pytorch_wrapper.ptn_conv_model import PtnConvModel
 from pytorch_wrapper.pto_adam import PtoAdam
 from pytorch_wrapper.ptv_image_folder_dataset import PtvImageFolderDataset
-from pytorch_wrapper.ptv_transforms_to_tensor import PtvTransformsToTensor
+from pytorch_wrapper.ptv_transforms_resize import PtvTransformsResize
 from pytorch_wrapper.pt_data_loader import PtDataLoader
 from pytorch_wrapper.pt_train_classification_model import PtTrainClassificationModel
 from pytorch_wrapper.pt_save_model import PtSaveModel
 
  
 class TestPtTrainConvModel2(unittest.TestCase):
+
+    @unittest.skipIf(os.getenv("RUN_SKIPPED_TESTS") != "1", "Skipping unless explicitly enabled")
     def setUp(self):
         """Set up test instance."""
-        compose_node = PtvTransformsToTensor()
-        transform = compose_node.f()[0]
+        compose_node = PtvTransformsResize()
+        transform = compose_node.f(256, 256)[0]
         self.node = PtvImageFolderDataset()
-        dataset = self.node.f("dog_and_cat/train",
+        train_dataset = self.node.f("dog_and_cat/train",
                     transform=transform)[0]
-        data_loader_node = PtDataLoader()
-        self.train_loader = data_loader_node.f(
-            dataset=dataset,
+        train_data_loader_node = PtDataLoader()
+        val_dataset = self.node.f("dog_and_cat/val",
+                    transform=transform)[0]
+        val_data_loader_node = PtDataLoader()
+        self.train_loader = train_data_loader_node.f(
+            dataset=train_dataset,
+            batch_size=32,
+            shuffle=True,
+            parameters='{"num_workers":1}'
+        )[0]
+        self.val_loader = val_data_loader_node.f(
+            dataset=val_dataset,
             batch_size=32,
             shuffle=True,
             parameters='{"num_workers":1}'
@@ -35,10 +46,10 @@ class TestPtTrainConvModel2(unittest.TestCase):
 
         self.model_node = PtnConvModel()
         self.model = self.model_node.f(
-                 input_dim="(3, 512, 512)",
+                 input_dim="(3, 256, 256)",
                  penultimate_dim=0,
                  output_dim=2,
-                 channel_list="[32,64,128,256,512]", # To 256, 128, 64, 32, 16
+                 channel_list="[32,64,128,256,512]", # To 128, 64, 32, 16, 8
                  kernel_size_list="[3,3,3,3,3]",
                  padding_list="[1,1,1,1,1]",
                  downsample_list="[True,True,True,True,True]"
@@ -48,11 +59,13 @@ class TestPtTrainConvModel2(unittest.TestCase):
         self.trainer = PtTrainClassificationModel()
         self.save_model = PtSaveModel()
 
+    @unittest.skipIf(os.getenv("RUN_SKIPPED_TESTS") != "1", "Skipping unless explicitly enabled")
     def test_1(self):
-        epochs = 7
+        epochs = 20
         trained_model = self.trainer.f(self.model, self.train_loader, self.optimizer,
                        epochs, # epochs
-                       use_gpu=True)[0]
+                       use_gpu=True,
+                       val_loader=self.val_loader)[0]
         self.save_model.f(trained_model, f"dog_cat_{epochs}_epochs_conv.pt")
 
 

tests/pytorch_wrapper/ptv_transforms_resize_test.py

@@ -0,0 +1,43 @@
+import os
+import sys
+import unittest
+import torch
+from PIL import Image
+import numpy as np
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pytorch_wrapper.ptv_transforms_resize import PtvTransformsResize
+
+
+class TestPtvTransformsResize(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.compose_node = PtvTransformsResize()
+        self.height = 128
+        self.width = 128
+
+    def test_with_transform(self):
+        """Tests the transformation output."""
+        transform = self.compose_node.f(self.height, self.width)[0]
+        self.assertTrue(callable(transform), "Transform should be callable.")
+
+        # Create a dummy image
+        img = Image.fromarray(np.random.randint(0, 256, (256, 256, 3), dtype=np.uint8))
+        transformed_img = transform(img)
+
+        # Check output type
+        self.assertIsInstance(transformed_img, torch.Tensor, "Output should be a PyTorch tensor.")
+
+        # Check output shape
+        self.assertEqual(transformed_img.shape, (3, self.height, self.width), "Output shape should match target dimensions.")
+
+    def test_default_parameters(self):
+        """Tests default transform parameters."""
+        transform = self.compose_node.f(256, 256)[0]
+        self.assertTrue(callable(transform), "Default transform should be callable.")
+
+
+if __name__ == "__main__":
+    unittest.main()