reflexive 2.0.0__tar.gz → 2.2.0__tar.gz

{reflexive-2.0.0 → reflexive-2.2.0}/.gitignore

@@ -170,3 +170,6 @@ cython_debug/
 # PyPI configuration file
 .pypirc
 *.DS_Store
+tests/data/*
+tests/annotated*
+tests/*.pkl

{reflexive-2.0.0 → reflexive-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflexive
-Version: 2.0.0
+Version: 2.2.0
 Summary: Supports AWS Reflexive Expressions Systems (RES) Analysis
 Project-URL: Repository, https://github.com/nlytx/reflexive.git
 Author-email: Andrew Gibson <andrew@nlytx.io>

{reflexive-2.0.0 → reflexive-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reflexive"
-version = "2.0.0"
+version = "2.2.0"
 description = "Supports AWS Reflexive Expressions Systems (RES) Analysis"
 authors = [{name = "Andrew Gibson", email = "andrew@nlytx.io"}]
 readme = "README.md"

{reflexive-2.0.0 → reflexive-2.2.0}/src/reflexive/analysis_functions.py

@@ -7,7 +7,10 @@ from functools import partial
 import tarfile
 import json
 import os
-import numpy as np
+from numpy import (
+    asarray,
+    dot
+)
 from numpy.linalg import norm
 from itertools import chain
 from graph_tool.all import (
@@ -15,6 +18,7 @@ from graph_tool.all import (
     similarity,
     adjacency)
 
+
 ### PIPELINE FUNCTIONS
 
 # Clean text using supplied function and calculate text length
@@ -99,9 +103,15 @@ def _add_res_weights(df):
     temp_df['res_weights'] = temp_df.res_interactions.apply(_calc_res_weights)
     return temp_df
 
+def _add_semantic_weights(df,ranking_factors={}):
+    temp_df = df.copy()
+    ranks = partial(_calc_semantic_weights,factors=ranking_factors)
+    temp_df['semantic_weights'] = temp_df.res_weights.apply(ranks)
+    return temp_df
+
 def _add_res_adj_matrix(df):
     temp_df = df.copy()
-    temp_df['res_adj_matrix'] = temp_df.res_weights.apply(_create_adj_matrix)
+    temp_df['res_adj_matrix'] = temp_df.semantic_weights.apply(_create_adj_matrix)
     return temp_df
 
 def _get_res_sequence(offsets_clean):
@@ -134,6 +144,16 @@ def _calc_res_weights(interactions:dict[tuple,int])->dict[tuple,float]:
     for edge,count in interactions.items():
         weights[edge] = round(count/(max_count),2)
     return weights
+
+
+
+def _calc_semantic_weights(weights:dict[tuple,float], factors:dict[tuple,float]={})->dict[tuple,float]:
+    if not factors:
+        return weights
+    else:
+        for edge,w in weights.items():
+            weights[edge] = factors[edge] * w
+        return weights
         
 
 def _create_adj_matrix(weights:dict[tuple,float])->list[list[float]]:
@@ -149,7 +169,7 @@ def _create_adj_matrix(weights:dict[tuple,float])->list[list[float]]:
         matrix.append(row)
     return matrix
 
-### GRAPH ANALYSIS
+### SIMILARITY ANALYSIS
 
 def _jaccard_similarity(g1:Graph,g2:Graph)->float:
     return similarity(g1, g2, 
@@ -157,10 +177,67 @@ def _jaccard_similarity(g1:Graph,g2:Graph)->float:
                       #label1=g1.vp['v_labels'], label2=g2.vp['v_labels'], 
                       norm=True, p=1.0, distance=False, asymmetric=False)
     
-def _cosine_similarity(m1,m2)->float:
-    v1 = list(chain.from_iterable(m1))
-    v2 = list(chain.from_iterable(m2))
-    return np.dot(v1,v2)/(norm(v1)*norm(v2))
+# def _cosine_similarity(m1,m2)->float:
+#     v1 = list(chain.from_iterable(m1))
+#     v2 = list(chain.from_iterable(m2))
+#     return np.dot(v1,v2)/(norm(v1)*norm(v2))
+
+def _vectorise_adj(matrix):
+    return list(chain.from_iterable((matrix[i][j] for j in range(i,5)) for i in range(5)))
+    
+def zero_pos(am):
+    nm = []
+    for r,row in enumerate(am):
+        nr = []
+        for c,weight in enumerate(row):
+            if r < 3 or c < 3:
+                nr.append(weight)
+            else:
+                nr.append(0)
+        nm.append(nr)
+    return nm
+
+def zero_mod(am):
+    nm = []
+    for r,row in enumerate(am):
+        nr = []
+        for c,weight in enumerate(row):
+            if r >= 3 or c >= 3:
+                nr.append(weight)
+            else:
+                nr.append(0)
+        nm.append(nr)
+    return nm
+
+def _adj_vector(adj_matrix):
+    return _vectorise_adj(adj_matrix)
+    
+def _positional_vector(adj_matrix):
+    return _vectorise_adj(zero_pos(adj_matrix))
+    
+def _modal_vector(adj_matrix):
+    return _vectorise_adj(zero_mod(adj_matrix))
+
+def _cosine(A,B):
+    return dot(A,B)/(norm(A)*norm(B))
+        
+def _am4idx(df,idx:int):
+    return df.res_adj_matrix[idx]
+
+def _similarity(m1,m2,vector_func):
+    return float(_cosine(vector_func(m1),vector_func(m2)))
+
+def _res_similarity(df,idx1,idx2,vector_func):
+    return _similarity(_am4idx(df,idx1),_am4idx(df,idx2),vector_func)
+
+_interaction_similarity = partial(_res_similarity,vector_func=_adj_vector)
+_positional_similarity = partial(_res_similarity,vector_func=_positional_vector)
+_modal_similarity = partial(_res_similarity,vector_func=_modal_vector)
+
+def _similarities(df,idx1,idx2):
+    return {"interaction": _interaction_similarity(df,idx1,idx2),
+            "positional": _positional_similarity(df,idx1,idx2),
+            "modal":_modal_similarity(df,idx1,idx2)}
 
     
 

{reflexive-2.0.0 → reflexive-2.2.0}/src/reflexive/res_analysis.py

@@ -20,9 +20,10 @@ from reflexive.analysis_functions import (
     _add_res_sequence,
     _add_res_interactions,
     _add_res_weights,
+    _add_semantic_weights,
     _add_res_adj_matrix,
     _jaccard_similarity,
-    _cosine_similarity,
+    _similarities,
     _date_string,
     _create_local_dir   
 )
@@ -39,6 +40,12 @@ class RES_analyser:
     config:dict
     
     logger = logging.getLogger(__name__)
+    
+    ranking_factors = {('RR','RR'):0.5, ('NR','RR'):0.9, ('AR','RR'):0.9, ('AF','RR'):0.8, ('EP','RR'):0.7,  #Alpha sorted tuples
+                        ('NR','NR'):0.6, ('AR','NR'):1.0, ('AF','NR'):0.8, ('EP','NR'):0.7, 
+                        ('AR','AR'):0.6, ('AF','AR'):0.8, ('AR','EP'):0.7, 
+                        ('AF','AF'):0.5, ('AF','EP'):0.6, 
+                        ('EP','EP'):0.5}
 
     
     def __init__(self,parameters,prefix="res",postfix=None,dir="/data/")->None:
@@ -113,15 +120,20 @@ class RES_analyser:
         df = _add_res_sequence(df)
         df = _add_res_interactions(df)
         df = _add_res_weights(df)
+        df = _add_semantic_weights(df,self.ranking_factors)
         df = _add_res_adj_matrix(df)
         return df
+    
+    # def add_semantic_weights(self,df):
+    #     return _add_semantic_weights(df,self.ranking_factors)
 
     # Graph Jaccard Similarity
     def get_jaccard_similarity(self,g1,g2):
         return _jaccard_similarity(g1,g2)
     
-    def get_cosine_similarity(self,m1,m2):
-        return _cosine_similarity(m1,m2)
+    def get_cosine_similarities(self,df,idx1,idx2):
+        return _similarities(df,idx1,idx2)
+    
     
     ############################################################
     # UTILITY METHODS