updated examples to new get_activations api

Author: facundoq

docs/examples/ResNet Invariance with TinyImageNet.ipynb

@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/",
@@ -46,14 +46,14 @@
     "\n",
     "%load_ext autoreload\n",
     "%autoreload 2\n",
+    "from tempfile import TemporaryDirectory\n",
     "import torch \n",
     "\n",
     "from pathlib import Path\n",
-    "\n",
-    "\n",
     "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-    "results_path = Path(\"~/tm_example_pytorch/\").expanduser()\n",
-    "results_path.mkdir(parents=True, exist_ok=True)"
+    "results_path = Path(TemporaryDirectory().name)/\"tm_example_pytorch\"\n",
+    "results_path.mkdir(parents=True, exist_ok=True)\n",
+    "print(f\"Saving results to {results_path}\")"
    ]
   },
   {
@@ -279,7 +279,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -313,11 +313,14 @@
     "# print(model)\n",
     "\n",
     "# Create an ActivationsModule from the vanilla model\n",
-    "activations_module = tm.pytorch.AutoActivationsModule(normalized_model)\n",
-    "print(activations_module.activation_names())\n",
-    "def filter(module, name): return True #name.endswith(\"conv2\")\n",
     "\n",
-    "activations_module = tm.pytorch.model.FilteredActivationsModule(activations_module,filter)\n",
+    "activations = tm.pytorch.get_activations(model)\n",
+    "def filter_stochastic(a):\n",
+    "    return not str(a).startswith(\"StochasticDepth\")\n",
+    "activations = {k:v for k,v in activations.items() if filter_stochastic(k)}\n",
+    "\n",
+    "activations_module = tm.pytorch.ActivationsModule(model,activations)\n",
+    "\n",
     "print(activations_module.activation_names())"
    ]
   },
@@ -336,7 +339,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -357,7 +360,7 @@
     "        measure_result = pickle.load(f)\n",
     "        print(f\"loaded measure results from {filepath}\", measure_result) \n",
     "else:\n",
-    "    options = tm.pytorch.PyTorchMeasureOptions(batch_size=128, num_workers=0,model_device=device,measure_device=device,data_device=\"cpu\")\n",
+    "    options = tm.pytorch.PyTorchMeasureOptions(batch_size=128, num_workers=0,model_device=device,measure_device=device,data_device=torch.device(\"cpu\"))\n",
     "\n",
     "    # Define the measure and evaluate it\n",
     "    measure = tm.pytorch.NormalizedVarianceInvariance()\n",
@@ -425,7 +428,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -453,9 +456,8 @@
     "from tmeasures.visualization.weights import reorder_conv2d_weights,plot_conv2d_filters,plot_conv2d_filters_rgb\n",
     "\n",
     "activation_name = \"/ResNet_1/layer3/BasicBlock_1/conv2\"\n",
-    "#\"/ResNet_1/layer1/BasicBlock_0/conv2\"\n",
-    "activation_index = activations_module.inner_model.names.index(activation_name)\n",
-    "activation = activations_module.inner_model.activations[activation_index]\n",
+    "\n",
+    "activation = activations[activation_name]\n",
     "invariance = measure_result.layers_dict()[activation_name]\n",
     "# print(activation)\n",
     "# print(invariance.shape)\n",
@@ -563,7 +565,7 @@
    "provenance": []
   },
   "kernelspec": {
-   "display_name": "tm",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },

docs/examples/Variance to rotations of a CNN trained on MNIST with PyTorch.ipynb

@@ -35,9 +35,12 @@
     "from pathlib import Path\n",
     "\n",
     "torch.manual_seed(0)\n",
+    "from tempfile import TemporaryDirectory\n",
+    "\n",
     "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-    "results_path = Path(\"~/.tmeasures/\").expanduser()\n",
-    "results_path.mkdir(parents=True, exist_ok=True)"
+    "results_path = Path(TemporaryDirectory().name)/\"tm_example_pytorch\"\n",
+    "results_path.mkdir(parents=True, exist_ok=True)\n",
+    "print(f\"Saving results to {results_path}\")"
    ]
   },
   {

docs/examples/basic_example_pytorch.py

@@ -11,7 +11,7 @@
 import matplotlib.pyplot as plt
 from torch import nn
 
-from tmeasures.pytorch.model import AutoActivationsModule, ManualActivationsModule
+from tmeasures.pytorch.model import AutoActivationsModule, ActivationsModule
 
 class Flatten(nn.Module):
     def forward(self, input: torch.Tensor):
@@ -132,7 +132,7 @@ def __getitem__(self, index):
 
     print("Activations in model:")
     print(activations.keys())
-    filtered_model = ManualActivationsModule(model,activations)
+    filtered_model = ActivationsModule(model,activations)
     activations_module = AutoActivationsModule(model)
 
     average_fm=tm.pytorch.AverageFeatureMaps()

docs/examples/brighntness_invariance_efficientnet_pretrained.py

@@ -8,14 +8,15 @@
 # %pip install tinyimagenet
 # %pip install scikit-learn
 
-# %load_ext autoreload
-# %autoreload 2
+from tempfile import TemporaryDirectory
 import torch 
 
 from pathlib import Path
 
-results_path = Path("~/tm_example_pytorch/").expanduser()
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+results_path = Path(TemporaryDirectory().name)/"tm_example_pytorch"
 results_path.mkdir(parents=True, exist_ok=True)
+print(f"Saving results to {results_path}")
 
 from torchvision import models
 
@@ -86,7 +87,9 @@ def __getitem__(self, index):
 def filter_stochastic(a):
     return not str(a).startswith("StochasticDepth")
 
-activations_module = tm.pytorch.AutoActivationsModule(model,filter=filter_stochastic)
+activations = tm.pytorch.get_activations(model)
+activations = {k:v for k,v in activations.items() if filter_stochastic(k)}
+activations_module = tm.pytorch.ActivationsModule(model,activations)
 
     # a.training=False
 """# Computing the measure

docs/examples/brightness_invariance_efficientnet_pretrained.py

@@ -1,4 +1,5 @@
 #%%
+from tempfile import TemporaryDirectory
 import numpy as np
 import matplotlib.pyplot as plt
 
@@ -20,8 +21,9 @@
 import torchvision
 #%%
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-results_path = Path("~/tm_example_pytorch/").expanduser()
+results_path = Path(TemporaryDirectory().name)/"tm_example_pytorch"
 results_path.mkdir(parents=True, exist_ok=True)
+print(f"Saving results to {results_path}")
 # %%
 
 model = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.IMAGENET1K_V1)
@@ -97,11 +99,13 @@ def filter_stochastic(a):
         return True
     else:
         return False
-def filter_vit(a):
-    return str(a).startswith("GELU")
-    #and (not str(a).startswith("NonDynamicallyQuantizableLinear"))
 
-activations_module = tm.pytorch.AutoActivationsModule(model,filter=filter_stochastic)
+activations = tm.pytorch.get_activations(model)
+activations = {k:v for k,v in activations.items() if filter_stochastic(k)}
+activations_module = tm.pytorch.ActivationsModule(model,activations)
+
+
+    
 
 #%%
 # Define options for computing the measure

docs/examples/brightness_transformation.py

@@ -6,6 +6,7 @@
 
 # # Define a CNN model that implements ObservableLayersModule
 import os
+from tempfile import TemporaryDirectory
 import tmeasures as tm
 import torch
 from torchvision import transforms,datasets, models
@@ -15,7 +16,9 @@
 if __name__ == '__main__':
     torch.manual_seed(0)
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    data_path = Path("~/tm_example_pretrained/").expanduser()
+    data_path = Path(TemporaryDirectory().name)/"tm_example_pytorch"
+    data_path.mkdir(parents=True, exist_ok=True)
+    print(f"Saving results to {data_path}")
 
     # MODEL
 
@@ -57,7 +60,9 @@ def __getitem__(self, index):
 
     # evaluate measure
     model.eval()
-    activations_module = tm.pytorch.AutoActivationsModule(model)
+    
+    activations = tm.pytorch.get_activations(model)
+    activations_module = tm.pytorch.ActivationsModule(model,activations)
 
     print("Activations in model:")
     print(activations_module.activation_names())

docs/examples/resnet_pretrained_rotation_invariance.py

@@ -21,7 +21,7 @@
 * :class:`.NormalizedVarianceSameEquivariance`
 """
 
-from .model import ActivationsModule,AutoActivationsModule,get_activations,ManualActivationsModule
+from .model import BaseActivationsModule,AutoActivationsModule,get_activations,ActivationsModule
 from .base import PyTorchMeasure,PyTorchMeasureOptions,ActivationsByLayer,PyTorchMeasureResult,STMatrixIterator,PyTorchActivationMeasure
 from .transformations import PyTorchTransformationSet,PyTorchTransformation
 

tmeasures/pytorch/__init__.py

@@ -10,7 +10,7 @@
 
 # from .activations_transformer import ActivationsTransformer
 from .. import InvertibleTransformation, Transformation
-from . import ActivationsModule
+from . import BaseActivationsModule
 from .base import PyTorchActivationMeasure, PyTorchMeasure, PyTorchMeasureOptions
 from .computation_model import ThreadsComputationModel
 from .dataset2d import Dataset2D, STDataset
@@ -48,7 +48,7 @@ def transform(self, activations: torch.Tensor, x: torch.Tensor, transformations:
 class PytorchActivationsIterator:
 
 
-    def __init__(self, model: ActivationsModule, dataset: Dataset2D, o: PyTorchMeasureOptions,
+    def __init__(self, model: BaseActivationsModule, dataset: Dataset2D, o: PyTorchMeasureOptions,
                  activations_transformer: ActivationsTransformer = IdentityActivationsTransformer()):
         """
         Constructor for PytorchActivationsIterator.