removed old activations iterator. Added basic tests for same equivariance

Author: facundoq

tests/pytorch/test_measure.py

@@ -3,7 +3,7 @@
 import tmeasures as tm
 import numpy as np
 from numpy.testing import assert_allclose
-from .utils import ConstantModel,ConstantDataset,RandomModel,RepeatedIdentitySet,MeasureFixture
+from .utils import ConstantModel,ConstantDataset, IdentityModel,RandomModel,RepeatedIdentitySet,MeasureFixture
 from torch import nn
 
 default_options = tm.pytorch.PyTorchMeasureOptions(batch_size=32)
@@ -14,13 +14,12 @@ def constant_model_invariance(n:int,bs:int):
     o = tm.pytorch.PyTorchMeasureOptions(batch_size=bs)
     transformations = RepeatedIdentitySet(n)
     dataset = ConstantDataset(n,torch.Tensor((1,)))
-    transformations = RepeatedIdentitySet(n)
     output_shape = (2,2)
     output = torch.rand(output_shape)
     result = np.zeros(output.shape)
     result_nv = np.ones(output.shape)
     model = torch.nn.Sequential(ConstantModel(output))
-    sv,tv,nv = measures
+    sv,tv,nv = invariance_measures
     return [
             MeasureFixture(model, sv,[result],dataset,transformations,options=o),
             MeasureFixture(model, tv,[result],dataset,transformations,options=o),
@@ -34,11 +33,16 @@ def constant_model_invariance_options():
 def test_constant_model_invariance(f:MeasureFixture):
     f.assert_fixture(atol=1e-5) 
 
-measures = [tm.pytorch.SampleVarianceInvariance(),
+invariance_measures = [tm.pytorch.SampleVarianceInvariance(),
             tm.pytorch.TransformationVarianceInvariance(),
             tm.pytorch.NormalizedVarianceInvariance()
             ]
 
+same_equivariance_measures = [tm.pytorch.SampleVarianceSameEquivariance(),
+            tm.pytorch.TransformationVarianceSameEquivariance(),
+            tm.pytorch.NormalizedVarianceSameEquivariance()
+            ]
+
 def random_model_invariance_options():
     sample_size_order = 2
     n = 10**sample_size_order
@@ -52,7 +56,7 @@ def random_model_invariance_options():
     model = torch.nn.Sequential(RandomModel(output_shape,2,3))
     result = np.ones(output_shape)*std
     result_nv = np.ones(output_shape)
-    sv,tv,nv = measures
+    sv,tv,nv = invariance_measures
     return [
             MeasureFixture(model, sv,[result],dataset,transformations,options=o),
             MeasureFixture(model, tv,[result],dataset,transformations,options=o),
@@ -63,6 +67,26 @@ def random_model_invariance_options():
 def test_random_model_invariance(f:MeasureFixture):
     f.assert_fixture(atol=1e-1)
 
+
+
+def constant_model_same_equivariance_options(n:int=16,bs:int=4):
+    o = tm.pytorch.PyTorchMeasureOptions(batch_size=bs)
+    transformations = RepeatedIdentitySet(n)
+    value = torch.Tensor(((2,3),(4,5)))
+    dataset = ConstantDataset(n,value)
+    result = np.zeros(value.shape)
+    result_nv = np.ones(value.shape)
+    model = torch.nn.Sequential(IdentityModel())
+    sev,tev,nev = same_equivariance_measures
+    return [
+            MeasureFixture(model, sev,[result],dataset,transformations,options=o),
+            MeasureFixture(model, tev,[result],dataset,transformations,options=o),
+            MeasureFixture(model, nev,[result_nv],dataset,transformations,options=o),
+    ]   
+@pytest.mark.parametrize("f",constant_model_same_equivariance_options())
+def test_constant_model_same_equivariance(f:MeasureFixture):
+    f.assert_fixture(atol=1e-5)
+
 if __name__ == "__main__":
     import logging
     # logging.basicConfig()

tests/pytorch/utils.py

@@ -60,7 +60,7 @@ def __getitem__(self, index):
         return self.value
 
 
-class RepeatedIdentitySet(tm.pytorch.transformations.PyTorchTransformationSet):
+class RepeatedIdentitySet(tm.pytorch.transformations.PyTorchInvertibleTransformationSet):
     def __init__(self,transformations=1):
         super().__init__([tm.pytorch.transformations.IdentityTransformation()]*transformations)
     def valid_input(self):

tmeasures/pytorch/__init__.py

@@ -22,10 +22,10 @@
 """
 
 from .model import ActivationsModule,AutoActivationsModule,get_activations,ManualActivationsModule
-from .base import PyTorchMeasure,PyTorchMeasureOptions,ActivationsByLayer,PyTorchMeasureResult,STMatrixIterator,PyTorchLayerMeasure
+from .base import PyTorchMeasure,PyTorchMeasureOptions,ActivationsByLayer,PyTorchMeasureResult,STMatrixIterator,PyTorchActivationMeasure
 from .transformations import PyTorchTransformationSet,PyTorchTransformation
 
-from .activations_iterator_base import PytorchActivationsIterator,InvertedPytorchActivationsIterator,BothPytorchActivationsIterator,NormalPytorchActivationsIterator
+#from .activations_iterator_base import PytorchActivationsIterator,InvertedPytorchActivationsIterator,BothPytorchActivationsIterator,NormalPytorchActivationsIterator
 
 from .by_layer import PyTorchMeasureByLayer
 

tmeasures/pytorch/activations_iterator.py

@@ -11,7 +11,7 @@
 # from .activations_transformer import ActivationsTransformer
 from .. import InvertibleTransformation, Transformation
 from . import ActivationsModule
-from .base import PyTorchLayerMeasure, PyTorchMeasure, PyTorchMeasureOptions
+from .base import PyTorchActivationMeasure, PyTorchMeasure, PyTorchMeasureOptions
 from .computation_model import ThreadsComputationModel
 from .dataset2d import Dataset2D, STDataset
 from .transformations import PyTorchTransformation
@@ -124,12 +124,12 @@ def split_activations_by_row(self,activations:ActivationValues,i_rows:list[int])
             start=end
             yield current_row,activations_row
 
-    def evaluate(self, m: PyTorchLayerMeasure):
-        layers = self.model.activation_names()
+    def evaluate(self, m: PyTorchActivationMeasure):
+        activation_names = self.model.activation_names()
         rows, cols = self.dataset.len0, self.dataset.len1
         logger.debug(f"Main thread {threading.get_ident()}")
-        measure_functions = {l:m.eval for l in layers}
+        measure_functions = {l:m.eval for l in activation_names}
         model_evaluating_function = self.feed_measures
-        max_workers = len(layers)+1
+        max_workers = len(activation_names)+1
         tm = ThreadsComputationModel(model_evaluating_function,measure_functions,max_workers,rows,cols,self.o.batch_size)
         return tm.execute()