Repository: stanfordnlp/pyvene (language: python)

Issue:
[Minor] Adding in subspace support for lambda
## Description

Currently, the code assumes whenever we use customized function or lambda expression based interventions, we only allow two arguments. This. change allows us to specify the subspace for these interventions as well.

Ideally, the third argument could be anything for these customized interventions, which will be a future change.

## Testing Done

Tutorial test is added.

## Checklist:

- [x] My PR title strictly follows the format: `[Your Priority] Your Title`
- [x] I have attached the testing log above
- [x] I provide enough comments to my code
- [x] I have changed documentations
- [x] I have added tests for my changes



Discussion / hints:

Fix patch:
diff --git a/.gitignore b/.gitignore
index 87418378..5a243027 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,7 @@ _hidden_local_dev*
 tmp_dir_new*/
 tmp/
 tmp_*/
+tutorial*/*/*/*.bin
 notebooks/figures/
 *.tsv
 *.csv
diff --git a/pyvene/__init__.py b/pyvene/__init__.py
index e3ed94dc..c6c44dbe 100644
--- a/pyvene/__init__.py
+++ b/pyvene/__init__.py
@@ -35,6 +35,7 @@
 from .models.gpt2.modelings_intervenable_gpt2 import create_gpt2
 from .models.gpt2.modelings_intervenable_gpt2 import create_gpt2_lm
 from .models.blip.modelings_intervenable_blip import create_blip
+from .models.blip.modelings_intervenable_blip_itm import create_blip_itm
 from .models.gpt_neo.modelings_intervenable_gpt_neo import create_gpt_neo
 from .models.gpt_neox.modelings_intervenable_gpt_neox import create_gpt_neox
 from .models.gru.modelings_intervenable_gru import create_gru
diff --git a/pyvene/models/blip/modelings_blip_itm.py b/pyvene/models/blip/modelings_blip_itm.py
new file mode 100644
index 00000000..dfdbd9ed
--- /dev/null
+++ b/pyvene/models/blip/modelings_blip_itm.py
@@ -0,0 +1,105 @@
+import torch
+import torch.nn as nn
+from transformers import BlipConfig, BlipForImageTextRetrieval
+from transformers.utils import ModelOutput
+from typing import Optional, Union, Tuple, Dict
+
+
+class BlipITMWrapper(nn.Module):
+    def __init__(
+        self, model: BlipForImageTextRetrieval, use_itm_not_contrastive: bool = True
+    ):
+        super(BlipITMWrapper, self).__init__()
+        self.model_vis = model.vision_model
+        self.model_text_enc = model.text_encoder
+        self.model_vis_proj = model.vision_proj
+        self.model_text_proj = model.text_proj
+        self.model_itm = model.itm_head
+        # do I need to keep decoder_pad_token_id and decoder_start_token_id? might be a mistake in the HF implementation lol
+        self.config = model.config
+        self.eos_token_id = (model.config.text_config.sep_token_id,)
+        self.pad_token_id = model.config.text_config.pad_token_id
+        self.output_attentions = model.config.output_attentions
+        self.use_return_dict = model.config.use_return_dict
+        self.output_hidden_states = model.config.output_hidden_states
+
+        self.use_itm_head = use_itm_not_contrastive
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor,
+        pixel_values: torch.FloatTensor,
+        attention_mask: Optional[torch.LongTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, Dict]:
+        return_dict = return_dict if return_dict is not None else self.use_return_dict
+        output_attentions = (
+            output_attentions
+            if output_attentions is not None
+            else self.output_attentions
+        )
+        output_hidden_states = (
+            output_hidden_states
+            if output_hidden_states is not None
+            else self.output_hidden_states
+        )
+
+        vision_outputs = self.model_vis(
+            pixel_values=pixel_values,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        image_embeds = vision_outputs[0].to(self.model_text_enc.device)
+        input_ids = input_ids.to(self.model_text_enc.device)
+        
+        if self.use_itm_head:
+            image_attention_mask = torch.ones(
+                image_embeds.size()[:-1], dtype=torch.long
+            )
+
+            caption_embeds = self.model_text_enc(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                encoder_hidden_states=image_embeds,
+                encoder_attention_mask=image_attention_mask,
+                output_hidden_states=True,
+            )
+            caption_embeds = (
+                caption_embeds[0]
+                if not return_dict
+                else caption_embeds.last_hidden_state
+            )
+
+            output = self.model_itm(caption_embeds[:, 0, :])
+        else:
+            caption_embeds = self.model_text_enc(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                return_dict=return_dict,
+                output_hidden_states=True,
+            )
+            caption_embeds = (
+                caption_embeds[0]
+                if not return_dict
+                else caption_embeds.last_hidden_state
+            )
+
+            image_feat = nn.functional.normalize(
+                self.vision_proj(image_embeds[:, 0, :]), dim=-1
+            )
+            text_feat = nn.functional.normalize(
+                self.text_proj(caption_embeds[:, 0, :]), dim=-1
+            )
+
+            output = image_feat @ text_feat.t()
+
+        return {
+            "itm_score": output,
+            "image_embeds": image_embeds,
+            "encoder_last_hidden_state": caption_embeds.last_hidden_state,
+            "encoder_hidden_states": caption_embeds.hidden_states,
+        }
diff --git a/pyvene/models/blip/modelings_intervenable_blip.py b/pyvene/models/blip/modelings_intervenable_blip.py
index c98ea9fb..904d5ae7 100644
--- a/pyvene/models/blip/modelings_intervenable_blip.py
+++ b/pyvene/models/blip/modelings_intervenable_blip.py
@@ -100,7 +100,7 @@
 
 
 def create_blip(name="Salesforce/blip-vqa-base", cache_dir=None):
-    """Creates a GPT2 model, config, and tokenizer from the given name and revision"""
+    """Creates a BLIP VQA model, config, and tokenizer from the given name and revision"""
     from transformers import BlipConfig, BlipProcessor, BlipForQuestionAnswering
 
     config = BlipConfig.from_pretrained(name)
diff --git a/pyvene/models/blip/modelings_intervenable_blip_itm.py b/pyvene/models/blip/modelings_intervenable_blip_itm.py
new file mode 100644
index 00000000..cd00d6ae
--- /dev/null
+++ b/pyvene/models/blip/modelings_intervenable_blip_itm.py
@@ -0,0 +1,96 @@
+"""
+Each modeling file in this library is a mapping between
+abstract naming of intervention anchor points and actual
+model module defined in the huggingface library.
+
+We also want to let the intervention library know how to
+config the dimensions of intervention based on model config
+defined in the huggingface library.
+"""
+
+from ..constants import *
+
+"""blip ITM base model"""
+blip_itm_type_to_module_mapping = {
+    # TODO: not sure why these are commented out in the BlipVQA implementation
+    # 'vis.block_input': ("vision_model.encoder.layers[%s]", CONST_INPUT_HOOK),
+    # 'vis.block_output': ("vision_model.encoder.layers[%s]", CONST_OUTPUT_HOOK),
+    # 'vis.mlp_activation': ("vision_model.encoder.layers[%s].mlp.fc1", CONST_OUTPUT_HOOK),
+    # 'vis.mlp_output': ("vision_model.encoder.layers[%s].mlp", CONST_OUTPUT_HOOK),
+    # 'vis.mlp_input': ("vision_model.encoder.layers[%s].mlp", CONST_INPUT_HOOK),
+    # 'vis.attention_value_output': ("vision_model.encoder.layers[%s].self_attn.projection", CONST_INPUT_HOOK),
+    # 'vis.attention_output': ("vision_model.encoder.layers[%s].self_attn", CONST_OUTPUT_HOOK),
+    # 'vis.attention_input': ("vision_model.encoder.layers[%s].self_attn", CONST_INPUT_HOOK),
+    "block_input": ("text_encoder.encoder.layer[%s]", CONST_INPUT_HOOK),
+    "block_output": ("text_encoder.encoder.layer[%s]", CONST_INPUT_HOOK),
+    "mlp_activation": (
+        "text_encoder.encoder.layer[%s].intermediate.dense",
+        CONST_OUTPUT_HOOK,
+    ),
+    "mlp_output": ("text_encoder.encoder.layer[%s].output", CONST_OUTPUT_HOOK),
+    "mlp_input": ("text_encoder.encoder.layer[%s].intermediate", CONST_INPUT_HOOK),
+    "attention_value_output": (
+        "text_encoder.encoder.layer[%s].attention.output.dense",
+        CONST_INPUT_HOOK,
+    ),
+    "attention_output": (
+        "text_encoder.encoder.layer[%s].attention.output",
+        CONST_OUTPUT_HOOK,
+    ),
+    "attention_input": ("text_encoder.encoder.layer[%s].attention", CONST_INPUT_HOOK),
+    "itm_output": ("itm_head", CONST_OUTPUT_HOOK),
+}
+
+
+blip_itm_type_to_dimension_mapping = {
+    # 'vis.block_input': ("image_text_hidden_size", ),
+    # 'vis.block_output': ("image_text_hidden_size", ),
+    # 'vis.mlp_activation': ("projection_dim", ),
+    # 'vis.mlp_output': ("image_text_hidden_size", ),
+    # 'vis.mlp_input': ("image_text_hidden_size", ),
+    # 'vis.attention_value_output': ("image_text_hidden_size/text_config.num_attention_heads", ),
+    # 'vis.attention_output': ("image_text_hidden_size", ),
+    # 'vis.attention_input': ("image_text_hidden_size", ),
+    "block_input": ("image_text_hidden_size",),
+    "block_output": ("image_text_hidden_size",),
+    "mlp_activation": ("projection_dim",),
+    "mlp_output": ("image_text_hidden_size",),
+    "mlp_input": ("image_text_hidden_size",),
+    "attention_value_output": (
+        "image_text_hidden_size/text_config.num_attention_heads",
+    ),
+    "attention_output": ("image_text_hidden_size",),
+    "attention_input": ("image_text_hidden_size",),
+    "cross_attention_value_output": (
+        "image_text_hidden_size/text_config.num_attention_heads",
+    ),
+    "cross_attention_output": ("image_text_hidden_size",),
+    "cross_attention_input": ("image_text_hidden_size",),
+    "itm_input": ("image_text_hidden_size",),
+    "itm_output": (2,), # TODO: not sure how to specify this dim as it's not an attr in BlipConfig
+}
+
+
+"""blip model with wrapper"""
+blip_itm_wrapper_type_to_module_mapping = {}
+for k, v in blip_itm_type_to_module_mapping.items():
+    blip_itm_wrapper_type_to_module_mapping[k] = (
+        v[0].replace("text_encoder", "model_text_enc"), # NOTE: don't fully understand why we do this
+        v[1],
+    )
+
+
+blip_itm_wrapper_type_to_dimension_mapping = blip_itm_type_to_dimension_mapping
+
+
+def create_blip_itm(name="Salesforce/blip-itm-base-coco", cache_dir=None):
+    """Creates a BLIP ITM model, config, and tokenizer from the given name and revision"""
+    from transformers import BlipConfig, BlipProcessor, BlipForImageTextRetrieval
+
+    config = BlipConfig.from_pretrained(name)
+    processor = BlipProcessor.from_pretrained(name)
+    blip = BlipForImageTextRetrieval.from_pretrained(
+        name, config=config, cache_dir=cache_dir
+    )
+    print("loaded model")
+    return config, processor, blip
diff --git a/pyvene/models/intervenable_base.py b/pyvene/models/intervenable_base.py
index b903774c..85f8e47f 100644
--- a/pyvene/models/intervenable_base.py
+++ b/pyvene/models/intervenable_base.py
@@ -1,7 +1,7 @@
-import json, logging, torch
+import json, logging, torch, types
 import numpy as np
 from collections import OrderedDict
-from typing import List, Optional, Tuple, Union, Dict
+from typing import List, Optional, Tuple, Union, Dict, Any
 
 from .basic_utils import *
 from .modeling_utils import *
@@ -20,8 +20,16 @@
 
 from torch import optim
 from transformers import get_linear_schedule_with_warmup
+from dataclasses import dataclass
+from transformers.utils import ModelOutput
 from tqdm import tqdm, trange
 
+@dataclass
+class IntervenableModelOutput(ModelOutput):
+    original_outputs: Optional[Any] = None
+    intervened_outputs: Optional[Any] = None
+    collected_activations: Optional[Any] = None
+
 
 class IntervenableModel(nn.Module):
     """
@@ -41,6 +49,7 @@ def __init__(self, config, model, **kwargs):
         self.is_model_stateless = is_stateless(model)
         self.config.model_type = type(model) # backfill
         self.use_fast = kwargs["use_fast"] if "use_fast" in kwargs else False
+
         self.model_has_grad = False
         if self.use_fast:
             logging.warn(
@@ -561,6 +570,10 @@ def _gather_intervention_output(
                 original_output = output[0].clone()
             else:
                 original_output = output.clone()
+            # for non-sequence models, there is no concept of
+            # unit location anyway.
+            if unit_locations is None:
+                return original_output
             # gather subcomponent
             original_output = output_to_subcomponent(
                 original_output,
@@ -598,6 +611,11 @@ def _scatter_intervention_output(
             original_output = output[0]
         else:
             original_output = output
+        # for non-sequence-based models, we simply replace
+        # all the activations.
+        if unit_locations is None:
+            original_output[:] = intervened_representation[:]
+            return original_output
         
         component = self.representations[
             representations_key
@@ -634,11 +652,13 @@ def _intervention_getter(
 
             def hook_callback(model, args, kwargs, output=None):
                 if self._is_generation:
-                    is_prompt = self._key_getter_call_counter[key] == 0
-                    if not self._intervene_on_prompt or is_prompt:
-                        self._key_getter_call_counter[key] += 1
-                    if self._intervene_on_prompt ^ is_prompt:
-                        return  # no-op
+                    pass
+                    # for getter, there is no restriction.
+                    # is_prompt = self._key_getter_call_counter[key] == 0
+                    # if not self._intervene_on_prompt or is_prompt:
+                    #     self._key_getter_call_counter[key] += 1
+                    # if self._intervene_on_prompt ^ is_prompt:
+                    #     return  # no-op
                 if output is None:
                     if len(args) == 0:  # kwargs based calls
                         # PR: https://github.com/frankaging/align-transformers/issues/11
@@ -718,6 +738,9 @@ def _reconcile_stateful_cached_activations(
         intervening_unit_locations,
     ):
         """Based on the key, we consolidate activations based on key's state"""
+        if key not in self.activations:
+            return None
+
         cached_activations = self.activations[key]
         if self.is_model_stateless:
             # nothing to reconcile if stateless
@@ -771,9 +794,10 @@ def _intervention_setter(
         handlers = []
         for key_i, key in enumerate(keys):
             intervention, module_hook = self.interventions[key]
-            self._batched_setter_activation_select[key] = [
-                0 for _ in range(len(unit_locations_base[0]))
-            ]  # batch_size
+            if unit_locations_base[0] is not None:
+                self._batched_setter_activation_select[key] = [
+                    0 for _ in range(len(unit_locations_base[0]))
+                ]  # batch_size
 
             def hook_callback(model, args, kwargs, output=None):
                 if self._is_generation:
@@ -814,14 +838,27 @@ def hook_callback(model, args, kwargs, output=None):
                     # no-op to the output
                     
                 else:
-                    if intervention.is_source_constant:
-                        intervened_representation = do_intervention(
-                            selected_output,
-                            None,
-                            intervention,
-                            subspaces[key_i] if subspaces is not None else None,
-                        )
+                    if not isinstance(self.interventions[key][0], types.FunctionType):
+                        if intervention.is_source_constant:
+                            intervened_representation = do_intervention(
+                                selected_output,
+                                None,
+                                intervention,
+                                subspaces[key_i] if subspaces is not None else None,
+                            )
+                        else:
+                            intervened_representation = do_intervention(
+                                selected_output,
+                                self._reconcile_stateful_cached_activations(
+                                    key,
+                                    selected_output,
+                                    unit_locations_base[key_i],
+                                ),
+                                intervention,
+                                subspaces[key_i] if subspaces is not None else None,
+                            )
                     else:
+                        # highly unlikely it's a primitive intervention type
                         intervened_representation = do_intervention(
                             selected_output,
                             self._reconcile_stateful_cached_activations(
@@ -832,7 +869,9 @@ def hook_callback(model, args, kwargs, output=None):
                             intervention,
                             subspaces[key_i] if subspaces is not None else None,
                         )
-                
+                    if intervened_representation is None:
+                        return
+
                     # setter can produce hot activations for shared subspace interventions if linked
                     if key in self._intervention_reverse_link:
                         self.hot_activations[
@@ -863,9 +902,9 @@ def _input_validation(
         subspaces,
     ):
         """Fail fast input validation"""
-        if self.mode == "parallel":
+        if self.mode == "parallel" and unit_locations is not None:
             assert "sources->base" in unit_locations or "base" in unit_locations
-        elif activations_sources is None and self.mode == "serial":
+        elif activations_sources is None and unit_locations is not None and self.mode == "serial":
             assert "sources->base" not in unit_locations
         
         # sources may contain None, but length should match
@@ -941,6 +980,7 @@ def _wait_for_forward_with_parallel_intervention(
         all_set_handlers = HandlerList([])
         unit_locations_sources = unit_locations["sources->base"][0]
         unit_locations_base = unit_locations["sources->base"][1]
+
         # for each source, we hook in getters to cache activations
         # at each aligning representations
         if activations_sources is None:
@@ -973,6 +1013,7 @@ def _wait_for_forward_with_parallel_intervention(
             for key in keys:
                 # skip in case smart jump
                 if key in self.activations or \
+                    isinstance(self.interventions[key][0], types.FunctionType) or \
                     self.interventions[key][0].is_source_constant:
                     set_handlers = self._intervention_setter(
                         [key],
@@ -1042,6 +1083,7 @@ def _wait_for_forward_with_serial_intervention(
             for key in keys:
                 # skip in case smart jump
                 if key in self.activations or \
+                    isinstance(self.interventions[key][0], types.FunctionType) or \
                     self.interventions[key][0].is_source_constant:
                     # set with intervened activation to source_i+1
                     set_handlers = self._intervention_setter(
@@ -1065,6 +1107,10 @@ def _broadcast_unit_locations(
         batch_size,
         unit_locations
     ):
+        if unit_locations is None:
+            # this means, we don't filter based on location at all.
+            return {"sources->base": ([None]*len(self.interventions), [None]*len(self.interventions))}
+        
         if self.mode == "parallel":
             _unit_locations = {}
             for k, v in unit_locations.items():
@@ -1171,7 +1217,7 @@ def _broadcast_sources(
         """Broadcast simple inputs to a dict"""
         _sources = sources
         if len(sources) == 1 and len(self._intervention_group) > 1:
-            for _ in range(len(self._intervention_group)):
+            for _ in range(len(self._intervention_group)-1):
                 _sources += [sources[0]]
         else:
             _sources = sources
@@ -1201,6 +1247,8 @@ def forward(
         unit_locations: Optional[Dict] = None,
         source_representations: Optional[Dict] = None,
         subspaces: Optional[List] = None,
+        output_original_output: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
     ):
         """
         Main forward function that serves a wrapper to
@@ -1274,11 +1322,10 @@ def forward(
         
         self._cleanup_states()
 
-        # if no source inputs, we are calling a simple forward
+        # if no source input or intervention, we return base
         if sources is None and activations_sources is None \
-            and unit_locations is None:
+            and unit_locations is None and len(self.interventions) == 0:
             return self.model(**base), None
-        
         # broadcast
         unit_locations = self._broadcast_unit_locations(get_batch_size(base), unit_locations)
         sources = [None]*len(self._intervention_group) if sources is None else sources
@@ -1294,9 +1341,8 @@ def forward(
             subspaces,
         )
 
-        # returning un-intervened output without gradients
-        with torch.inference_mode():
-            base_outputs = self.model(**base)
+        # returning un-intervened output with gradients
+        base_outputs = self.model(**base)
 
         try:
             # intervene
@@ -1344,8 +1390,22 @@ def forward(
             )
         
         if self.return_collect_activations:
+            if return_dict:
+                return IntervenableModelOutput(
+                    original_outputs=base_outputs,
+                    intervened_outputs=counterfactual_outputs,
+                    collected_activations=collected_activations
+                )
+            
             return (base_outputs, collected_activations), counterfactual_outputs
         
+        if return_dict:
+            return IntervenableModelOutput(
+                original_outputs=base_outputs,
+                intervened_outputs=counterfactual_outputs,
+                collected_activations=None
+            )
+
         return base_outputs, counterfactual_outputs
 
     def generate(
@@ -1451,7 +1511,6 @@ def generate(
                         CollectIntervention
                     ):
                         collected_activations += self.activations[key]
-            
         except Exception as e:
             raise e
         finally:
diff --git a/pyvene/models/intervenable_modelcard.py b/pyvene/models/intervenable_modelcard.py
index 64cb84b4..7b7b2829 100644
--- a/pyvene/models/intervenable_modelcard.py
+++ b/pyvene/models/intervenable_modelcard.py
@@ -6,6 +6,7 @@
 from .mlp.modelings_intervenable_mlp import *
 from .gru.modelings_intervenable_gru import *
 from .blip.modelings_intervenable_blip import *
+from .blip.modelings_intervenable_blip_itm import *
 from .backpack_gpt2.modelings_intervenable_backpack_gpt2 import *
 
 
@@ -20,6 +21,7 @@
 
 import transformers.models as hf_models
 from .blip.modelings_blip import BlipWrapper
+from .blip.modelings_blip_itm import BlipITMWrapper
 from .mlp.modelings_mlp import MLPModel, MLPForClassification
 from .gru.modelings_gru import GRUModel, GRULMHeadModel, GRUForClassification
 from .backpack_gpt2.modelings_backpack_gpt2 import BackpackGPT2LMHeadModel
@@ -40,7 +42,9 @@
     hf_models.gpt_neox.modeling_gpt_neox.GPTNeoXModel: gpt_neox_type_to_module_mapping,
     hf_models.gpt_neox.modeling_gpt_neox.GPTNeoXForCausalLM: gpt_neox_lm_type_to_module_mapping,
     hf_models.blip.modeling_blip.BlipForQuestionAnswering: blip_type_to_module_mapping,
+    hf_models.blip.modeling_blip.BlipForImageTextRetrieval: blip_itm_type_to_module_mapping,
     BlipWrapper: blip_wrapper_type_to_module_mapping,
+    BlipITMWrapper: blip_itm_wrapper_type_to_module_mapping,
     MLPModel: mlp_type_to_module_mapping,
     MLPForClassification: mlp_classifier_type_to_module_mapping,
     GRUModel: gru_type_to_module_mapping,
@@ -61,7 +65,9 @@
     hf_models.gpt_neox.modeling_gpt_neox.GPTNeoXModel: gpt_neox_type_to_dimension_mapping,
     hf_models.gpt_neox.modeling_gpt_neox.GPTNeoXForCausalLM: gpt_neox_lm_type_to_dimension_mapping,
     hf_models.blip.modeling_blip.BlipForQuestionAnswering: blip_type_to_dimension_mapping,
+    hf_models.blip.modeling_blip.BlipForImageTextRetrieval: blip_itm_type_to_dimension_mapping,
     BlipWrapper: blip_wrapper_type_to_dimension_mapping,
+    BlipITMWrapper: blip_itm_wrapper_type_to_dimension_mapping,
     MLPModel: mlp_type_to_dimension_mapping,
     MLPForClassification: mlp_classifier_type_to_dimension_mapping,
     GRUModel: gru_type_to_dimension_mapping,
diff --git a/pyvene/models/interventions.py b/pyvene/models/interventions.py
index 038ed638..5ed0f76b 100644
--- a/pyvene/models/interventions.py
+++ b/pyvene/models/interventions.py
@@ -407,7 +407,7 @@ def __init__(self, **kwargs):
         self.mask = torch.nn.Parameter(
             torch.zeros(self.embed_dim), requires_grad=True)
         
-        self.temperature = torch.nn.Parameter(torch.tensor(50.0))
+        self.temperature = torch.nn.Parameter(torch.tensor(0.01))
 
     def get_temperature(self):
         return self.temperature
diff --git a/pyvene/models/mlp/modelings_mlp.py b/pyvene/models/mlp/modelings_mlp.py
index d32c706c..9826d562 100644
--- a/pyvene/models/mlp/modelings_mlp.py
+++ b/pyvene/models/mlp/modelings_mlp.py
@@ -7,7 +7,7 @@
 from transformers.activations import ACT2FN
 from transformers.utils import ModelOutput
 from transformers.modeling_outputs import SequenceClassifierOutput
-
+from dataclasses import dataclass
 
 class MLPConfig(PretrainedConfig):
     model_type = "mlp"
@@ -40,7 +40,7 @@ def __init__(
         self.squeeze_output = squeeze_output
         super().__init__(**kwargs)
 
-
+@dataclass
 class MLPModelOutput(ModelOutput):
     last_hidden_state: torch.FloatTensor = None
     hidden_states: Optional[Tuple[torch.FloatTensor]] = None
diff --git a/pyvene/models/modeling_utils.py b/pyvene/models/modeling_utils.py
index c9ef2de5..3edd6ff6 100644
--- a/pyvene/models/modeling_utils.py
+++ b/pyvene/models/modeling_utils.py
@@ -1,4 +1,4 @@
-import random, torch
+import random, torch, types
 import numpy as np
 from torch import nn
 from .intervenable_modelcard import *
@@ -102,7 +102,9 @@ def get_dimension_by_component(model_type, model_config, component) -> int:
 
     dimension_proposals = type_to_dimension_mapping[model_type][component]
     for proposal in dimension_proposals:
-        if "*" in proposal:
+        if proposal.isnumeric():
+            dimension = int(proposal)
+        elif "*" in proposal:
             # often constant multiplier with MLP
             dimension = getattr_for_torch_module(
                 model_config, proposal.split("*")[0]
@@ -130,6 +132,7 @@ def get_dimension_by_component(model_type, model_config, component) -> int:
 def get_module_hook(model, representation) -> nn.Module:
     """Render the intervening module with a hook."""
     if (
+        get_internal_model_type(model) in type_to_module_mapping and
         representation.component
         in type_to_module_mapping[get_internal_model_type(model)]
     ):
@@ -419,6 +422,12 @@ def do_intervention(
 ):
     """Do the actual intervention."""
 
+    if isinstance(intervention, types.FunctionType):
+        if subspaces is None:
+            return intervention(base_representation, source_representation)
+        else:
+            return intervention(base_representation, source_representation, subspaces)
+
     num_unit = base_representation.shape[1]
 
     # flatten
@@ -439,7 +448,7 @@ def do_intervention(
         source_representation_f = bhsd_to_bs_hd(source_representation)
     else:
         assert False  # what's going on?
-
+    
     intervened_representation = intervention(
         base_representation_f, source_representation_f, subspaces
     )
diff --git a/pyvene_101.ipynb b/pyvene_101.ipynb
index 25e7658c..5ac97c7c 100644
--- a/pyvene_101.ipynb
+++ b/pyvene_101.ipynb
@@ -19,13 +19,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 10,
    "id": "d123a2ba",
    "metadata": {},
    "outputs": [],
    "source": [
     "__author__ = \"Zhengxuan Wu\"\n",
-    "__version__ = \"01/20/2024\""
+    "__version__ = \"02/01/2024\""
    ]
   },
   {
@@ -37,8 +37,10 @@
     "1. [Set-up](#Set-up)     \n",
     "1. [pyvene 101](#pyvene-101) \n",
     "    1. [Get Attention Weights](#Get-Attention-Weights)\n",
-    "        1. [Get Attention Weights with String Access](#Get-Attention-Weights-with-Direct-Access-String)\n",
+    "        1. [with String Access](#Get-Attention-Weights-with-Direct-Access-String)\n",
+    "        1. [with 1-Line Function](#Get-Attention-Weights-with-a-Function)\n",
     "    1. [Set Activations to Zeros](#Set-Activation-to-Zeros) \n",
+    "        1. [with Lambda Expression](#Set-Activation-to-Zeros-with-a-Lambda-Expression)\n",
     "    1. [Set Activations with Subspaces](#Set-Activations-to-Zeros-with-Subspaces)\n",
     "    1. [Interchange Intervention](#Interchange-Interventions)\n",
     "    1. [Intervention Config](#Intervention-Configuration)\n",
@@ -69,6 +71,8 @@
     "    1. [Inference-time Intervention](#Inference-time-Intervention)\n",
     "    1. [IntervenableModel from HuggingFace Directly](#IntervenableModel-from-HuggingFace-Directly)\n",
     "    1. [Path Patching with DAS](#Path-Patching-with-Trainable-Interventions)\n",
+    "    1. [Intervene ResNet with Lambda Functors](#Intervene-on-ResNet-with-Lambda-Functions)\n",
+    "    1. [Intervene ResNet with 1-line DAS Lambda](#Intervene-on-ResNet-with-Trainable-Lambda-Functions)\n",
     "1. [The End](#The-End)\n",
     "    "
    ]
@@ -108,7 +112,8 @@
     "- **Source** example or representations: this is the source of our intervention. We use **Source** to intervene on **Base**.\n",
     "- **component**: this is the `nn.module` we are intervening in a pytorch-based NN. For models supported by this library, you can use directly access via str, or use the abstract names defined in the config file (e.g., `h[0].mlp.output` or `mlp_output` with other fields). \n",
     "- **unit**: this is the axis of our intervention. If we say our **unit** is `pos` (`position`), then you are intervening on each token position.\n",
-    "- **unit_locations**: this list gives you the percisely location of your intervention. It is the locations of the unit of analysis you are specifying. For instance, if your `unit` is `pos`, and your `unit_location` is 3, then it means you are intervening on the third token."
+    "- **unit_locations**: this list gives you the percisely location of your intervention. It is the locations of the unit of analysis you are specifying. For instance, if your `unit` is `pos`, and your `unit_location` is 3, then it means you are intervening on the third token. If this field is left as `None`, then no selection will be taken, i.e., you can think of you are getting the raw tensor and you can do whatever you want.\n",
+    "- **intervention_type** or **intervention**: this field specifies the intervention you can perform. It can be a primitive type, or it can be a function or a lambda expression for simple interventions. One benefit of using primitives is speed and systematic training schemes. You can also save and load interventions if you use the supported primitives."
    ]
   },
   {
@@ -121,7 +126,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 13,
    "id": "17c7f2f6-b0d3-4fe2-8e4f-c044b93f3ef0",
    "metadata": {},
    "outputs": [
@@ -146,7 +151,7 @@
     "base = \"When John and Mary went to the shops, Mary gave the bag to\"\n",
     "collected_attn_w = pv_gpt2(\n",
     "    base = tokenizer(base, return_tensors=\"pt\"\n",
-    "    ), unit_locations={\"base\": ([[[h for h in range(12)]]])}\n",
+    "    ), unit_locations={\"base\": [h for h in range(12)]}\n",
     ")[0][-1][0]"
    ]
   },
@@ -160,7 +165,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 15,
    "id": "1ef4a1db-5187-4457-9878-f1dc03e9859b",
    "metadata": {},
    "outputs": [
@@ -193,7 +198,7 @@
        ")"
       ]
      },
-     "execution_count": 35,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -204,7 +209,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 19,
    "id": "128be2dd-f089-4291-bfc5-7002d031b1e9",
    "metadata": {},
    "outputs": [
@@ -230,10 +235,50 @@
     "base = \"When John and Mary went to the shops, Mary gave the bag to\"\n",
     "collected_attn_w = pv_gpt2(\n",
     "    base = tokenizer(base, return_tensors=\"pt\"\n",
-    "    ), unit_locations={\"base\": ([[[h for h in range(12)]]])}\n",
+    "    ), unit_locations={\"base\": [h for h in range(12)]}\n",
     ")[0][-1][0]"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "22643b2d",
+   "metadata": {},
+   "source": [
+    "#### Get Attention Weights with a Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "678dc46f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loaded model\n"
+     ]
+    }
+   ],
+   "source": [
+    "import copy\n",
+    "import pyvene as pv\n",
+    "\n",
+    "_, tokenizer, gpt2 = pv.create_gpt2()\n",
+    "\n",
+    "cached_w = {}\n",
+    "def pv_patcher(b, s): cached_w[\"attn_w\"] = copy.deepcopy(b.data)\n",
+    "\n",
+    "pv_gpt2 = pv.IntervenableModel({\n",
+    "    \"component\": \"h[10].attn.attn_dropout.input\", \n",
+    "    \"intervention\": pv_patcher}, model=gpt2)\n",
+    "\n",
+    "base = \"When John and Mary went to the shops, Mary gave the bag to\"\n",
+    "_ = pv_gpt2(tokenizer(base, return_tensors=\"pt\"))\n",
+    "torch.allclose(collected_attn_w, cached_w[\"attn_w\"].unsqueeze(dim=0))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "12c5addb-4bd7-4129-b350-0677774f5790",
@@ -244,7 +289,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "a82664f9",
    "metadata": {},
    "outputs": [
@@ -275,6 +320,121 @@
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "b9c11cb9",
+   "metadata": {},
+   "source": [
+    "#### Set Activation to Zeros with a Lambda Expression"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7627dc32",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loaded model\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import pyvene as pv\n",
+    "\n",
+    "_, tokenizer, gpt2 = pv.create_gpt2()\n",
+    "\n",
+    "# indices are specified in the intervention\n",
+    "mask = torch.ones(1, 5, 768)\n",
+    "mask[:,3,:] = 0.\n",
+    "# define the component to zero-out\n",
+    "pv_gpt2 = pv.IntervenableModel({\n",
+    "    \"component\": \"h[0].mlp.output\", \"intervention\": lambda b, s: b*mask\n",
+    "}, model=gpt2)\n",
+    "# run the intervened forward pass\n",
+    "intervened_outputs_fn = pv_gpt2(\n",
+    "    base = tokenizer(\"The capital of Spain is\", return_tensors=\"pt\")\n",
+    ")\n",
+    "torch.allclose(\n",
+    "    intervened_outputs[1].last_hidden_state, \n",
+    "    intervened_outputs_fn[1].last_hidden_state\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72363777",
+   "metadata": {},
+   "source": [
+    "#### Set Activation to Zeros with a Lambda Expression and Subspace notation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d86c06f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loaded model\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import pyvene as pv\n",
+    "\n",
+    "_, tokenizer, gpt2 = pv.create_gpt2()\n",
+    "\n",
+    "# indices are specified in the intervention\n",
+    "\n",
+    "def pv_patcher(b, s, sp): \n",
+    "    mask = torch.ones(1, 5, 768)\n",
+    "    mask[:,sp[0][0],:] = 0.\n",
+    "    return b*mask\n",
+    "\n",
+    "# define the component to zero-out\n",
+    "pv_gpt2 = pv.IntervenableModel({\n",
+    "    \"component\": \"h[0].mlp.output\", \"intervention\": pv_patcher\n",
+    "}, model=gpt2)\n",
+    "# run the intervened forward pass\n",
+    "intervened_outputs_fn = pv_gpt2(\n",
+    "    base = tokenizer(\"The capital of Spain is\", return_tensors=\"pt\"),\n",
+    "    subspaces=3,\n",
+    ")\n",
+    "torch.allclose(\n",
+    "    intervened_outputs[1].last_hidden_state, \n",
+    "    intervened_outputs_fn[1].last_hidden_state\n",
+    ")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "39071858",
@@ -907,7 +1067,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 8,
    "id": "f718e2d6",
    "metadata": {},
    "outputs": [
@@ -915,8 +1075,6 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/sailhome/wuzhengx/.local/lib/python3.8/site-packages/torch/_utils.py:831: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly.  To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n",
-      "  return self.fget.__get__(instance, owner)()\n",
       "The attention mask and the pad token id were not set. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n",
       "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n"
      ]
@@ -990,6 +1148,93 @@
     "))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "e628990d",
+   "metadata": {},
+   "source": [
+    "intervene on generation with source example passed in. The result will be slightly different since we no longer have a static vector to be added in; it is layerwise addition."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "087541f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The attention mask and the pad token id were not set. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n",
+      "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loaded model\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The attention mask and the pad token id were not set. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n",
+      "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Once upon a time there was a little girl named Lucy. She was very excited because she was going to the park. She wanted to go to the park and play.\n",
+      "\n",
+      "When she got to the park, she saw a big slide. She was so excited! She ran to the slide and started to climb up. She was so happy.\n",
+      "\n",
+      "But then she saw something else. It was a big, scary dog. It was a big, mean dog. He was barking and growling at her. Lucy was scared. She didn't know what to do.\n",
+      "\n",
+      "Suddenly, she heard a voice. It was her mommy. She said, \"Don't worry, Lucy. I will help you. I will protect you.\"\n",
+      "\n",
+      "Lucy was so happy. She hugged her mommy and they went to the park. They played together and had lots of fun. Lucy was so happy. She was no longer scared.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import pyvene as pv\n",
+    "\n",
+    "# built-in helper to get tinystore\n",
+    "_, tokenizer, tinystory = pv.create_gpt_neo()\n",
+    "\n",
+    "def pv_patcher(b, s): return b + s*0.1\n",
+    "\n",
+    "pv_tinystory = pv.IntervenableModel([{\n",
+    "    \"layer\": l,\n",
+    "    \"component\": \"mlp_output\",\n",
+    "    \"intervention\": pv_patcher\n",
+    "    } for l in range(tinystory.config.num_layers)],\n",
+    "    model=tinystory\n",
+    ")\n",
+    "# prompt and generate\n",
+    "prompt = tokenizer(\n",
+    "    \"Once upon a time there was\", return_tensors=\"pt\")\n",
+    "happy_prompt = tokenizer(\n",
+    "    \" Happy\", return_tensors=\"pt\")\n",
+    "_, intervened_story = pv_tinystory.generate(\n",
+    "    prompt, happy_prompt, \n",
+    "    unit_locations = {\"sources->base\": 0},\n",
+    "    max_length=256\n",
+    ")\n",
+    "\n",
+    "print(tokenizer.decode(\n",
+    "    intervened_story[0], \n",
+    "    skip_special_tokens=True\n",
+    "))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "26d25dc6",
@@ -1946,7 +2191,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 9,
    "id": "559bf80a-2a79-46f0-b8a1-8848fd49613b",
    "metadata": {},
    "outputs": [
@@ -1960,7 +2205,7 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "7bc8a51db70643f59c53fe9e7bd22bc0",
+       "model_id": "09c7100d49c94e1b94f3429440f1aab3",
        "version_major": 2,
        "version_minor": 0
       },
@@ -2268,6 +2513,125 @@
     "counterfactual_outputs[0].sum().backward()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "0907a98c",
+   "metadata": {},
+   "source": [
+    "### Intervene on ResNet with Lambda Functions\n",
+    "\n",
+    "Huggingface Vision model comes with the support of ResNet. Here, we show how we can use pyvene to intervene on a patch of pixels, like token in transformer, which is like a primitive object in ResNet or ConvNet based NNs.\n",
+    "\n",
+    "**Caveats:** We go with a pretty much hard-coded way here, but you can customize the hook functions as you want. It does not have to be a lambda function as well."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "bfb48112",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor(0.0005)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import pyvene as pv\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoFeatureExtractor, AutoModelForImageClassification\n",
+    "\n",
+    "feature_extractor = AutoFeatureExtractor.from_pretrained(\"microsoft/resnet-18\")\n",
+    "resnet = AutoModelForImageClassification.from_pretrained(\"microsoft/resnet-18\")\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\")\n",
+    "base_image = dataset[\"test\"][\"image\"][0]\n",
+    "source_image = dataset[\"test\"][\"image\"][0]\n",
+    "base_inputs = feature_extractor(base_image, return_tensors=\"pt\")\n",
+    "source_inputs = feature_extractor(source_image, return_tensors=\"pt\")\n",
+    "source_inputs['pixel_values'] += 0.5*torch.randn(source_inputs['pixel_values'].shape)\n",
+    "\n",
+    "def create_mask():\n",
+    "    _mask = torch.zeros((56, 56))\n",
+    "    _mask[56//2:, 56//2:] = 1\n",
+    "    return _mask\n",
+    "m = create_mask()\n",
+    "\n",
+    "pv_resnet = pv.IntervenableModel({\n",
+    "    \"component\": \"resnet.embedder.pooler.output\", \n",
+    "    \"intervention\": lambda b, s: b * (1. - m) + s * m}, \n",
+    "    model=resnet\n",
+    ")\n",
+    "intervened_outputs = pv_resnet(\n",
+    "    base_inputs, [source_inputs], return_dict=True\n",
+    ")\n",
+    "(intervened_outputs.intervened_outputs.logits - intervened_outputs.original_outputs.logits).sum()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b4d0aa78",
+   "metadata": {},
+   "source": [
+    "### Intervene on ResNet with Trainable Lambda Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6d0095f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor(0.0068, grad_fn=<SumBackward0>)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import pyvene as pv\n",
+    "from datasets import load_dataset\n",
+    "from transformers import AutoFeatureExtractor, AutoModelForImageClassification\n",
+    "\n",
+    "feature_extractor = AutoFeatureExtractor.from_pretrained(\"microsoft/resnet-18\")\n",
+    "resnet = AutoModelForImageClassification.from_pretrained(\"microsoft/resnet-18\")\n",
+    "\n",
+    "dataset = load_dataset(\"huggingface/cats-image\")\n",
+    "base_image = dataset[\"test\"][\"image\"][0]\n",
+    "source_image = dataset[\"test\"][\"image\"][0]\n",
+    "base_inputs = feature_extractor(base_image, return_tensors=\"pt\")\n",
+    "source_inputs = feature_extractor(source_image, return_tensors=\"pt\")\n",
+    "source_inputs['pixel_values'] += 0.5*torch.randn(source_inputs['pixel_values'].shape)\n",
+    "\n",
+    "# trainable DAS directions\n",
+    "v = torch.nn.utils.parametrizations.orthogonal(\n",
+    "    torch.nn.Linear(56, 10))\n",
+    "\n",
+    "pv_resnet = pv.IntervenableModel({\n",
+    "    \"component\": \"resnet.embedder.pooler.output\", \n",
+    "    \"intervention\": lambda b, s: b + ((s @ v.weight.T - b @ v.weight.T) @ v.weight)}, \n",
+    "    model=resnet\n",
+    ")\n",
+    "\n",
+    "intervened_outputs = pv_resnet(\n",
+    "    base_inputs, [source_inputs], return_dict=True\n",
+    ")\n",
+    "(intervened_outputs.intervened_outputs.logits - intervened_outputs.original_outputs.logits).sum()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "bc6eb49d",
diff --git a/setup.py b/setup.py
index cbcd3930..07692470 100644
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,7 @@
 
 setup(
     name="pyvene",
-    version="0.0.7",
+    version="0.0.8dev",
     description="Use Activation Intervention to Interpret Causal Mechanism of Model",
     long_description=long_description,
     long_description_content_type='text/markdown',
diff --git a/tutorials/advanced_tutorials/Voting_Mechanism.ipynb b/tutorials/advanced_tutorials/Voting_Mechanism.ipynb
new file mode 100644
index 00000000..4b75f5db
--- /dev/null
+++ b/tutorials/advanced_tutorials/Voting_Mechanism.ipynb
@@ -0,0 +1,1557 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a35493d6",
+   "metadata": {},
+   "source": [
+    "## An exploration on Voting Mechanism and Intervention"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "aab5efc5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "__author__ = \"Zhengxuan Wu and Kevin Du and Tiago Pimentel\"\n",
+    "__version__ = \"02/13/2023\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6633e9fa",
+   "metadata": {},
+   "source": [
+    "### Overview\n",
+    "\n",
+    "Through our offline discussions, we found a strange behavior in the Boundless DAS paper: there are multiple \"good\" aligning representations for a single causal variable. If these aligning representations take on different values, how will the NN behave? Will it trust more on certain location?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b39c8f0",
+   "metadata": {},
+   "source": [
+    "### Set-up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 157,
+   "id": "f5ff4f76",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:\n",
+    "    # This library is our indicator that the required installs\n",
+    "    # need to be done.\n",
+    "    import pyvene\n",
+    "\n",
+    "except ModuleNotFoundError:\n",
+    "    !pip install git+https://github.com/stanfordnlp/pyvene.git"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "850bf6fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import seaborn as sns\n",
+    "from tqdm import tqdm, trange\n",
+    "from datasets import Dataset\n",
+    "from torch.utils.data import DataLoader\n",
+    "from transformers import get_linear_schedule_with_warmup\n",
+    "from torch.nn import CrossEntropyLoss\n",
+    "from tutorial_price_tagging_utils import *\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "from plotnine import ggplot, aes, geom_boxplot, geom_point, geom_errorbar, labs, theme\n",
+    "\n",
+    "import pyvene as pv\n",
+    "from pyvene import create_llama\n",
+    "from pyvene import set_seed, count_parameters\n",
+    "\n",
+    "# You can define your custom compute_metrics function.\n",
+    "def compute_metrics(eval_preds, eval_labels):\n",
+    "    total_count = 0\n",
+    "    correct_count = 0\n",
+    "    for eval_pred, eval_label in zip(eval_preds, eval_labels):\n",
+    "        actual_test_labels = eval_label[:, -1]\n",
+    "        pred_test_labels = torch.argmax(eval_pred[:, -1], dim=-1)\n",
+    "        correct_labels = actual_test_labels == pred_test_labels\n",
+    "        total_count += len(correct_labels)\n",
+    "        correct_count += correct_labels.sum().tolist()\n",
+    "    accuracy = round(correct_count / total_count, 2)\n",
+    "    return {\"accuracy\": accuracy}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "75d4d2e5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "You are using the default legacy behaviour of the <class 'transformers.models.llama.tokenization_llama.LlamaTokenizer'>. This is expected, and simply means that the `legacy` (previous) behavior will be used so nothing changes for you. If you want to use the new behaviour, set `legacy=False`. This should only be set if you understand what it means, and thoroughly read the reason why this was added as explained in https://github.com/huggingface/transformers/pull/24565\n",
+      "normalizer.cc(51) LOG(INFO) precompiled_charsmap is empty. use identity normalization.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5e43d3570ec941adb21f8203bbf61b4f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Loading checkpoint shards:   0%|          | 0/34 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/sailhome/wuzhengx/.local/lib/python3.8/site-packages/torch/_utils.py:831: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly.  To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loaded model\n"
+     ]
+    }
+   ],
+   "source": [
+    "config, tokenizer, llama = create_llama()\n",
+    "_ = llama.to(\"cuda\")\n",
+    "_ = llama.eval()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1499039a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "raw_prealign = factual_sampler(tokenizer, 5000, game=\"pricing_tag\")\n",
+    "prealign_dataset = Dataset.from_dict(\n",
+    "    {\"input_ids\": raw_prealign[0], \"labels\": raw_prealign[1]}\n",
+    ")\n",
+    "prealign_dataset.set_format(\"torch\", columns=[\"input_ids\", \"labels\"])\n",
+    "prealign_dataloader = DataLoader(prealign_dataset, batch_size=8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f13b8ed9",
+   "metadata": {},
+   "source": [
+    "#### Display some training task instances"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "fac2e331",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'
Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.\\n\\n### Instruction:\\nPlease say yes only if it costs between 1.60 and 4.11 dollars, otherwise no.\\n\\n### Input:\\n0.32 dollars\\n\\n### Response:\\n'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tokenizer.decode(raw_prealign[0][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c599652d",
+   "metadata": {},
+   "source": [
+    "#### creating alignment datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "18d62623",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "set_seed(42)\n",
+    "\n",
+    "###################\n",
+    "# data loaders\n",
+    "###################\n",
+    "raw_data = bound_alignment_sampler(\n",
+    "    tokenizer, 10000, [lower_bound_alignment_example_sampler]\n",
+    ")\n",
+    "\n",
+    "raw_train = (\n",
+    "    raw_data[0][:8000],\n",
+    "    raw_data[1][:8000],\n",
+    "    raw_data[2][:8000],\n",
+    "    raw_data[3][:8000],\n",
+    ")\n",
+    "raw_eval = (\n",
+    "    raw_data[0][8000:9000],\n",
+    "    raw_data[1][8000:9000],\n",
+    "    raw_data[2][8000:9000],\n",
+    "    raw_data[3][8000:9000],\n",
+    ")\n",
+    "raw_test = (\n",
+    "    raw_data[0][9000:],\n",
+    "    raw_data[1][9000:],\n",
+    "    raw_data[2][9000:],\n",
+    "    raw_data[3][9000:],\n",
+    ")\n",
+    "train_dataset = Dataset.from_dict(\n",
+    "    {\n",
+    "        \"input_ids\": raw_train[0],\n",
+    "        \"source_input_ids\": raw_train[1],\n",
+    "        \"labels\": raw_train[2],\n",
+    "        \"intervention_ids\": raw_train[3],  # we will not use this field\n",
+    "    }\n",
+    ").with_format(\"torch\")\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset,\n",
+    "    batch_size=16,\n",
+    ")\n",
+    "eval_dataset = Dataset.from_dict(\n",
+    "    {\n",
+    "        \"input_ids\": raw_eval[0],\n",
+    "        \"source_input_ids\": raw_eval[1],\n",
+    "        \"labels\": raw_eval[2],\n",
+    "        \"intervention_ids\": raw_eval[3],  # we will not use this field\n",
+    "    }\n",
+    ").with_format(\"torch\")\n",
+    "eval_dataloader = DataLoader(\n",
+    "    eval_dataset,\n",
+    "    batch_size=16,\n",
+    ")\n",
+    "test_dataset = Dataset.from_dict(\n",
+    "    {\n",
+    "        \"input_ids\": raw_test[0],\n",
+    "        \"source_input_ids\": raw_test[1],\n",
+    "        \"labels\": raw_test[2],\n",
+    "        \"intervention_ids\": raw_test[3],  # we will not use this field\n",
+    "    }\n",
+    ").with_format(\"torch\")\n",
+    "test_dataloader = DataLoader(\n",
+    "    test_dataset,\n",
+    "    batch_size=16,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff11ff48",
+   "metadata": {},
+   "source": [
+    "#### where are we aligning in LLaMA?\n",
+    "\n",
+    "you need to run this multiple times, and save different interventions into your disk."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "id": "07976f76",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "layer = 15\n",
+    "token_position = 78"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "471a4c00",
+   "metadata": {},
+   "source": [
+    "set-up training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 139,
+   "id": "99dd2bb5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pv_config = pv.IntervenableConfig(\n",
+    "    representations=[\n",
+    "        pv.RepresentationConfig(\n",
+    "            layer, \"block_output\"\n",
+    "        )],\n",
+    "    intervention_types=pv.BoundlessRotatedSpaceIntervention,\n",
+    ")\n",
+    "pv_llama = pv.IntervenableModel(pv_config, llama)\n",
+    "pv_llama.set_device(\"cuda\")\n",
+    "pv_llama.disable_model_gradients()\n",
+    "\n",
+    "epochs = 1\n",
+    "gradient_accumulation_steps = 4\n",
+    "total_step = 0\n",
+    "t_total = int(len(train_dataloader) * epochs)\n",
+    "temperature_start = 50.0\n",
+    "temperature_end = 0.1\n",
+    "temperature_schedule = (\n",
+    "    torch.linspace(\n",
+    "        temperature_start, temperature_end, t_total\n",
+    "    )\n",
+    "    .to(torch.bfloat16)\n",
+    "    .to(\"cuda\")\n",
+    ")\n",
+    "pv_llama.set_temperature(temperature_schedule[total_step])\n",
+    "\n",
+    "warm_up_steps = 0.1 * t_total\n",
+    "optimizer_params = []\n",
+    "for k, v in pv_llama.interventions.items():\n",
+    "    optimizer_params += [\n",
+    "        {\"params\": v[0].rotate_layer.parameters()}]\n",
+    "    optimizer_params += [\n",
+    "        {\"params\": v[0].intervention_boundaries, \"lr\": 1e-2}]\n",
+    "optimizer = torch.optim.Adam(optimizer_params, lr=1e-3)\n",
+    "scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer, num_warmup_steps=warm_up_steps,\n",
+    "    num_training_steps=t_total\n",
+    ")\n",
+    "\n",
+    "def calculate_loss(logits, labels):\n",
+    "    shift_logits = logits[..., :, :].contiguous()\n",
+    "    shift_labels = labels[..., :].contiguous()\n",
+    "    # Flatten the tokens\n",
+    "    loss_fct = CrossEntropyLoss()\n",
+    "    shift_logits = shift_logits.view(-1, config.vocab_size)\n",
+    "    shift_labels = shift_labels.view(-1)\n",
+    "    # Enable model parallelism\n",
+    "    shift_labels = shift_labels.to(shift_logits.device)\n",
+    "    loss = loss_fct(shift_logits, shift_labels)\n",
+    "\n",
+    "    for k, v in pv_llama.interventions.items():\n",
+    "        boundary_loss = 1.0 * v[0].intervention_boundaries.sum()\n",
+    "    loss += boundary_loss\n",
+    "\n",
+    "    return loss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 140,
+   "id": "c8c31a14",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "llama trainable parameters:  0\n",
+      "intervention trainable parameters:  16777218\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [13:24<00:00,  1.61s/it, loss=0.12, acc=0.75]\n",
+      "Epoch: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [13:24<00:00, 804.32s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "pv_llama.model.train()  # train enables drop-off but no grads\n",
+    "print(\"llama trainable parameters: \", count_parameters(pv_llama.model))\n",
+    "print(\"intervention trainable parameters: \", pv_llama.count_parameters())\n",
+    "train_iterator = trange(0, int(epochs), desc=\"Epoch\")\n",
+    "for epoch in train_iterator:\n",
+    "    epoch_iterator = tqdm(\n",
+    "        train_dataloader, \n",
+    "        desc=f\"Epoch: {epoch}\", position=0, leave=True\n",
+    "    )\n",
+    "    for step, inputs in enumerate(epoch_iterator):\n",
+    "        for k, v in inputs.items():\n",
+    "            if v is not None and isinstance(v, torch.Tensor):\n",
+    "                inputs[k] = v.to(\"cuda\")\n",
+    "        b_s = inputs[\"input_ids\"].shape[0]\n",
+    "        _, counterfactual_outputs = pv_llama(\n",
+    "            {\"input_ids\": inputs[\"input_ids\"]},\n",
+    "            [{\"input_ids\": inputs[\"source_input_ids\"]}],\n",
+    "            {\"sources->base\": token_position},\n",
+    "        )\n",
+    "        eval_metrics = compute_metrics(\n",
+    "            [counterfactual_outputs.logits], [inputs[\"labels\"]]\n",
+    "        )\n",
+    "\n",
+    "        # loss and backprop\n",
+    "        loss = calculate_loss(counterfactual_outputs.logits, inputs[\"labels\"])\n",
+    "        loss_str = round(loss.item(), 2)\n",
+    "        epoch_iterator.set_postfix({\"loss\": loss_str, \"acc\": eval_metrics[\"accuracy\"]})\n",
+    "\n",
+    "        if gradient_accumulation_steps > 1:\n",
+    "            loss = loss / gradient_accumulation_steps\n",
+    "        loss.backward()\n",
+    "        if total_step % gradient_accumulation_steps == 0:\n",
+    "            if not (gradient_accumulation_steps > 1 and total_step == 0):\n",
+    "                optimizer.step()\n",
+    "                scheduler.step()\n",
+    "                optimizer.zero_grad()\n",
+    "                pv_llama.set_temperature(\n",
+    "                    temperature_schedule[total_step])\n",
+    "        total_step += 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 141,
+   "id": "31915697",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 63/63 [00:45<00:00,  1.38it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.64}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# evaluation on the test set\n",
+    "eval_labels = []\n",
+    "eval_preds = []\n",
+    "with torch.no_grad():\n",
+    "    epoch_iterator = tqdm(test_dataloader, desc=f\"Test\")\n",
+    "    for step, inputs in enumerate(epoch_iterator):\n",
+    "        for k, v in inputs.items():\n",
+    "            if v is not None and isinstance(v, torch.Tensor):\n",
+    "                inputs[k] = v.to(\"cuda\")\n",
+    "        b_s = inputs[\"input_ids\"].shape[0]\n",
+    "        _, counterfactual_outputs = pv_llama(\n",
+    "            {\"input_ids\": inputs[\"input_ids\"]},\n",
+    "            [{\"input_ids\": inputs[\"source_input_ids\"]}],\n",
+    "            {\"sources->base\": 75}\n",
+    "        )\n",
+    "        eval_labels += [inputs[\"labels\"]]\n",
+    "        eval_preds += [counterfactual_outputs.logits]\n",
+    "eval_metrics = compute_metrics(eval_preds, eval_labels)\n",
+    "print(eval_metrics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 142,
+   "id": "de8abd35",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.save(\n",
+    "    pv_llama.interventions[\n",
+    "        f\"layer.{layer}.comp.block_output.unit.pos.nunit.1#0\"][0].state_dict(), \n",
+    "    f\"./tutorial_data/layer.{layer}.pos.{token_position}.bin\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1a7b22ad",
+   "metadata": {},
+   "source": [
+    "#### Loading back saved DAS params and intervene on single or multiple sites"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 143,
+   "id": "9fa49db7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 143,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "layer = 15\n",
+    "pv_config = pv.IntervenableConfig(\n",
+    "    representations=[\n",
+    "        pv.RepresentationConfig(layer, \"block_output\"), \n",
+    "        pv.RepresentationConfig(layer, \"block_output\")],\n",
+    "    intervention_types=pv.BoundlessRotatedSpaceIntervention,\n",
+    ")\n",
+    "pv_llama = pv.IntervenableModel(pv_config, llama)\n",
+    "pv_llama.set_device(\"cuda\")\n",
+    "pv_llama.disable_model_gradients()\n",
+    "pv_llama.interventions[f'layer.{layer}.comp.block_output.unit.pos.nunit.1#0'][0].load_state_dict(\n",
+    "    torch.load('./tutorial_data/layer.15.pos.75.bin'))\n",
+    "pv_llama.interventions[f'layer.{layer}.comp.block_output.unit.pos.nunit.1#1'][0].load_state_dict(\n",
+    "    torch.load('./tutorial_data/layer.15.pos.80.bin'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 144,
+   "id": "26659165",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[control ]intervening location:  78\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 63/63 [00:41<00:00,  1.51it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 200,
+       "width": 400
+      }
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "intervening location:  75\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 63/63 [00:42<00:00,  1.50it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 200,
+       "width": 400
+      }
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "intervening location:  80\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 63/63 [00:43<00:00,  1.46it/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 200,
+       "width": 400
+      }
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "intervening location:  [75, 80]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 63/63 [01:09<00:00,  1.10s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 200,
+       "width": 400
+      }
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for loc in [78, 75, 80, [75, 80]]:\n",
+    "    if loc == 78:\n",
+    "        print(\"[control] intervening location: \", loc)\n",
+    "        pv_llama.interventions[f'layer.{layer}.comp.block_output.unit.pos.nunit.1#0'][0].load_state_dict(\n",
+    "            torch.load('./tutorial_data/layer.15.pos.78.bin'))\n",
+    "    else:\n",
+    "        print(\"intervening location: \", loc)\n",
+    "        pv_llama.interventions[f'layer.{layer}.comp.block_output.unit.pos.nunit.1#0'][0].load_state_dict(\n",
+    "            torch.load('./tutorial_data/layer.15.pos.75.bin'))\n",
+    "    # evaluation on the test set\n",
+    "    collected_probs = []\n",
+    "    eval_labels = []\n",
+    "    eval_preds = []\n",
+    "    with torch.no_grad():\n",
+    "        epoch_iterator = tqdm(test_dataloader, desc=f\"Test\")\n",
+    "        for step, inputs in enumerate(epoch_iterator):\n",
+    "            for k, v in inputs.items():\n",
+    "                if v is not None and isinstance(v, torch.Tensor):\n",
+    "                    inputs[k] = v.to(\"cuda\")\n",
+    "            b_s = inputs[\"input_ids\"].shape[0]\n",
+    "            if loc == 75 or loc == 78:\n",
+    "                input_sources = [{\"input_ids\": inputs[\"source_input_ids\"]}, None]\n",
+    "            elif loc == 80:\n",
+    "                input_sources = [None, {\"input_ids\": inputs[\"source_input_ids\"]}]\n",
+    "            else:\n",
+    "                input_sources = [{\"input_ids\": inputs[\"source_input_ids\"]}]\n",
+    "            _, counterfactual_outputs = pv_llama(\n",
+    "                {\"input_ids\": inputs[\"input_ids\"]},\n",
+    "                input_sources, {\"sources->base\": loc}\n",
+    "            )\n",
+    "            correct_label = inputs[\"labels\"][:,-1]\n",
+    "            incorrect_label = \\\n",
+    "                ((correct_label == 8241)*3782 + \\\n",
+    "                (correct_label == 3782)*8241).long()\n",
+    "            norm_prob = torch.softmax(\n",
+    "                counterfactual_outputs.logits[:, -1], dim=-1)\n",
+    "            correct_prob = norm_prob[torch.arange(b_s),correct_label].detach().cpu()\n",
+    "            incorrect_prob = norm_prob[torch.arange(b_s),incorrect_label].detach().cpu()\n",
+    "            diff_prob = torch.abs(correct_prob - incorrect_prob)\n",
+    "            collected_probs += [[correct_prob, incorrect_prob, diff_prob]]\n",
+    "            eval_labels += [inputs[\"labels\"]]\n",
+    "            eval_preds += [counterfactual_outputs.logits]\n",
+    "    correct_probs = torch.cat([p[0] for p in collected_probs])\n",
+    "    incorrect_probs = torch.cat([p[1] for p in collected_probs])\n",
+    "    diff_probs = torch.cat([p[2] for p in collected_probs])\n",
+    "    eval_metrics = compute_metrics(eval_preds, eval_labels)\n",
+    "\n",
+    "    list1 = correct_probs.tolist()\n",
+    "    list2 = incorrect_probs.tolist()\n",
+    "    list3 = diff_probs.tolist()\n",
+    "    acc = eval_metrics['accuracy']\n",
+    "    df = pd.DataFrame({'Group': ['Correct']*len(list1) + ['Incorrect']*len(list2) + ['Abs(Diff)']*len(list2),\n",
+    "                       'Value': list1 + list2 + list3})\n",
+    "    means = df.groupby('Group')['Value'].mean().reset_index()\n",
+    "    means['ymin'] = means['Value'] - df.groupby('Group')['Value'].std().reset_index()['Value']\n",
+    "    means['ymax'] = means['Value'] + df.groupby('Group')['Value'].std().reset_index()['Value']\n",
+    "    plot = (ggplot(df, aes('Group', 'Value')) +\n",
+    "            geom_boxplot(fill='lightgray', alpha=0.5) +\n",
+    "            geom_point(means, aes('Group', 'Value'), color='blue', size=3) +\n",
+    "            geom_errorbar(means, aes('Group', ymin='ymin', ymax='ymax'), width=0.2) +\n",
+    "            labs(title=f'w/ Acc={acc}', x='Group', y='Prob (Softmax)') +\n",
+    "            theme(figure_size=(4, 2)))\n",
+    "    print(plot)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73312a7b",
+   "metadata": {},
+   "source": [
+    "#### Now, what if we set two aligning intervention sites with contradicting values?\n",
+    "\n",
+    "We need to write new data generator since we know want two source examples and these two examples have to result in contrasting behaviors."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 145,
+   "id": "df4bacaf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def lower_bound_alignment_example_sampler_multisource_non_contradict(\n",
+    "    tokenizer, amount=None, lower_bound=None, bound_width=None\n",
+    "):\n",
+    "    (\n",
+    "        base_lower_bound_sample,\n",
+    "        base_upper_bound_sample,\n",
+    "        _,\n",
+    "    ) = pricing_tag_game_config_sampler(amount, lower_bound, bound_width)\n",
+    "    (\n",
+    "        source_lower_bound_sample,\n",
+    "        source_upper_bound_sample,\n",
+    "        _,\n",
+    "    ) = pricing_tag_game_config_sampler(amount, lower_bound, bound_width)\n",
+    "    (\n",
+    "        source_lower_bound_sample_extra,\n",
+    "        source_upper_bound_sample_extra,\n",
+    "        _,\n",
+    "    ) = pricing_tag_game_config_sampler(amount, lower_bound, bound_width)\n",
+    "    ctf_label_str = random.choice([\"Yes\", \"No\"])\n",
+    "    if ctf_label_str == \"Yes\":\n",
+    "        ctf_label = tokenizer.convert_tokens_to_ids(\"Yes\")\n",
+    "        base_source_regions = [\n",
+    "            [1, 2],\n",
+    "            [1, 3],\n",
+    "            [2, 2],\n",
+    "            [2, 3],\n",
+    "        ]\n",
+    "    elif ctf_label_str == \"No\":\n",
+    "        ctf_label = tokenizer.convert_tokens_to_ids(\"No\")\n",
+    "        base_source_regions = [[1, 1], [2, 1], [3, 1], [3, 2], [3, 3]]\n",
+    "    base_source_region = random.choice(base_source_regions)\n",
+    "    base_region = base_source_region[0]\n",
+    "    source_region = base_source_region[1]\n",
+    "\n",
+    "    base_amount_sample = sample_with_region(\n",
+    "        base_region, base_lower_bound_sample, base_upper_bound_sample\n",
+    "    )\n",
+    "    source_amount_sample = sample_with_region(\n",
+    "        source_region, source_lower_bound_sample, source_upper_bound_sample\n",
+    "    )\n",
+    "    source_amount_sample_extra = sample_with_region(\n",
+    "        source_region, source_lower_bound_sample_extra, source_upper_bound_sample_extra\n",
+    "    )\n",
+    "    return (\n",
+    "        base_lower_bound_sample,\n",
+    "        base_upper_bound_sample,\n",
+    "        source_lower_bound_sample,\n",
+    "        source_upper_bound_sample,\n",
+    "        source_lower_bound_sample_extra, # extra bound\n",
+    "        source_upper_bound_sample_extra, # extra bound\n",
+    "        base_amount_sample,\n",
+    "        source_amount_sample,\n",
+    "        source_amount_sample_extra,      # extra amount\n",
+    "        ctf_label,\n",
+    "        ctf_label_str,\n",
+    "        ctf_label,     # extra label\n",
+    "        ctf_label_str, # extra label\n",
+    "    )\n",
+    "\n",
+    "def lower_bound_alignment_example_sampler_multisource_contradict(\n",
+    "    tokenizer, amount=None, lower_bound=None, bound_width=None\n",
+    "):\n",
+    "    (\n",
+    "        base_lower_bound_sample,\n",
+    "        base_upper_bound_sample,\n",
+    "        _,\n",
+    "    ) = pricing_tag_game_config_sampler(amount, lower_bound, bound_width)\n",
+    "    (\n",
+    "        source_lower_bound_sample,\n",
+    "        source_upper_bound_sample,\n",
+    "        _,\n",
+    "    ) = pricing_tag_game_config_sampler(amount, lower_bound, bound_width)\n",
+    "    (\n",
+    "        source_lower_bound_sample_extra,\n",
+    "        source_upper_bound_sample_extra,\n",
+    "        _,\n",
+    "    ) = pricing_tag_game_config_sampler(amount, lower_bound, bound_width)\n",
+    "    ctf_label_str = random.choice([\"Yes\", \"No\"])\n",
+    "    if ctf_label_str == \"Yes\":\n",
+    "        ctf_label = tokenizer.convert_tokens_to_ids(\"Yes\")\n",
+    "        base_source_regions = [\n",
+    "            [1, 2],\n",
+    "            [1, 3],\n",
+    "            [2, 2],\n",
+    "            [2, 3],\n",
+    "        ]\n",
+    "        \n",
+    "    elif ctf_label_str == \"No\":\n",
+    "        ctf_label = tokenizer.convert_tokens_to_ids(\"No\")\n",
+    "        base_source_regions = [[1, 1], [2, 1]]\n",
+    "        \n",
+    "    base_source_region = random.choice(base_source_regions)\n",
+    "    base_region = base_source_region[0]\n",
+    "    source_region = base_source_region[1]\n",
+    "    if ctf_label_str == \"Yes\":\n",
+    "        source_extra_region = 1 # flip the left label\n",
+    "        ctf_label_extra = tokenizer.convert_tokens_to_ids(\"No\")\n",
+    "        ctf_label_str_extra = \"No\"\n",
+    "    elif ctf_label_str == \"No\":\n",
+    "        source_extra_region = random.choice([2,3]) # flip the left label\n",
+    "        ctf_label_extra = tokenizer.convert_tokens_to_ids(\"Yes\")\n",
+    "        ctf_label_str_extra = \"Yes\"\n",
+    "\n",
+    "    base_amount_sample = sample_with_region(\n",
+    "        base_region, base_lower_bound_sample, base_upper_bound_sample\n",
+    "    )\n",
+    "    source_amount_sample = sample_with_region(\n",
+    "        source_region, source_lower_bound_sample, source_upper_bound_sample\n",
+    "    )\n",
+    "    source_amount_sample_extra = sample_with_region(\n",
+    "        source_region, source_lower_bound_sample_extra, source_upper_bound_sample_extra\n",
+    "    )\n",
+    "    return (\n",
+    "        base_lower_bound_sample,\n",
+    "        base_upper_bound_sample,\n",
+    "        source_lower_bound_sample,\n",
+    "        source_upper_bound_sample,\n",
+    "        source_lower_bound_sample_extra, # extra bound\n",
+    "        source_upper_bound_sample_extra, # extra bound\n",
+    "        base_amount_sample,\n",
+    "        source_amount_sample,\n",
+    "        source_amount_sample_extra,      # extra amount\n",
+    "        ctf_label,\n",
+    "        ctf_label_str,\n",
+    "        ctf_label_extra,     # extra label\n",
+    "        ctf_label_str_extra, # extra label\n",
+    "    )\n",
+    "\n",
+    "def bound_alignment_sampler_multisource(\n",
+    "    tokenizer,\n",
+    "    max_n_training_examples,\n",
+    "    bound_functors,\n",
+    "    amount=None,\n",
+    "    lower_bound=None,\n",
+    "    bound_width=None,\n",
+    "):\n",
+    "    all_base_input_ids = []\n",
+    "    all_source_input_ids = []\n",
+    "    all_ctf_output_ids = []  # this one does not have input ids, etc..\n",
+    "    all_intervention_ids = []\n",
+    "    \n",
+    "    all_second_source_input_ids = []\n",
+    "    all_second_ctf_output_ids = []\n",
+    "    \n",
+    "    for _ in range(max_n_training_examples):\n",
+    "        bound_functor = random.choice(bound_functors)\n",
+    "        (\n",
+    "            base_lower_bound_sample,\n",
+    "            base_upper_bound_sample,\n",
+    "            source_lower_bound_sample,\n",
+    "            source_upper_bound_sample,\n",
+    "            source_lower_bound_sample_extra, # extra bound\n",
+    "            source_upper_bound_sample_extra, # extra bound\n",
+    "            base_amount_sample,\n",
+    "            source_amount_sample,\n",
+    "            source_amount_sample_extra,      # extra amount\n",
+    "            ctf_label,\n",
+    "            ctf_label_str,\n",
+    "            ctf_label_extra,     # extra label\n",
+    "            ctf_label_str_extra, # extra label\n",
+    "        ) = bound_functor(\n",
+    "            tokenizer,\n",
+    "            amount,\n",
+    "            lower_bound,\n",
+    "            bound_width,\n",
+    "        )\n",
+    "\n",
+    "        base_amount_str = \"%.2f dollars\" % base_amount_sample\n",
+    "        source_amount_str = \"%.2f dollars\" % source_amount_sample\n",
+    "        source_amount_str_extra = \"%.2f dollars\" % source_amount_sample_extra\n",
+    "        base_lower_bound_str = \"%.2f\" % base_lower_bound_sample\n",
+    "        base_upper_bound_str = \"%.2f\" % base_upper_bound_sample\n",
+    "        source_lower_bound_str = \"%.2f\" % source_lower_bound_sample\n",
+    "        source_upper_bound_str = \"%.2f\" % source_upper_bound_sample\n",
+    "        source_lower_bound_str_extra = \"%.2f\" % source_lower_bound_sample_extra\n",
+    "        source_upper_bound_str_extra = \"%.2f\" % source_upper_bound_sample_extra\n",
+    "        # print(f\"base: [{base_lower_bound_str}, {base_upper_bound_str}], {base_amount_str}\")\n",
+    "        # print(f\"source: [{source_lower_bound_str}, {source_upper_bound_str}], {source_amount_str}\")\n",
+    "        # print(f\"ctf label: {ctf_label_str}\")\n",
+    "\n",
+    "        base_instruction = f\"Please say yes only if it costs between {base_lower_bound_str} and {base_upper_bound_str} dollars, otherwise no.\"\n",
+    "        source_instruction = f\"Please say yes only if it costs between {source_lower_bound_str} and {source_upper_bound_str} dollars, otherwise no.\"\n",
+    "        source_instruction_extra = f\"Please say yes only if it costs between {source_lower_bound_str_extra} and {source_upper_bound_str_extra} dollars, otherwise no.\"\n",
+    "        \n",
+    "        base_alpaca_prompt = alpaca_prompt_template % (\n",
+    "            base_instruction,\n",
+    "            base_amount_str,\n",
+    "        )\n",
+    "        source_alpaca_prompt = alpaca_prompt_template % (\n",
+    "            source_instruction,\n",
+    "            source_amount_str,\n",
+    "        )\n",
+    "        source_alpaca_prompt_extra = alpaca_prompt_template % (\n",
+    "            source_instruction_extra,\n",
+    "            source_amount_str_extra,\n",
+    "        )\n",
+    "        \n",
+    "        base_input_ids = tokenizer(base_alpaca_prompt, return_tensors=\"pt\").input_ids[0]\n",
+    "        source_input_ids = tokenizer(\n",
+    "            source_alpaca_prompt, return_tensors=\"pt\"\n",
+    "        ).input_ids[0]\n",
+    "        source_input_ids_extra = tokenizer(\n",
+    "            source_alpaca_prompt_extra, return_tensors=\"pt\"\n",
+    "        ).input_ids[0]\n",
+    "        \n",
+    "        base_input_ids = base_input_ids.tolist()\n",
+    "        source_input_ids = source_input_ids.tolist()\n",
+    "        source_input_ids_extra = source_input_ids_extra.tolist()\n",
+    "        \n",
+    "        ctf_output_ids = (torch.ones(len(base_input_ids)) * -100).long().tolist()\n",
+    "        ctf_output_ids[-1] = ctf_label\n",
+    "        ctf_output_ids_extra = (torch.ones(len(base_input_ids)) * -100).long().tolist()\n",
+    "        ctf_output_ids_extra[-1] = ctf_label_extra\n",
+    "        intervention_id = 0 if bound_functor == bound_functors[0] else 1\n",
+    "\n",
+    "        all_base_input_ids += [base_input_ids]\n",
+    "        all_source_input_ids += [source_input_ids]\n",
+    "        all_second_source_input_ids += [source_input_ids_extra]\n",
+    "\n",
+    "        all_ctf_output_ids += [ctf_output_ids]\n",
+    "        all_second_ctf_output_ids += [ctf_output_ids_extra]\n",
+    "        all_intervention_ids += [intervention_id]\n",
+    "\n",
+    "        assert len(base_input_ids) == 82\n",
+    "        assert len(source_input_ids) == 82\n",
+    "\n",
+    "    return (\n",
+    "        all_base_input_ids,\n",
+    "        all_source_input_ids,\n",
+    "        all_second_source_input_ids,\n",
+    "        all_ctf_output_ids,\n",
+    "        all_second_ctf_output_ids,\n",
+    "        all_intervention_ids,\n",
+    "    )\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 146,
+   "id": "daa4becb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "multisource_non_contradict_test_data = bound_alignment_sampler_multisource(\n",
+    "    tokenizer, 1000, [lower_bound_alignment_example_sampler_multisource_non_contradict]\n",
+    ")\n",
+    "multisource_contradict_test_data = bound_alignment_sampler_multisource(\n",
+    "    tokenizer, 1000, [lower_bound_alignment_example_sampler_multisource_contradict]\n",
+    ")\n",
+    "multisource_non_contradict_test_dataset = Dataset.from_dict(\n",
+    "    {\n",
+    "        \"input_ids\": multisource_non_contradict_test_data[0],\n",
+    "        \"source_input_ids\": multisource_non_contradict_test_data[1],\n",
+    "        \"second_source_input_ids\": multisource_non_contradict_test_data[2],\n",
+    "        \"labels\": multisource_non_contradict_test_data[3],\n",
+    "        \"second_labels\": multisource_non_contradict_test_data[4],\n",
+    "        \"intervention_ids\": multisource_non_contradict_test_data[5],  # we will not use this field\n",
+    "    }\n",
+    ").with_format(\"torch\")\n",
+    "multisource_non_contradict_test_dataloader = DataLoader(multisource_non_contradict_test_dataset, batch_size=16)\n",
+    "\n",
+    "multisource_contradict_test_dataset = Dataset.from_dict(\n",
+    "    {\n",
+    "        \"input_ids\": multisource_contradict_test_data[0],\n",
+    "        \"source_input_ids\": multisource_contradict_test_data[1],\n",
+    "        \"second_source_input_ids\": multisource_contradict_test_data[2],\n",
+    "        \"labels\": multisource_contradict_test_data[3],\n",
+    "        \"second_labels\": multisource_contradict_test_data[4],\n",
+    "        \"intervention_ids\": multisource_contradict_test_data[5],  # we will not use this field\n",
+    "    }\n",
+    ").with_format(\"torch\")\n",
+    "multisource_contradict_test_dataloader = DataLoader(multisource_contradict_test_dataset, batch_size=16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 158,
+   "id": "bcb96a3d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[control] swapping two sources with the same counterfactual behavior\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 63/63 [01:04<00:00,  1.02s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 200,
+       "width": 400
+      }
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "swapping contradicting sources, and evaluate with matching location 75\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 63/63 [01:07<00:00,  1.07s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 200,
+       "width": 400
+      }
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "swapping contradicting sources, and evaluate with matching location 80\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 63/63 [01:09<00:00,  1.10s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 200,
+       "width": 400
+      }
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"[control] swapping two sources with the same counterfactual behavior\")\n",
+    "for testing_label in [\"labels\"]:\n",
+    "    collected_probs = []\n",
+    "    eval_labels = []\n",
+    "    eval_preds = []\n",
+    "    with torch.no_grad():\n",
+    "        epoch_iterator = tqdm(multisource_non_contradict_test_dataloader, desc=f\"Test\")\n",
+    "        for step, inputs in enumerate(epoch_iterator):\n",
+    "            for k, v in inputs.items():\n",
+    "                if v is not None and isinstance(v, torch.Tensor):\n",
+    "                    inputs[k] = v.to(\"cuda\")\n",
+    "            b_s = inputs[\"input_ids\"].shape[0]\n",
+    "            input_sources = [\n",
+    "                {\"input_ids\": inputs[\"source_input_ids\"]},\n",
+    "                {\"input_ids\": inputs[\"second_source_input_ids\"]}\n",
+    "            ]\n",
+    "            _, counterfactual_outputs = pv_llama(\n",
+    "                {\"input_ids\": inputs[\"input_ids\"]},\n",
+    "                input_sources, {\"sources->base\": [75, 80]}\n",
+    "            )\n",
+    "            correct_label = inputs[testing_label][:,-1]\n",
+    "            incorrect_label = \\\n",
+    "                ((correct_label == 8241)*3782 + \\\n",
+    "                (correct_label == 3782)*8241).long()\n",
+    "            norm_prob = torch.softmax(\n",
+    "                counterfactual_outputs.logits[:, -1], dim=-1)\n",
+    "            correct_prob = norm_prob[torch.arange(b_s),correct_label].detach().cpu()\n",
+    "            incorrect_prob = norm_prob[torch.arange(b_s),incorrect_label].detach().cpu()\n",
+    "            diff_prob = torch.abs(correct_prob - incorrect_prob)\n",
+    "            collected_probs += [[correct_prob, incorrect_prob, diff_prob]]\n",
+    "            eval_labels += [inputs[testing_label]]\n",
+    "            eval_preds += [counterfactual_outputs.logits]\n",
+    "    correct_probs = torch.cat([p[0] for p in collected_probs])\n",
+    "    incorrect_probs = torch.cat([p[1] for p in collected_probs])\n",
+    "    diff_probs = torch.cat([p[2] for p in collected_probs])\n",
+    "    eval_metrics = compute_metrics(eval_preds, eval_labels)\n",
+    "\n",
+    "    list1 = correct_probs.tolist()\n",
+    "    list2 = incorrect_probs.tolist()\n",
+    "    list3 = diff_probs.tolist()\n",
+    "    acc = eval_metrics['accuracy']\n",
+    "    df = pd.DataFrame({'Group': ['Correct']*len(list1) + ['Incorrect']*len(list2) + ['Abs(Diff)']*len(list2),\n",
+    "                       'Value': list1 + list2 + list3})\n",
+    "    means = df.groupby('Group')['Value'].mean().reset_index()\n",
+    "    means['ymin'] = means['Value'] - df.groupby('Group')['Value'].std().reset_index()['Value']\n",
+    "    means['ymax'] = means['Value'] + df.groupby('Group')['Value'].std().reset_index()['Value']\n",
+    "    plot = (ggplot(df, aes('Group', 'Value')) +\n",
+    "            geom_boxplot(fill='lightgray', alpha=0.5) +\n",
+    "            geom_point(means, aes('Group', 'Value'), color='blue', size=3) +\n",
+    "            geom_errorbar(means, aes('Group', ymin='ymin', ymax='ymax'), width=0.2) +\n",
+    "            labs(title=f'w/ Acc={acc}', x='Token Type', y='Prob (Softmax)') +\n",
+    "            theme(figure_size=(4, 2)))\n",
+    "    print(plot)\n",
+    "    \n",
+    "for testing_label in [\"labels\", \"second_labels\"]:\n",
+    "    if testing_label == \"labels\":\n",
+    "        print(\"swapping contradicting sources, and evaluate with matching location 75\")\n",
+    "    elif testing_label == \"second_labels\":\n",
+    "        print(\"swapping contradicting sources, and evaluate with matching location 80\")\n",
+    "    collected_probs = []\n",
+    "    eval_labels = []\n",
+    "    eval_preds = []\n",
+    "    with torch.no_grad():\n",
+    "        epoch_iterator = tqdm(multisource_contradict_test_dataloader, desc=f\"Test\")\n",
+    "        for step, inputs in enumerate(epoch_iterator):\n",
+    "            for k, v in inputs.items():\n",
+    "                if v is not None and isinstance(v, torch.Tensor):\n",
+    "                    inputs[k] = v.to(\"cuda\")\n",
+    "            b_s = inputs[\"input_ids\"].shape[0]\n",
+    "            input_sources = [\n",
+    "                {\"input_ids\": inputs[\"source_input_ids\"]},\n",
+    "                {\"input_ids\": inputs[\"second_source_input_ids\"]}\n",
+    "            ]\n",
+    "            _, counterfactual_outputs = pv_llama(\n",
+    "                {\"input_ids\": inputs[\"input_ids\"]},\n",
+    "                input_sources, {\"sources->base\": [75, 80]}\n",
+    "            )\n",
+    "            correct_label = inputs[testing_label][:,-1]\n",
+    "            incorrect_label = \\\n",
+    "                ((correct_label == 8241)*3782 + \\\n",
+    "                (correct_label == 3782)*8241).long()\n",
+    "            norm_prob = torch.softmax(\n",
+    "                counterfactual_outputs.logits[:, -1], dim=-1)\n",
+    "            correct_prob = norm_prob[torch.arange(b_s),correct_label].detach().cpu()\n",
+    "            incorrect_prob = norm_prob[torch.arange(b_s),incorrect_label].detach().cpu()\n",
+    "            diff_prob = torch.abs(correct_prob - incorrect_prob)\n",
+    "            collected_probs += [[correct_prob, incorrect_prob, diff_prob]]\n",
+    "            eval_labels += [inputs[testing_label]]\n",
+    "            eval_preds += [counterfactual_outputs.logits]\n",
+    "    correct_probs = torch.cat([p[0] for p in collected_probs])\n",
+    "    incorrect_probs = torch.cat([p[1] for p in collected_probs])\n",
+    "    diff_probs = torch.cat([p[2] for p in collected_probs])\n",
+    "    eval_metrics = compute_metrics(eval_preds, eval_labels)\n",
+    "\n",
+    "    list1 = correct_probs.tolist()\n",
+    "    list2 = incorrect_probs.tolist()\n",
+    "    list3 = diff_probs.tolist()\n",
+    "    acc = eval_metrics['accuracy']\n",
+    "    df = pd.DataFrame({'Group': ['Correct']*len(list1) + ['Incorrect']*len(list2) + ['Abs(Diff)']*len(list2),\n",
+    "                       'Value': list1 + list2 + list3})\n",
+    "    means = df.groupby('Group')['Value'].mean().reset_index()\n",
+    "    means['ymin'] = means['Value'] - df.groupby('Group')['Value'].std().reset_index()['Value']\n",
+    "    means['ymax'] = means['Value'] + df.groupby('Group')['Value'].std().reset_index()['Value']\n",
+    "    plot = (ggplot(df, aes('Group', 'Value')) +\n",
+    "            geom_boxplot(fill='lightgray', alpha=0.5) +\n",
+    "            geom_point(means, aes('Group', 'Value'), color='blue', size=3) +\n",
+    "            geom_errorbar(means, aes('Group', ymin='ymin', ymax='ymax'), width=0.2) +\n",
+    "            labs(title=f'w/ Acc={acc}', x='Token Type', y='Prob (Softmax)') +\n",
+    "            theme(figure_size=(4, 2)))\n",
+    "    print(plot)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2105ac9f",
+   "metadata": {},
+   "source": [
+    "#### The results above show if two intervention sites take on contradicting values, it will trust the earlier site. \n",
+    "It is hard to say if this would hold till more tests. However, we can see the neural network shows some voting mechanism by trusting some location over another during interventions when these locations take different values. If they have the same value, it seems to working well."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d2deee7",
+   "metadata": {},
+   "source": [
+    "##### Minor: make sure other control models cannot find good alignments\n",
+    "We test this by training Boundless DAS with the best locations in the paper: layer 15 and last token (81th)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "e5a9c190",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "control_sampler = bracket_alignment_sampler"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "5cb5aa40",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "set_seed(42)\n",
+    "\n",
+    "###################\n",
+    "# data loaders\n",
+    "###################\n",
+    "raw_data = control_sampler(\n",
+    "    tokenizer, 10000,\n",
+    ")\n",
+    "\n",
+    "raw_train = (\n",
+    "    raw_data[0][:8000],\n",
+    "    raw_data[1][:8000],\n",
+    "    raw_data[2][:8000],\n",
+    "    raw_data[3][:8000],\n",
+    ")\n",
+    "raw_eval = (\n",
+    "    raw_data[0][8000:9000],\n",
+    "    raw_data[1][8000:9000],\n",
+    "    raw_data[2][8000:9000],\n",
+    "    raw_data[3][8000:9000],\n",
+    ")\n",
+    "raw_test = (\n",
+    "    raw_data[0][9000:],\n",
+    "    raw_data[1][9000:],\n",
+    "    raw_data[2][9000:],\n",
+    "    raw_data[3][9000:],\n",
+    ")\n",
+    "train_dataset = Dataset.from_dict(\n",
+    "    {\n",
+    "        \"input_ids\": raw_train[0],\n",
+    "        \"source_input_ids\": raw_train[1],\n",
+    "        \"labels\": raw_train[2],\n",
+    "        \"intervention_ids\": raw_train[3],  # we will not use this field\n",
+    "    }\n",
+    ").with_format(\"torch\")\n",
+    "train_dataloader = DataLoader(\n",
+    "    train_dataset,\n",
+    "    batch_size=16,\n",
+    ")\n",
+    "eval_dataset = Dataset.from_dict(\n",
+    "    {\n",
+    "        \"input_ids\": raw_eval[0],\n",
+    "        \"source_input_ids\": raw_eval[1],\n",
+    "        \"labels\": raw_eval[2],\n",
+    "        \"intervention_ids\": raw_eval[3],  # we will not use this field\n",
+    "    }\n",
+    ").with_format(\"torch\")\n",
+    "eval_dataloader = DataLoader(\n",
+    "    eval_dataset,\n",
+    "    batch_size=16,\n",
+    ")\n",
+    "test_dataset = Dataset.from_dict(\n",
+    "    {\n",
+    "        \"input_ids\": raw_test[0],\n",
+    "        \"source_input_ids\": raw_test[1],\n",
+    "        \"labels\": raw_test[2],\n",
+    "        \"intervention_ids\": raw_test[3],  # we will not use this field\n",
+    "    }\n",
+    ").with_format(\"torch\")\n",
+    "test_dataloader = DataLoader(\n",
+    "    test_dataset,\n",
+    "    batch_size=16,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "0f4d8e82",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "layer = 15\n",
+    "token_position = 81"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "de0d63ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pv_config = pv.IntervenableConfig(\n",
+    "    representations=[\n",
+    "        pv.RepresentationConfig(\n",
+    "            layer, \"block_output\"\n",
+    "        )],\n",
+    "    intervention_types=pv.BoundlessRotatedSpaceIntervention,\n",
+    ")\n",
+    "pv_llama = pv.IntervenableModel(pv_config, llama)\n",
+    "pv_llama.set_device(\"cuda\")\n",
+    "pv_llama.disable_model_gradients()\n",
+    "\n",
+    "epochs = 1\n",
+    "gradient_accumulation_steps = 4\n",
+    "total_step = 0\n",
+    "t_total = int(len(train_dataloader) * epochs)\n",
+    "temperature_start = 50.0\n",
+    "temperature_end = 0.1\n",
+    "temperature_schedule = (\n",
+    "    torch.linspace(\n",
+    "        temperature_start, temperature_end, t_total\n",
+    "    )\n",
+    "    .to(torch.bfloat16)\n",
+    "    .to(\"cuda\")\n",
+    ")\n",
+    "pv_llama.set_temperature(temperature_schedule[total_step])\n",
+    "\n",
+    "warm_up_steps = 0.1 * t_total\n",
+    "optimizer_params = []\n",
+    "for k, v in pv_llama.interventions.items():\n",
+    "    optimizer_params += [\n",
+    "        {\"params\": v[0].rotate_layer.parameters()}]\n",
+    "    optimizer_params += [\n",
+    "        {\"params\": v[0].intervention_boundaries, \"lr\": 1e-2}]\n",
+    "optimizer = torch.optim.Adam(optimizer_params, lr=1e-3)\n",
+    "scheduler = get_linear_schedule_with_warmup(\n",
+    "    optimizer, num_warmup_steps=warm_up_steps,\n",
+    "    num_training_steps=t_total\n",
+    ")\n",
+    "\n",
+    "def calculate_loss(logits, labels):\n",
+    "    shift_logits = logits[..., :, :].contiguous()\n",
+    "    shift_labels = labels[..., :].contiguous()\n",
+    "    # Flatten the tokens\n",
+    "    loss_fct = CrossEntropyLoss()\n",
+    "    shift_logits = shift_logits.view(-1, config.vocab_size)\n",
+    "    shift_labels = shift_labels.view(-1)\n",
+    "    # Enable model parallelism\n",
+    "    shift_labels = shift_labels.to(shift_logits.device)\n",
+    "    loss = loss_fct(shift_logits, shift_labels)\n",
+    "\n",
+    "    for k, v in pv_llama.interventions.items():\n",
+    "        boundary_loss = 1.0 * v[0].intervention_boundaries.sum()\n",
+    "    loss += boundary_loss\n",
+    "\n",
+    "    return loss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "8a996118",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "llama trainable parameters:  0\n",
+      "intervention trainable parameters:  16777218\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [13:18<00:00,  1.60s/it, loss=0.73, acc=0.75]\n",
+      "Epoch: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [13:18<00:00, 798.36s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "pv_llama.model.train()  # train enables drop-off but no grads\n",
+    "print(\"llama trainable parameters: \", count_parameters(pv_llama.model))\n",
+    "print(\"intervention trainable parameters: \", pv_llama.count_parameters())\n",
+    "train_iterator = trange(0, int(epochs), desc=\"Epoch\")\n",
+    "for epoch in train_iterator:\n",
+    "    epoch_iterator = tqdm(\n",
+    "        train_dataloader, \n",
+    "        desc=f\"Epoch: {epoch}\", position=0, leave=True\n",
+    "    )\n",
+    "    for step, inputs in enumerate(epoch_iterator):\n",
+    "        for k, v in inputs.items():\n",
+    "            if v is not None and isinstance(v, torch.Tensor):\n",
+    "                inputs[k] = v.to(\"cuda\")\n",
+    "        b_s = inputs[\"input_ids\"].shape[0]\n",
+    "        _, counterfactual_outputs = pv_llama(\n",
+    "            {\"input_ids\": inputs[\"input_ids\"]},\n",
+    "            [{\"input_ids\": inputs[\"source_input_ids\"]}],\n",
+    "            {\"sources->base\": token_position},\n",
+    "        )\n",
+    "        eval_metrics = compute_metrics(\n",
+    "            [counterfactual_outputs.logits], [inputs[\"labels\"]]\n",
+    "        )\n",
+    "\n",
+    "        # loss and backprop\n",
+    "        loss = calculate_loss(counterfactual_outputs.logits, inputs[\"labels\"])\n",
+    "        loss_str = round(loss.item(), 2)\n",
+    "        epoch_iterator.set_postfix({\"loss\": loss_str, \"acc\": eval_metrics[\"accuracy\"]})\n",
+    "\n",
+    "        if gradient_accumulation_steps > 1:\n",
+    "            loss = loss / gradient_accumulation_steps\n",
+    "        loss.backward()\n",
+    "        if total_step % gradient_accumulation_steps == 0:\n",
+    "            if not (gradient_accumulation_steps > 1 and total_step == 0):\n",
+    "                optimizer.step()\n",
+    "                scheduler.step()\n",
+    "                optimizer.zero_grad()\n",
+    "                pv_llama.set_temperature(\n",
+    "                    temperature_schedule[total_step])\n",
+    "        total_step += 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "32e2894a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Test: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 63/63 [00:43<00:00,  1.46it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'accuracy': 0.68}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# evaluation on the test set\n",
+    "eval_labels = []\n",
+    "eval_preds = []\n",
+    "with torch.no_grad():\n",
+    "    epoch_iterator = tqdm(test_dataloader, desc=f\"Test\")\n",
+    "    for step, inputs in enumerate(epoch_iterator):\n",
+    "        for k, v in inputs.items():\n",
+    "            if v is not None and isinstance(v, torch.Tensor):\n",
+    "                inputs[k] = v.to(\"cuda\")\n",
+    "        b_s = inputs[\"input_ids\"].shape[0]\n",
+    "        _, counterfactual_outputs = pv_llama(\n",
+    "            {\"input_ids\": inputs[\"input_ids\"]},\n",
+    "            [{\"input_ids\": inputs[\"source_input_ids\"]}],\n",
+    "            {\"sources->base\": 75}\n",
+    "        )\n",
+    "        eval_labels += [inputs[\"labels\"]]\n",
+    "        eval_preds += [counterfactual_outputs.logits]\n",
+    "eval_metrics = compute_metrics(eval_preds, eval_labels)\n",
+    "print(eval_metrics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "18a61a22",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/advanced_tutorials/tutorial_price_tagging_utils.py b/tutorials/advanced_tutorials/tutorial_price_tagging_utils.py
index 94494be2..0ec7c6a0 100644
--- a/tutorials/advanced_tutorials/tutorial_price_tagging_utils.py
+++ b/tutorials/advanced_tutorials/tutorial_price_tagging_utils.py
@@ -296,3 +296,146 @@ def bound_alignment_sampler(
         all_ctf_output_ids,
         all_intervention_ids,
     )
+
+
+def midpoint_alignment_sampler(
+    tokenizer,
+    max_n_training_examples,
+    amount=None,
+    lower_bound=None,
+    bound_width=None,
+):
+
+    all_base_input_ids = []
+    all_source_input_ids = []
+    all_ctf_output_ids = [] # this one does not have input ids, etc..
+    all_intervention_ids = []
+    
+    for _ in range(max_n_training_examples):
+        
+        base_lower_bound_sample, base_upper_bound_sample, base_amount_sample = \
+            pricing_tag_game_config_sampler(
+                amount,
+                lower_bound,
+                bound_width
+            )
+        source_lower_bound_sample, source_upper_bound_sample, source_amount_sample = \
+            pricing_tag_game_config_sampler(
+                amount,
+                lower_bound,
+                bound_width
+            )
+        ctf_label = None
+        ctf_label_str = None
+        source_mid_point = (source_lower_bound_sample+source_upper_bound_sample)/2.0
+        base_half = 0.5*abs(base_upper_bound_sample-base_lower_bound_sample)
+        ctf_mid_diff = abs(base_amount_sample-source_mid_point)
+        if ctf_mid_diff <= base_half:
+            ctf_label = tokenizer.convert_tokens_to_ids("Yes")
+            ctf_label_str = "Yes"
+        else:
+            ctf_label = tokenizer.convert_tokens_to_ids("No")
+            ctf_label_str = "No"
+            
+        base_amount_str = "%.2f dollars" % base_amount_sample
+        source_amount_str = "%.2f dollars" % source_amount_sample
+        base_lower_bound_str = "%.2f" % base_lower_bound_sample
+        base_upper_bound_str = "%.2f" % base_upper_bound_sample
+        source_lower_bound_str = "%.2f" % source_lower_bound_sample
+        source_upper_bound_str = "%.2f" % source_upper_bound_sample
+        
+        # print(f"base: [{base_lower_bound_str}, {base_upper_bound_str}], {base_amount_str}")
+        # print(f"source: [{source_lower_bound_str}, {source_upper_bound_str}], {source_amount_str}")
+        # print(f"ctf label: {ctf_label_str}")
+        
+        base_instruction = f"Please say yes only if it costs between {base_lower_bound_str} and {base_upper_bound_str} dollars, otherwise no."
+        source_instruction = f"Please say yes only if it costs between {source_lower_bound_str} and {source_upper_bound_str} dollars, otherwise no."
+        
+        base_alpaca_prompt = alpaca_prompt_template % (base_instruction, base_amount_str)
+        source_alpaca_prompt = alpaca_prompt_template % (source_instruction, source_amount_str)
+        
+        base_input_ids = tokenizer(base_alpaca_prompt, return_tensors="pt").input_ids[0]
+        source_input_ids = tokenizer(source_alpaca_prompt, return_tensors="pt").input_ids[0]
+        base_input_ids = base_input_ids.tolist()
+        source_input_ids = source_input_ids.tolist()
+        ctf_output_ids = (torch.ones(len(base_input_ids))*-100).long().tolist()
+        ctf_output_ids[-1] = ctf_label
+        
+        all_base_input_ids += [base_input_ids]
+        all_source_input_ids += [source_input_ids]
+        all_ctf_output_ids += [ctf_output_ids]
+        all_intervention_ids += [0]
+        assert len(base_input_ids) == 82
+        assert len(source_input_ids) == 82
+        
+    return all_base_input_ids, all_source_input_ids, all_ctf_output_ids, all_intervention_ids
+
+
+def bracket_alignment_sampler(
+    tokenizer,
+    max_n_training_examples,
+    amount=None,
+    lower_bound=None,
+    bound_width=None,
+):
+
+    all_base_input_ids = []
+    all_source_input_ids = []
+    all_ctf_output_ids = [] # this one does not have input ids, etc..
+    all_intervention_ids = []
+    
+    for _ in range(max_n_training_examples):
+        
+        base_lower_bound_sample, base_upper_bound_sample, base_amount_sample = \
+            pricing_tag_game_config_sampler(
+                amount,
+                lower_bound,
+                bound_width
+            )
+        source_lower_bound_sample, source_upper_bound_sample, source_amount_sample = \
+            pricing_tag_game_config_sampler(
+                amount,
+                lower_bound,
+                bound_width
+            )
+        ctf_label = None
+        ctf_label_str = None
+        if base_amount_sample <= source_upper_bound_sample and base_amount_sample >= source_lower_bound_sample:
+            ctf_label = tokenizer.convert_tokens_to_ids("Yes")
+            ctf_label_str = "Yes"
+        else:
+            ctf_label = tokenizer.convert_tokens_to_ids("No")
+            ctf_label_str = "No"
+            
+        base_amount_str = "%.2f dollars" % base_amount_sample
+        source_amount_str = "%.2f dollars" % source_amount_sample
+        base_lower_bound_str = "%.2f" % base_lower_bound_sample
+        base_upper_bound_str = "%.2f" % base_upper_bound_sample
+        source_lower_bound_str = "%.2f" % source_lower_bound_sample
+        source_upper_bound_str = "%.2f" % source_upper_bound_sample
+        
+        # print(f"base: [{base_lower_bound_str}, {base_upper_bound_str}], {base_amount_str}")
+        # print(f"source: [{source_lower_bound_str}, {source_upper_bound_str}], {source_amount_str}")
+        # print(f"ctf label: {ctf_label_str}")
+        
+        base_instruction = f"Please say yes only if it costs between {base_lower_bound_str} and {base_upper_bound_str} dollars, otherwise no."
+        source_instruction = f"Please say yes only if it costs between {source_lower_bound_str} and {source_upper_bound_str} dollars, otherwise no."
+        
+        base_alpaca_prompt = alpaca_prompt_template % (base_instruction, base_amount_str)
+        source_alpaca_prompt = alpaca_prompt_template % (source_instruction, source_amount_str)
+        
+        base_input_ids = tokenizer(base_alpaca_prompt, return_tensors="pt").input_ids[0]
+        source_input_ids = tokenizer(source_alpaca_prompt, return_tensors="pt").input_ids[0]
+        base_input_ids = base_input_ids.tolist()
+        source_input_ids = source_input_ids.tolist()
+        ctf_output_ids = (torch.ones(len(base_input_ids))*-100).long().tolist()
+        ctf_output_ids[-1] = ctf_label
+        
+        all_base_input_ids += [base_input_ids]
+        all_source_input_ids += [source_input_ids]
+        all_ctf_output_ids += [ctf_output_ids]
+        all_intervention_ids += [0]
+        assert len(base_input_ids) == 82
+        assert len(source_input_ids) == 82
+        
+    return all_base_input_ids, all_source_input_ids, all_ctf_output_ids, all_intervention_ids


Test patch:
diff --git a/tests/integration_tests/IntervenableBasicTestCase.py b/tests/integration_tests/IntervenableBasicTestCase.py
index 0b71e7d0..546c496a 100644
--- a/tests/integration_tests/IntervenableBasicTestCase.py
+++ b/tests/integration_tests/IntervenableBasicTestCase.py
@@ -1,6 +1,7 @@
 import unittest
 from ..utils import *
 
+import copy
 import torch
 import pyvene as pv
 
@@ -603,7 +604,66 @@ def test_multisource_serial(self):
             # on different subspaces
             subspaces=[[[0]], [[1]]],
         )
+        
+    def test_customized_intervention_function_get(self):
+
+        _, tokenizer, gpt2 = pv.create_gpt2()
+
+        pv_gpt2 = pv.IntervenableModel({
+            "layer": 10,
+            "component": "attention_weight",
+            "intervention_type": pv.CollectIntervention}, model=gpt2)
+
+        base = "When John and Mary went to the shops, Mary gave the bag to"
+        collected_attn_w = pv_gpt2(
+            base = tokenizer(base, return_tensors="pt"
+            ), unit_locations={"base": [h for h in range(12)]}
+        )[0][-1][0]
 
+        cached_w = {}
+        def pv_patcher(b, s): cached_w["attn_w"] = copy.deepcopy(b.data)
+
+        pv_gpt2 = pv.IntervenableModel({
+            "component": "h[10].attn.attn_dropout.input", 
+            "intervention": pv_patcher}, model=gpt2)
+
+        base = "When John and Mary went to the shops, Mary gave the bag to"
+        _ = pv_gpt2(tokenizer(base, return_tensors="pt"))
+        torch.allclose(collected_attn_w, cached_w["attn_w"].unsqueeze(dim=0))
+      
+    def test_customized_intervention_function_zeroout(self):
+        
+        _, tokenizer, gpt2 = pv.create_gpt2()
+
+        # define the component to zero-out
+        pv_gpt2 = pv.IntervenableModel({
+            "layer": 0, "component": "mlp_output",
+            "source_representation": torch.zeros(gpt2.config.n_embd)
+        }, model=gpt2)
+        # run the intervened forward pass
+        intervened_outputs = pv_gpt2(
+            base = tokenizer("The capital of Spain is", return_tensors="pt"), 
+            # we define the intervening token dynamically
+            unit_locations={"base": 3}
+        )
+        
+        # indices are specified in the intervention
+        mask = torch.ones(1, 5, 768)
+        mask[:,3,:] = 0.
+        # define the component to zero-out
+        pv_gpt2 = pv.IntervenableModel({
+            "component": "h[0].mlp.output",
+            "intervention": lambda b, s: b*mask
+        }, model=gpt2)
+        # run the intervened forward pass
+        intervened_outputs_fn = pv_gpt2(
+            base = tokenizer("The capital of Spain is", return_tensors="pt")
+        )
+        torch.allclose(
+            intervened_outputs[1].last_hidden_state, 
+            intervened_outputs_fn[1].last_hidden_state
+        )
+    
     @classmethod
     def tearDownClass(self):
         print(f"Removing testing dir {self._test_dir}")
diff --git a/tests/integration_tests/InterventionWithMLPTestCase.py b/tests/integration_tests/InterventionWithMLPTestCase.py
index 1623a9b6..e5b840b0 100644
--- a/tests/integration_tests/InterventionWithMLPTestCase.py
+++ b/tests/integration_tests/InterventionWithMLPTestCase.py
@@ -161,12 +161,12 @@ def test_with_subspace_negative(self):
                 base,
                 [source_1],
                 {"sources->base": ([[[0]] * b_s], [[[0]] * b_s])},
-                subspaces=[[[0]] * b_s],
+                subspaces=0,
             )
-        except ValueError:
+        except IndexError:
             pass
         else:
-            raise AssertionError("ValueError was not raised")
+            raise AssertionError("IndexError was not raised")
 
     def test_intervention_link_positive(self):
         """
diff --git a/tests/unit_tests/IntervenableUnitTestCase.py b/tests/unit_tests/IntervenableUnitTestCase.py
deleted file mode 100644
index f47a3605..00000000
--- a/tests/unit_tests/IntervenableUnitTestCase.py
+++ /dev/null
@@ -1,208 +0,0 @@
-import unittest
-from ..utils import *
-
-
-class IntervenableUnitTestCase(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        print("=== Test Suite: IntervenableUnitTestCase ===")
-        self.config, self.tokenizer, self.gpt2 = create_gpt2_lm(
-            config=GPT2Config(
-                n_embd=24,
-                attn_pdrop=0.0,
-                embd_pdrop=0.0,
-                resid_pdrop=0.0,
-                summary_first_dropout=0.0,
-                n_layer=4,
-                bos_token_id=0,
-                eos_token_id=0,
-                n_positions=128,
-                vocab_size=10,
-            )
-        )
-        self.test_output_dir_prefix = "test_tmp_output"
-        self.test_output_dir_pool = []
-
-    def test_initialization_positive(self):
-        config = IntervenableConfig(
-            model_type=type(self.gpt2),
-            representations=[
-                RepresentationConfig(
-                    0,
-                    "block_output",
-                    "pos",
-                    1,
-                ),
-                RepresentationConfig(
-                    1,
-                    "block_output",
-                    "pos",
-                    1,
-                ),
-            ],
-            intervention_types=VanillaIntervention,
-        )
-
-        intervenable = IntervenableModel(config, self.gpt2)
-
-        assert intervenable.mode == "parallel"
-        self.assertTrue(intervenable.is_model_stateless)
-        assert intervenable.use_fast == False
-
-        assert len(intervenable.interventions) == 2
-        key_list = []
-        counter = 0
-        for k, _ in intervenable.interventions.items():
-            assert "#" in k
-            assert int(k.split("#")[-1]) <= counter
-            counter += 1
-            assert "block_output" in k
-
-        assert len(intervenable._intervention_group) == 2
-        assert len(intervenable._key_getter_call_counter) == 2
-        assert len(intervenable._key_setter_call_counter) == 2
-        assert len(intervenable.activations) == 0
-        assert len(intervenable.hot_activations) == 0
-        assert len(intervenable._batched_setter_activation_select) == 0
-
-    def test_local_non_trainable_save_positive(self):
-        config = IntervenableConfig(
-            model_type=type(self.gpt2),
-            representations=[
-                RepresentationConfig(
-                    0,
-                    "block_output",
-                    "pos",
-                    1,
-                ),
-                RepresentationConfig(
-                    1,
-                    "block_output",
-                    "pos",
-                    1,
-                ),
-            ],
-            intervention_types=VanillaIntervention,
-        )
-
-        intervenable = IntervenableModel(config, self.gpt2)
-        _uuid = str(uuid.uuid4())[:6]
-        _test_dir = os.path.join(f"./test_output_dir_prefix-{_uuid}")
-        self.test_output_dir_pool += [_test_dir]
-
-        intervenable.save(save_directory=_test_dir, save_to_hf_hub=False)
-
-        self.assertTrue(os.path.isfile(os.path.join(_test_dir, "config.json")))
-        for file in os.listdir(_test_dir):
-            if file.endswith(".bin"):
-                raise ValueError(
-                    "For non-trainable interventions, "
-                    "there should not be any model binary file!"
-                )
-
-    def test_local_trainable_save_positive(self):
-        config = IntervenableConfig(
-            model_type=type(self.gpt2),
-            representations=[
-                RepresentationConfig(
-                    0,
-                    "block_output",
-                    "pos",
-                    1,
-                ),
-                RepresentationConfig(
-                    1,
-                    "block_output",
-                    "pos",
-                    1,
-                ),
-            ],
-            intervention_types=RotatedSpaceIntervention,
-        )
-
-        intervenable = IntervenableModel(config, self.gpt2)
-        _uuid = str(uuid.uuid4())[:6]
-        _test_dir = os.path.join(f"./test_output_dir_prefix-{_uuid}")
-        self.test_output_dir_pool += [_test_dir]
-
-        intervenable.save(save_directory=_test_dir, save_to_hf_hub=False)
-
-        self.assertTrue(os.path.isfile(os.path.join(_test_dir, "config.json")))
-        binary_count = 0
-        for file in os.listdir(_test_dir):
-            if file.endswith(".bin"):
-                binary_count += 1
-        if binary_count != 2:
-            raise ValueError(
-                "For trainable interventions, "
-                "there should binary file for each of them."
-            )
-
-    def _test_local_trainable_load_positive(self, intervention_types):
-        b_s = 10
-
-        config = IntervenableConfig(
-            model_type=type(self.gpt2),
-            representations=[
-                RepresentationConfig(
-                    0, "block_output", "pos", 1, low_rank_dimension=4
-                ),
-                RepresentationConfig(
-                    1, "block_output", "pos", 1, low_rank_dimension=4
-                ),
-            ],
-            intervention_types=intervention_types,
-        )
-
-        intervenable = IntervenableModel(config, self.gpt2)
-        _uuid = str(uuid.uuid4())[:6]
-        _test_dir = os.path.join(f"./test_output_dir_prefix-{_uuid}")
-        self.test_output_dir_pool += [_test_dir]
-
-        intervenable.save(save_directory=_test_dir, save_to_hf_hub=False)
-
-        loaded = IntervenableModel.load(
-            load_directory=_test_dir,
-            model=self.gpt2,
-        )
-
-        assert intervenable != loaded
-
-        base = {"input_ids": torch.randint(0, 10, (b_s, 10))}
-        source = {"input_ids": torch.randint(0, 10, (b_s, 10))}
-
-        _, counterfactual_outputs_unsaved = intervenable(
-            base, [source, source], {"sources->base": ([[[3]], [[4]]], [[[3]], [[4]]])}
-        )
-
-        _, counterfactual_outputs_loaded = loaded(
-            base, [source, source], {"sources->base": ([[[3]], [[4]]], [[[3]], [[4]]])}
-        )
-
-        torch.equal(counterfactual_outputs_unsaved[0], counterfactual_outputs_loaded[0])
-
-    def test_local_load_positive(self):
-        self._test_local_trainable_load_positive(VanillaIntervention)
-        self._test_local_trainable_load_positive(RotatedSpaceIntervention)
-        self._test_local_trainable_load_positive(LowRankRotatedSpaceIntervention)
-
-    @classmethod
-    def tearDownClass(self):
-        for current_dir in self.test_output_dir_pool:
-            print(f"Removing testing dir {current_dir}")
-            if os.path.exists(current_dir) and os.path.isdir(current_dir):
-                shutil.rmtree(current_dir)
-
-
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(IntervenableUnitTestCase("test_initialization_positive"))
-    suite.addTest(IntervenableUnitTestCase("test_local_non_trainable_save_positive"))
-    suite.addTest(IntervenableUnitTestCase("test_local_trainable_save_positive"))
-    suite.addTest(IntervenableUnitTestCase("test_local_load_positive"))
-    return suite
-
-
-if __name__ == "__main__":
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
diff --git a/tests/unit_tests/InterventionUtilsTestCase.py b/tests/unit_tests/InterventionUtilsTestCase.py
index 9074473d..ed1af69e 100644
--- a/tests/unit_tests/InterventionUtilsTestCase.py
+++ b/tests/unit_tests/InterventionUtilsTestCase.py
@@ -7,6 +7,190 @@
 
 
 class InterventionUtilsTestCase(unittest.TestCase):
+    
+    @classmethod
+    def setUpClass(self):
+        print("=== Test Suite: InterventionUtilsTestCase ===")
+        self.config, self.tokenizer, self.gpt2 = create_gpt2_lm(
+            config=GPT2Config(
+                n_embd=24,
+                attn_pdrop=0.0,
+                embd_pdrop=0.0,
+                resid_pdrop=0.0,
+                summary_first_dropout=0.0,
+                n_layer=4,
+                bos_token_id=0,
+                eos_token_id=0,
+                n_positions=128,
+                vocab_size=10,
+            )
+        )
+        self.test_output_dir_prefix = "test_tmp_output"
+        self.test_output_dir_pool = []
+        
+    def test_initialization_positive(self):
+        config = IntervenableConfig(
+            model_type=type(self.gpt2),
+            representations=[
+                RepresentationConfig(
+                    0,
+                    "block_output",
+                    "pos",
+                    1,
+                ),
+                RepresentationConfig(
+                    1,
+                    "block_output",
+                    "pos",
+                    1,
+                ),
+            ],
+            intervention_types=VanillaIntervention,
+        )
+
+        intervenable = IntervenableModel(config, self.gpt2)
+
+        assert intervenable.mode == "parallel"
+        self.assertTrue(intervenable.is_model_stateless)
+        assert intervenable.use_fast == False
+
+        assert len(intervenable.interventions) == 2
+        key_list = []
+        counter = 0
+        for k, _ in intervenable.interventions.items():
+            assert "#" in k
+            assert int(k.split("#")[-1]) <= counter
+            counter += 1
+            assert "block_output" in k
+
+        assert len(intervenable._intervention_group) == 2
+        assert len(intervenable._key_getter_call_counter) == 2
+        assert len(intervenable._key_setter_call_counter) == 2
+        assert len(intervenable.activations) == 0
+        assert len(intervenable.hot_activations) == 0
+        assert len(intervenable._batched_setter_activation_select) == 0
+
+    def test_local_non_trainable_save_positive(self):
+        config = IntervenableConfig(
+            model_type=type(self.gpt2),
+            representations=[
+                RepresentationConfig(
+                    0,
+                    "block_output",
+                    "pos",
+                    1,
+                ),
+                RepresentationConfig(
+                    1,
+                    "block_output",
+                    "pos",
+                    1,
+                ),
+            ],
+            intervention_types=VanillaIntervention,
+        )
+
+        intervenable = IntervenableModel(config, self.gpt2)
+        _uuid = str(uuid.uuid4())[:6]
+        _test_dir = os.path.join(f"./test_output_dir_prefix-{_uuid}")
+        self.test_output_dir_pool += [_test_dir]
+
+        intervenable.save(save_directory=_test_dir, save_to_hf_hub=False)
+
+        self.assertTrue(os.path.isfile(os.path.join(_test_dir, "config.json")))
+        for file in os.listdir(_test_dir):
+            if file.endswith(".bin"):
+                raise ValueError(
+                    "For non-trainable interventions, "
+                    "there should not be any model binary file!"
+                )
+
+    def test_local_trainable_save_positive(self):
+        config = IntervenableConfig(
+            model_type=type(self.gpt2),
+            representations=[
+                RepresentationConfig(
+                    0,
+                    "block_output",
+                    "pos",
+                    1,
+                ),
+                RepresentationConfig(
+                    1,
+                    "block_output",
+                    "pos",
+                    1,
+                ),
+            ],
+            intervention_types=RotatedSpaceIntervention,
+        )
+
+        intervenable = IntervenableModel(config, self.gpt2)
+        _uuid = str(uuid.uuid4())[:6]
+        _test_dir = os.path.join(f"./test_output_dir_prefix-{_uuid}")
+        self.test_output_dir_pool += [_test_dir]
+
+        intervenable.save(save_directory=_test_dir, save_to_hf_hub=False)
+
+        self.assertTrue(os.path.isfile(os.path.join(_test_dir, "config.json")))
+        binary_count = 0
+        for file in os.listdir(_test_dir):
+            if file.endswith(".bin"):
+                binary_count += 1
+        if binary_count != 2:
+            raise ValueError(
+                "For trainable interventions, "
+                "there should binary file for each of them."
+            )
+
+    def _test_local_trainable_load_positive(self, intervention_types):
+        b_s = 10
+
+        config = IntervenableConfig(
+            model_type=type(self.gpt2),
+            representations=[
+                RepresentationConfig(
+                    0, "block_output", "pos", 1, low_rank_dimension=4
+                ),
+                RepresentationConfig(
+                    1, "block_output", "pos", 1, low_rank_dimension=4
+                ),
+            ],
+            intervention_types=intervention_types,
+        )
+
+        intervenable = IntervenableModel(config, self.gpt2)
+        _uuid = str(uuid.uuid4())[:6]
+        _test_dir = os.path.join(f"./test_output_dir_prefix-{_uuid}")
+        self.test_output_dir_pool += [_test_dir]
+
+        intervenable.save(save_directory=_test_dir, save_to_hf_hub=False)
+
+        loaded = IntervenableModel.load(
+            load_directory=_test_dir,
+            model=self.gpt2,
+        )
+
+        assert intervenable != loaded
+
+        base = {"input_ids": torch.randint(0, 10, (b_s, 10))}
+        source = {"input_ids": torch.randint(0, 10, (b_s, 10))}
+
+        _, counterfactual_outputs_unsaved = intervenable(
+            base, [source, source], {"sources->base": ([[[3]], [[4]]], [[[3]], [[4]]])}
+        )
+
+        _, counterfactual_outputs_loaded = loaded(
+            base, [source, source], {"sources->base": ([[[3]], [[4]]], [[[3]], [[4]]])}
+        )
+
+        torch.equal(counterfactual_outputs_unsaved[0], counterfactual_outputs_loaded[0])
+
+    def test_local_load_positive(self):
+        self._test_local_trainable_load_positive(VanillaIntervention)
+        self._test_local_trainable_load_positive(RotatedSpaceIntervention)
+        self._test_local_trainable_load_positive(LowRankRotatedSpaceIntervention)
+        
     def test_vanilla_intervention_positive(self):
         intervention = VanillaIntervention(embed_dim=2)
         base = torch.arange(36).view(2, 3, 6)
@@ -176,107 +360,121 @@ def test_brs_intervention_positive(self):
         self.assertTrue(torch.allclose(golden, output))
 
     def test_brs_gradient_positive(self):
-        intervention = BoundlessRotatedSpaceIntervention(embed_dim=6)
-        intervention.temperature = torch.nn.Parameter(torch.tensor(2.0))
-        base = torch.arange(12).float().view(2, 6)
-        source = torch.arange(12, 24).float().view(2, 6)
+        
+        _retry = 10
+        while _retry > 0:
+            try:
+                intervention = BoundlessRotatedSpaceIntervention(embed_dim=6)
+                intervention.temperature = torch.nn.Parameter(torch.tensor(2.0))
+                base = torch.arange(12).float().view(2, 6)
+                source = torch.arange(12, 24).float().view(2, 6)
 
-        optimizer_params = []
-        optimizer_params += [{"params": intervention.rotate_layer.parameters()}]
-        optimizer_params += [{"params": intervention.intervention_boundaries}]
-        optimizer = torch.optim.Adam(optimizer_params, lr=1e-1)
+                optimizer_params = []
+                optimizer_params += [{"params": intervention.rotate_layer.parameters()}]
+                optimizer_params += [{"params": intervention.intervention_boundaries}]
+                optimizer = torch.optim.Adam(optimizer_params, lr=1e-1)
 
-        golden = torch.tensor([[5, 6, 7, 8, 9, 10], [11, 12, 13, 14, 15, 16],]).float()
+                golden = torch.tensor([[5, 6, 7, 8, 9, 10], [11, 12, 13, 14, 15, 16],]).float()
 
-        for _ in range(1000):
-            optimizer.zero_grad()
-            output = intervention(base, source)
-            loss = F.mse_loss(output, golden)
-            loss.backward()
-            optimizer.step()
-        self.assertTrue(torch.allclose(golden, output, rtol=1e-02, atol=1e-02))
+                for _ in range(1000):
+                    optimizer.zero_grad()
+                    output = intervention(base, source)
+                    loss = F.mse_loss(output, golden)
+                    loss.backward()
+                    optimizer.step()
+                self.assertTrue(torch.allclose(golden, output, rtol=1e-02, atol=1e-02))
+            except:
+                pass  # retry
+            finally:
+                break
+            _retry -= 1
+        if _retry > 0:
+            pass  # succeed
+        else:
+            raise AssertionError(
+                "test_brs_gradient_positive with retries"
+            )
+        
 
     def test_sigmoid_mask_gradient_positive(self):
-        intervention = SigmoidMaskIntervention(embed_dim=6)
-        base = torch.arange(12).float().view(2, 6)
-        source = torch.arange(12, 24).float().view(2, 6)
+        
+        _retry = 10
+        while _retry > 0:
+            try:
+                intervention = SigmoidMaskIntervention(embed_dim=6)
+                base = torch.arange(12).float().view(2, 6)
+                source = torch.arange(12, 24).float().view(2, 6)
 
-        optimizer_params = []
-        optimizer_params += [{"params": intervention.mask}]
-        optimizer_params += [{"params": intervention.temperature}]
-        optimizer = torch.optim.Adam(optimizer_params, lr=1e-1)
+                optimizer_params = []
+                optimizer_params += [{"params": intervention.mask}]
+                optimizer_params += [{"params": intervention.temperature}]
+                optimizer = torch.optim.Adam(optimizer_params, lr=1e-1)
 
-        golden = torch.tensor([[0, 1, 14, 15, 16, 17], [6, 7, 20, 21, 22, 23],]).float()
+                golden = torch.tensor([[0, 1, 14, 15, 16, 17], [6, 7, 20, 21, 22, 23],]).float()
 
-        for _ in range(2000):
-            optimizer.zero_grad()
-            output = intervention(base, source)
-            loss = F.mse_loss(output, golden)
-            loss.backward()
-            optimizer.step()
-        res = torch.sigmoid(intervention.mask)
-        self.assertTrue(
-            torch.allclose(res, torch.tensor([0.0, 0.0, 1.0, 1.0, 1.0, 1.0]))
-        )
+                for _ in range(2000):
+                    optimizer.zero_grad()
+                    output = intervention(base, source)
+                    loss = F.mse_loss(output, golden)
+                    loss.backward()
+                    optimizer.step()
+                res = torch.sigmoid(intervention.mask)
+                self.assertTrue(
+                    torch.allclose(res, torch.tensor([0.0, 0.0, 1.0, 1.0, 1.0, 1.0]))
+                )
+            except:
+                pass  # retry
+            finally:
+                break
+            _retry -= 1
+        if _retry > 0:
+            pass  # succeed
+        else:
+            raise AssertionError(
+                "test_sigmoid_mask_gradient_positive with retries"
+            )
+        
 
     def test_low_rank_gradient_positive(self):
-        intervention = LowRankRotatedSpaceIntervention(
-            embed_dim=6, low_rank_dimension=1
-        )
-        base = torch.arange(12).float().view(2, 6)
-        source = torch.arange(12, 24).float().view(2, 6)
+        
+        _retry = 10
+        while _retry > 0:
+            try:
+                intervention = LowRankRotatedSpaceIntervention(
+                    embed_dim=6, low_rank_dimension=1
+                )
+                base = torch.arange(12).float().view(2, 6)
+                source = torch.arange(12, 24).float().view(2, 6)
 
-        optimizer_params = []
-        optimizer_params += [{"params": intervention.rotate_layer.parameters()}]
-        optimizer = torch.optim.Adam(optimizer_params, lr=1e-1)
+                optimizer_params = []
+                optimizer_params += [{"params": intervention.rotate_layer.parameters()}]
+                optimizer = torch.optim.Adam(optimizer_params, lr=1e-1)
 
-        golden = torch.tensor([[0, 1, 14, 15, 16, 17], [6, 7, 20, 21, 22, 23],]).float()
+                golden = torch.tensor([[0, 1, 14, 15, 16, 17], [6, 7, 20, 21, 22, 23],]).float()
 
-        for _ in range(2000):
-            optimizer.zero_grad()
-            output = intervention(base, source)
-            loss = F.mse_loss(output, golden)
-            loss.backward()
-            optimizer.step()
-        print(output)
-        self.assertTrue(torch.allclose(golden, output, rtol=1e-02, atol=1e-02))
-
-
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(
-        InterventionUtilsTestCase("test_vanilla_intervention_subspace_positive")
-    )
-    suite.addTest(InterventionUtilsTestCase("test_vanilla_intervention_positive"))
-    suite.addTest(InterventionUtilsTestCase("test_vanilla_intervention_negative"))
-    suite.addTest(
-        InterventionUtilsTestCase(
-            "test_vanilla_intervention_subspace_partition_positive"
-        )
-    )
-    suite.addTest(
-        InterventionUtilsTestCase("test_vanilla_intervention_broadcast_positive")
-    )
-    suite.addTest(
-        InterventionUtilsTestCase("test_vanilla_intervention_subspace_negative")
-    )
-    suite.addTest(
-        InterventionUtilsTestCase(
-            "test_vanilla_intervention_subspace_partition_negative"
-        )
-    )
-    suite.addTest(InterventionUtilsTestCase("test_vanilla_intervention_fast_positive"))
-    suite.addTest(InterventionUtilsTestCase("test_collect_intervention_positive"))
-    suite.addTest(InterventionUtilsTestCase("test_collect_intervention_negative"))
-    suite.addTest(InterventionUtilsTestCase("test_brs_intervention_positive"))
-    suite.addTest(InterventionUtilsTestCase("test_brs_gradient_positive"))
-    suite.addTest(InterventionUtilsTestCase("test_sigmoid_mask_gradient_positive"))
-    suite.addTest(InterventionUtilsTestCase("test_low_rank_gradient_positive"))
-
-    # TODO: Add tests to other interventions
-    return suite
-
-
-if __name__ == "__main__":
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
+                for _ in range(2000):
+                    optimizer.zero_grad()
+                    output = intervention(base, source)
+                    loss = F.mse_loss(output, golden)
+                    loss.backward()
+                    optimizer.step()
+                print(output)
+                self.assertTrue(torch.allclose(golden, output, rtol=1e-02, atol=1e-02))
+            except:
+                pass  # retry
+            finally:
+                break
+            _retry -= 1
+        if _retry > 0:
+            pass  # succeed
+        else:
+            raise AssertionError(
+                "test_sigmoid_mask_gradient_positive with retries"
+            )
+
+    @classmethod
+    def tearDownClass(self):
+        for current_dir in self.test_output_dir_pool:
+            print(f"Removing testing dir {current_dir}")
+            if os.path.exists(current_dir) and os.path.isdir(current_dir):
+                shutil.rmtree(current_dir)