psaiops 0.0.15__tar.gz → 0.0.17__tar.gz

{psaiops-0.0.15 → psaiops-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: psaiops
-Version: 0.0.15
+Version: 0.0.17
 Summary: Web apps to inspect & engineer NN activations.
 License: .github/LICENSE.md
 Author: apehex

{psaiops-0.0.15 → psaiops-0.0.17}/psaiops/score/attention/app.py

@@ -9,7 +9,7 @@ import psaiops.score.attention.lib
 # META #########################################################################
 
 TITLE = '''Attention Scoring'''
-INTRO = '''Score each token according to the weights of the attention layers.\nThe model is fixed to "openai/gpt-oss-20b" for now.'''
+INTRO = '''Score each token according to the weights of the attention layers. The model is fixed to "openai/gpt-oss-20b" for now.'''
 STYLE = '''.white-text span { color: white; }'''
 
 MODEL = 'openai/gpt-oss-20b'
@@ -78,7 +78,7 @@ def create_outputs_block() -> dict:
 
 def create_actions_block() -> dict:
     __process = gradio.Button('Process', variant='primary', size='lg', scale=1, interactive=True)
-    __position = gradio.Slider(label='Position', value=-1, minimum=-1, maximum=128, step=1, scale=1, interactive=True) # info='-1 to average on all tokens'
+    __position = gradio.Slider(label='Position', value=-1, minimum=-1, maximum=15, step=1, scale=1, interactive=True) # info='-1 to average on all tokens'
     return {
         'process_block': __process,
         'position_block': __position}
@@ -121,8 +121,8 @@ def create_layout(intro: str=INTRO) -> dict:
 def update_layer_range(value: float, model: str) -> dict:
     return gradio.update(maximum=35, value=min(35, int(value))) if '120b' in model else gradio.update(maximum=23, value=min(23, int(value)))
 
-def update_position_range(value: float, tokens: list) -> dict:
-    return gradio.update(maximum=len(tokens) - 1, value=min(len(tokens) - 1, int(value)))
+def update_position_range(value: float, tokens: float) -> dict:
+    return gradio.update(maximum=int(tokens) - 1, value=min(int(tokens) - 1, int(value)))
 
 def update_computation_state(
     token_num: float,
@@ -140,11 +140,14 @@ def update_computation_state(
     __token_num = max(1, min(128, int(token_num)))
     __topk_num = max(1, min(8, int(topk_num)))
     __topp_num = max(0.0, min(1.0, float(topp_num)))
-    __token_idx = max(0, min(__token_num, int(token_idx)))
-    __layer_idx = max(0, int(layer_idx))
-    __head_idx = max(0, int(head_idx))
+    __token_idx = max(-1, min(__token_num, int(token_idx)))
+    __layer_idx = max(-1, int(layer_idx))
+    __head_idx = max(-1, int(head_idx))
     __prompt_str = prompt_str.strip()
     __device_str = device_str if (device_str in ['cpu', 'cuda']) else 'cpu'
+    # exit if some values are missing
+    if (not __prompt_str) or (model_obj is None) or (tokenizer_obj is None):
+        return ([], [], [], torch.empty(0))
     # handle all exceptions at once
     try:
         # dictionary {'input_ids': _, 'attention_mask': _}
@@ -183,14 +186,12 @@ def update_computation_state(
             token_obj=__output_data)
         # update each component => (input, output, attention, highligh) states
         return (
-            gradio.update(value=__tokens[:__input_dim]),
-            gradio.update(value=__tokens[__input_dim:]),
-            gradio.update(value=__attention_data),
-            gradio.update(value=list(zip(__tokens, __labels))))
+            list(zip(__tokens, __labels)),
+            __tokens[:__input_dim],
+            __tokens[__input_dim:],
+            __attention_data,)
     except:
         raise Exception('Attention generation aborted with an error.')
-    finally:
-        return (gradio.update(), gradio.update(), gradio.update(), gradio.update())
 
 def update_text_highlight(
     token_idx: float,
@@ -199,15 +200,16 @@ def update_text_highlight(
     input_data: list,
     output_data: list,
     attention_data: torch.Tensor,
-) -> dict:
+) -> list:
     # sanitize the inputs
     __input_data = input_data or []
     __output_data = output_data or []
-    __attention_data = attention_data or torch.empty(0)
+    __attention_data = torch.empty(0) if (attention_data is None) else attention_data
     __input_dim = len(__input_data)
-    __token_idx = max(0, min(__input_dim, int(token_idx)))
-    __layer_idx = max(0, int(layer_idx))
-    __head_idx = max(0, int(head_idx))
+    __output_dim = len(__output_data)
+    __token_idx = max(-1, min(__output_dim, int(token_idx)))
+    __layer_idx = max(-1, int(layer_idx))
+    __head_idx = max(-1, int(head_idx))
     # exit if the data has not yet been computed
     if (not __input_data) or (not __output_data) or (attention_data is None) or (len(attention_data) == 0):
         return gradio.update()
@@ -228,11 +230,9 @@ def update_text_highlight(
             input_dim=__input_dim,
             token_idx=__token_idx)
         # update the component with [(token, label), ...]
-        return gradio.update(value=list(zip(__tokens, __labels)))
+        return list(zip(__tokens, __labels))
     except:
         raise Exception('Attention reduction aborted with an error.')
-    finally:
-        return gradio.update()
 
 # APP ##########################################################################
 
@@ -249,26 +249,23 @@ def create_app(title: str=TITLE, intro: str=INTRO, style: str=STYLE, model: str=
         __fields.update(create_layout(intro=intro))
         # init the state
         __fields.update(create_state())
-        # fetch the relevant fields
-        __button_block, __position_block, __output_block = (__fields['process_block'], __fields['position_block'], __fields['output_block'])
-        __output_state, __attention_state = (__fields['output_state'], __fields['attention_state'])
         # wire the input fields
-        __button_block.click(
+        __fields['process_block'].click(
             fn=__compute,
             inputs=[__fields[__k] for __k in ['tokens_block', 'topk_block', 'topp_block', 'position_block', 'layer_block', 'head_block', 'input_block']],
-            outputs=[__fields[__k] for __k in ['input_state', 'output_state', 'attention_state', 'output_block']],
+            outputs=[__fields[__k] for __k in ['output_block', 'input_state', 'output_state', 'attention_state']],
             queue=False,
             show_progress='full')
-        __output_state.change(
+        __fields['tokens_block'].change(
             fn=update_position_range,
-            inputs=[__position_block, __output_state],
-            outputs=__position_block,
+            inputs=[__fields[__k] for __k in ['position_block', 'tokens_block']],
+            outputs=__fields['position_block'],
             queue=False,
             show_progress='hidden')
-        __position_block.change(
+        __fields['position_block'].change(
             fn=update_text_highlight,
             inputs=[__fields[__k] for __k in ['position_block', 'layer_block', 'head_block', 'input_state', 'output_state', 'attention_state']],
-            outputs=__output_block,
+            outputs=__fields['output_block'],
             queue=False,
             show_progress='hidden')
         # gradio application

{psaiops-0.0.15 → psaiops-0.0.17}/psaiops/score/attention/lib.py

@@ -119,7 +119,7 @@ def postprocess_attention_scores(
     __output_range = list(range(__output_dim - input_dim)) if (__token_idx < 0) else [__token_idx]
     __output_mask = torch.BoolTensor([__i in __output_range for __i in range(__output_dim - input_dim)])
     # normalize the scores
-    __input_scores = attention_data[__input_slice] / (attention_data[__input_slice].sum() + 1e-5)
+    __input_scores = attention_data[__input_slice] / (attention_data[__input_slice].mean() + 1e-5)
     # round to obtain integer labels from 0 to 100
     __input_scores = torch.round(100.0 * __input_scores, decimals=0).type(torch.int32)
     # the generated tokens are not scored

{psaiops-0.0.15 → psaiops-0.0.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "psaiops"
-version = "0.0.15"
+version = "0.0.17"
 description = "Web apps to inspect & engineer NN activations."
 license = ".github/LICENSE.md"
 readme = ".github/README.md"