Merge pull request #19 from ArashAkbarinia/development

Merging from Development

Author: ArashAkbarinia

docs/source/conf.py

@@ -34,9 +34,27 @@
     'sphinx.ext.doctest',
     'sphinx.ext.napoleon',
     'sphinx.ext.viewcode',
+    'sphinx.ext.mathjax',
     'myst_nb'
 ]
 
+myst_enable_extensions = [
+    "amsmath",
+    # "attrs_inline",
+    # "colon_fence",
+    # "deflist",
+    "dollarmath",
+    # "fieldlist",
+    # "html_admonition",
+    # "html_image",
+    # "linkify",
+    # "replacements",
+    # "smartquotes",
+    # "strikethrough",
+    # "substitution",
+    # "tasklist",
+]
+
 templates_path = ['_templates']
 exclude_patterns = []
 

docs/source/examples.rst

@@ -5,5 +5,6 @@ In the following notebooks, we show different examples of how to use :code:`oscu
 
 .. toctree::
    notebooks/quick_start
+   notebooks/activation_maps
    notebooks/odd_one_out
    :maxdepth: 1

docs/source/notebooks/activation_maps.ipynb

@@ -53,7 +53,7 @@
    "id": "2b21aabc-b485-4f2f-9ed2-3340ef923db1",
    "metadata": {},
    "source": [
-    "## Prtrained features\n",
+    "## Pretrained features\n",
     "\n",
     "Let's create a linear classifier on top of the extracted features from a pretrained network to \n",
     "perform a **4AFC odd-one-out (OOO)** task (i.e., which image out of four options is the \"odd\" one). \n",
@@ -69,7 +69,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "architecture = 'vit_b_32'        # networks' architecture\n",
+    "architecture = 'vit_b_32'        # network's architecture\n",
     "weights = 'vit_b_32'             # the pretrained weights\n",
     "img_size = 224                   # network's input size\n",
     "layer = 'block7'                 # the readout layer\n",

docs/source/notebooks/odd_one_out.ipynb

@@ -57,7 +57,7 @@
    "id": "2d0848b0-b0b8-4def-8bac-684e060b8623",
    "metadata": {},
    "source": [
-    "## Prtrained features\n",
+    "## Pretrained features\n",
     "\n",
     "Let's create a linear classifier on top of the extracted features from a pretrained network to \n",
     "perform a binary classification task (i.e., 2AFC – two-alternative-force-choice). This is easily \n",
@@ -71,7 +71,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "architecture = 'resnet50'        # networks' architecture\n",
+    "architecture = 'resnet50'        # network's architecture\n",
     "weights = 'resnet50'             # the pretrained weights\n",
     "img_size = 224                   # network's input size\n",
     "layer = 'block0'                 # the readout layer\n",

docs/source/notebooks/quick_start.ipynb

@@ -7,12 +7,12 @@
    "source": [
     "# Usage\n",
     "\n",
-    "This notebook shows how to use the `osculari` package.\n",
+    "This notebook demonstrates how to use the `osculari` package.\n",
     "\n",
-    "The `osculari` package consists of three main `modules`:\n",
-    "* `models`: to readout pretrained networks and add linear layers on top of them.\n",
-    "* `datasets`: to create datasets and dataloaders to train and test linear probes.\n",
-    "* `paradigms`: to implement psychophysical paradigms to experiment with deep networks."
+    "The `osculari` package is organized into three main `modules`:\n",
+    "* `models`: Used for reading pretrained networks and adding linear layers on top of them.\n",
+    "* `datasets`: Used to create datasets and dataloaders for training and testing linear probes.\n",
+    "* `paradigms`: Used to implement psychophysical paradigms for experimenting with deep networks."
    ]
   },
   {
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
+   "execution_count": 2,
    "id": "e74f3e20-bb57-4511-baf7-d18da5cb38ed",
    "metadata": {},
    "outputs": [
@@ -168,8 +168,7 @@
        "  'deeplabv3_resnet101',\n",
        "  'deeplabv3_resnet50',\n",
        "  'fcn_resnet101',\n",
-       "  'fcn_resnet50',\n",
-       "  'lraspp_mobilenet_v3_large'],\n",
+       "  'fcn_resnet50'],\n",
        " 'taskonomy': ['taskonomy_autoencoding',\n",
        "  'taskonomy_class_object',\n",
        "  'taskonomy_class_scene',\n",
@@ -206,7 +205,7 @@
        "  'clip_ViT-L/14@336px']}"
       ]
      },
-     "execution_count": 73,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -242,7 +241,7 @@
     "  - Downloadable URL of the pretrained weights.\n",
     "  - A string corresponding to the available weight, for instance, [PyTorch resnet50](https://pytorch.org/vision/stable/models/generated/torchvision.models.resnet50.html) supports one\n",
     "of the following strings: \\[\"*DEFAULT*\", \"*IMAGENET1K_V1*\", \"*IMAGENET1K_V2*\"\\].\n",
-    "  - The same name as `architecture` which loads the network's default weights.\n",
+    "  - The same name as `architecture`, which loads the network's default weights.\n",
     "* `layers` determines the read-out (cut-off) layer(s). Which layers are available for each network\n",
     "can be obtained by calling the `models.available_layers()` function.\n",
     "\n",
@@ -272,7 +271,7 @@
     }
    ],
    "source": [
-    "architecture = 'resnet50'        # networks' architecture\n",
+    "architecture = 'resnet50'        # network's architecture\n",
     "weights = 'resnet50'             # the pretrained weights\n",
     "layer = 'block0'                 # the readout layer\n",
     "readout_kwargs = {               # parameters for extracting features from the pretrained network\n",
@@ -431,7 +430,7 @@
     }
    ],
    "source": [
-    "architecture = 'resnet50'        # networks' architecture\n",
+    "architecture = 'resnet50'        # network's architecture\n",
     "weights = 'resnet50'             # the pretrained weights\n",
     "img_size = 224                   # network's input size\n",
     "layer = 'block0'                 # the readout layer\n",
@@ -540,7 +539,7 @@
     }
    ],
    "source": [
-    "architecture = 'resnet50'        # networks' architecture\n",
+    "architecture = 'resnet50'        # network's architecture\n",
     "weights = 'resnet50'             # the pretrained weights\n",
     "img_size = 224                   # network's input size\n",
     "layer = 'block0'                 # the readout layer\n",
@@ -629,7 +628,7 @@
     }
    ],
    "source": [
-    "architecture = 'resnet50'        # networks' architecture\n",
+    "architecture = 'resnet50'        # network's architecture\n",
     "weights = 'resnet50'             # the pretrained weights\n",
     "img_size = 224                   # network's input size\n",
     "layer = 'block0'                 # the readout layer\n",

docs/source/notebooks/usage.ipynb

@@ -177,7 +177,7 @@ def _available_segmentation_layers(architecture: str) -> List[str]:
     elif 'mobilenet' in architecture:
         return _available_mobilenet_layers(architecture)
     else:
-        RuntimeError('Unsupported segmentation network: %s' % architecture)
+        raise RuntimeError('Unsupported segmentation network: %s' % architecture)
 
 
 def _available_imagenet_layers(architecture: str) -> List[str]:

osculari/models/pretrained_layers.py

@@ -96,3 +96,8 @@ def test_generic_features_size_fc():
     img_size = 128
     output_size = model_utils.generic_features_size(model, img_size)
     assert output_size == torch.Size([1000])
+
+
+def test_register_model_hooks_invalid_layers():
+    with pytest.raises(RuntimeError):
+        _ = model_utils.register_model_hooks(None, 'resnet50', ['invalid_layer'])

tests/models/model_utils_test.py

@@ -0,0 +1,27 @@
+"""
+Unit tests for pretrained_layers.py
+"""
+
+import pytest
+
+from osculari.models import pretrained_layers
+
+
+def test_available_segmentation_layers_invalid_network():
+    with pytest.raises(RuntimeError):
+        _ = pretrained_layers._available_segmentation_layers('invalid_architecture')
+
+
+def test_available_imagenet_layers_invalid_network():
+    with pytest.raises(RuntimeError):
+        _ = pretrained_layers._available_imagenet_layers('invalid_architecture')
+
+
+def test_available_layers_invalid_network():
+    with pytest.raises(RuntimeError):
+        _ = pretrained_layers.available_layers('invalid_architecture')
+
+
+def test_resnet_layer_invalid_layer():
+    with pytest.raises(RuntimeError):
+        _ = pretrained_layers.resnet_layer('invalid_layer')

tests/models/pretrained_layers_test.py

@@ -84,3 +84,38 @@ def test_model_features_invalid_layer():
     network = pretrained_models.get_pretrained_model('resnet18', 'none')
     with pytest.raises(RuntimeError):
         _ = pretrained_models.model_features(network, 'resnet18', 'invalid_layer')
+
+
+def test_vit_layers_invalid_blocks():
+    network = pretrained_models.get_pretrained_model('vit_b_32', 'none')
+    with pytest.raises(RuntimeError):
+        _ = pretrained_models.ViTLayers(network, 'block18')
+
+
+def test_vit_clip_layers_invalid_blocks():
+    network = pretrained_models.get_pretrained_model('clip_ViT-B/32', 'none')
+    with pytest.raises(RuntimeError):
+        _ = pretrained_models.ViTClipLayers(network.visual, 'block18')
+
+
+def test_regnet_layers_invalid_layer():
+    network = pretrained_models.get_pretrained_model('regnet_x_16gf', 'none')
+    with pytest.raises(RuntimeError):
+        _ = pretrained_models._regnet_features(network, 'invalid_layer')
+
+
+def test_vgg_layers_invalid_layer():
+    network = pretrained_models.get_pretrained_model('vgg11', 'none')
+    with pytest.raises(RuntimeError):
+        _ = pretrained_models._vgg_features(network, 'invalid_layer')
+
+
+def test_vgg_layers_classifier_layer():
+    network = pretrained_models.get_pretrained_model('vgg11', 'none')
+    features = pretrained_models._vgg_features(network, 'classifier0')
+    assert isinstance(list(features.children())[-1], torch.nn.Linear)
+
+
+def test_model_features_invalid_network():
+    with pytest.raises(RuntimeError):
+        _ = pretrained_models.model_features(None, 'invalid_architecture', 'fc')

tests/models/pretrained_models_test.py

@@ -3,10 +3,12 @@
 """
 
 import pytest
+import numpy as np
 import torch
 from torch.testing import assert_close
 
-from osculari.models import OddOneOutNet, load_paradigm_ooo, load_paradigm_2afc
+from osculari.models import OddOneOutNet, load_paradigm_ooo
+from osculari.models import readout
 
 
 def test_odd_one_out_net_few_inputs():
@@ -38,7 +40,7 @@ def test_odd_one_out_net_init_diff():
 
 @pytest.mark.parametrize("merge_paradigm,expected", [("cat", 4), ("diff", 4)])
 def test_odd_one_out_net_forward_cat(merge_paradigm, expected):
-    # Test the forward pass of OddOneOutNet with merge_paradigm='cat'
+    # Test the forward pass of OddOneOutNet with merge_paradigm
     input_nodes = 4
     img_size = 224
     net = OddOneOutNet(input_nodes=input_nodes, merge_paradigm=merge_paradigm,
@@ -54,6 +56,41 @@ def test_odd_one_out_net_forward_cat(merge_paradigm, expected):
     assert output.shape == (2, input_nodes)
 
 
+def test_readout_mix_features_no_pooling():
+    # Test the readout with mix features with no pooling
+    input_nodes = 4
+    img_size = 224
+    with pytest.raises(RuntimeError):
+        _ = OddOneOutNet(input_nodes=input_nodes, merge_paradigm='cat', architecture='resnet50',
+                         weights=None, layers=['block0', 'fc'], img_size=img_size)
+
+
+def test_readout_mix_features_invalid_pooling():
+    # Test the readout with mix features with no pooling
+    input_nodes = 4
+    img_size = 224
+    with pytest.raises(RuntimeError):
+        _ = OddOneOutNet(input_nodes=input_nodes, merge_paradigm='cat', architecture='resnet50',
+                         weights=None, layers=['block0', 'fc'], img_size=img_size,
+                         pooling='invalid')
+
+
+def test_readout_mix_features_():
+    # Test the readout with mix features
+    input_nodes = 4
+    img_size = 224
+    net = OddOneOutNet(input_nodes=input_nodes, merge_paradigm='cat', architecture='resnet50',
+                       weights=None, layers=['block0', 'fc'], img_size=img_size, pooling='avg_2_2')
+
+    x1 = torch.randn(2, 3, img_size, img_size)
+    x2 = torch.randn(2, 3, img_size, img_size)
+    x3 = torch.randn(2, 3, img_size, img_size)
+    x4 = torch.randn(2, 3, img_size, img_size)
+
+    output = net(x1, x2, x3, x4)
+    assert output.shape == (2, input_nodes)
+
+
 def test_odd_one_out_net_serialization():
     # Test the serialization of OddOneOutNet
     input_nodes = 4
@@ -83,3 +120,21 @@ def test_odd_one_out_net_loss_function():
 
     loss = net.loss_function(output, target)
     assert loss.item() >= 0
+
+
+def test_preprocess_transform():
+    # Test the preprocess_transform of BackboneNet
+    net = readout.BackboneNet(architecture='taskonomy_autoencoding', weights=None)
+
+    # Create a dummy input signal (replace this with your actual input)
+    input_signal = np.random.uniform(size=(224, 224, 3))
+
+    # Apply the transformations
+    transform = net.preprocess_transform()
+    output_signal = transform(input_signal)
+
+    # Check if the output has the correct shape
+    assert output_signal.shape == (3, 224, 224)
+
+    # Check if the output has the correct normalization
+    assert -1 <= torch.all(output_signal) <= 1