biomQuant 0.0.1__tar.gz

biomquant-0.0.1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mjolnir2307
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

biomquant-0.0.1/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: biomQuant
+Version: 0.0.1
+Summary: A package consisting of evaluation measures for gesture biometric quantification.
+Home-page: https://github.com/Mjolnir2307/measurementSuite
+Author: Mjolnir2307
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: summary
+
+# biomQuant
+
+A package consisting of evaluation measures for gesture biometric quantification.
+
+This package provide four measures:
+
+1. Rank deviation ($\hat{r}$)
+2. Relevance ($\mathcal{R}$)
+3. Trend match distance ($\Psi$)
+4. ICGD Score ($C_d$)
+
+We combine these in advanced acceptance score
+
+${A_r}^*~=~\frac{\sum_{j=1}^{G}\Bigl( \frac{2^{\lambda\mathcal{R}_j}}{\exp(\kappa*(r_{j}^{\Delta} - r_{j}^{\hat{e}} ))}\Bigr)}{\sqrt{\log_2(2+\nu\Psi)}}*{\exp(-\beta C_d)}$
+
+Here, $G$ is the number of gestures. While $r_{j}^{\Delta}$ and $r_{j}^{\hat{e}}$ denote ranks of the $j^{th}$ gesture wrt the estimated biometric estimates and the ground truth respectively. $\lambda,~\kappa,~\nu,~\text{and}~\beta$ are the scaling factors.
+
+We further normalize this into $nA_r^*(\Delta)$. Mathematically, 
+
+$nA_r^*(\Delta)=\frac{A_r^{*}(\Delta)}{A_r^{*}(\hat{e})}$
+
+Where, $A_r^*(\Delta)$ and $A_r^*(\hat{e})$ represents $A_r^*$ values for the output DGBQA scores and ground truth, i.e.,
+
+$A_r^*(\hat{e})=\sum_{j=1}^{G}2^{\lambda \Bigl[ \gamma\Bigl({\frac{G-{r_{j}^{\hat{e}}}+1}{G}\Bigr){\hat{e}\left[r_{j}^{\hat{e}}\right]}}+\Bigl(\frac{r_{j}^{\hat{e}}}{G}\Bigr)\Bigl(1-\hat{e}\left[r_{j}^{\hat{e}}\right]\Bigr) \Bigr]}$
+
+## Requirements
+
+1. numpy
+2. sckit-learn
+3. scipy
+4. tensorflow $\geq$ 2.8.0
+
+## How to use
+
+1. Advanced Acceptance Score
+
+```python
+from biomQaunt.advancedAcceptance import comp_advancedAcceptance
+nAr_star = comp_advancedAcceptance(biometricParams,
+                                   groundTruth,
+                                   embeddings,
+                                   labels,
+                                   G=numGestures)
+```
+
+2. Rank deviation
+
+```python
+from biomQaunt.rankDev import rankDev
+r_prime = rankDev(1-groundTruth,
+                  biometricParams,
+                  G=numGestures)
+```
+
+3. Relevance
+
+```python
+import numpy as np
+from biomQaunt.acceptanceScore import compAr
+
+def preProcess(inputVec):
+    inputVec = (inputVec - np.mean(inputVec))/np.std(inputVec)
+    return inputVec/np.linalg.norm(inputVec)
+
+relevance = compAr(preProcess(biometricParams),
+                   preProcess(groundTruth),
+                   normalizer=False,
+                   relevance=True)
+```
+
+4. ICGD score
+
+```python
+import tensorflow as tf
+from biomQaunt.icgd import compICGD
+
+def normalisation_layer(x):   
+    return(tf.math.l2_normalize(x, axis=1, epsilon=1e-12))
+
+embeddings = tf.keras.layers.Lambda(normalisation_layer)(embeddings)
+
+icgdScore = icgdScore(embeddings.numpy(),
+                     labels)
+```
+
+5. Trend match distance
+
+```python
+from biomQaunt.trendMatch import compTrendMatchDist
+psi = rankDev(biometricParams,
+              groundTruth,
+              G=numGestures)
+```

biomquant-0.0.1/README.md

@@ -0,0 +1,93 @@
+# biomQuant
+
+A package consisting of evaluation measures for gesture biometric quantification.
+
+This package provide four measures:
+
+1. Rank deviation ($\hat{r}$)
+2. Relevance ($\mathcal{R}$)
+3. Trend match distance ($\Psi$)
+4. ICGD Score ($C_d$)
+
+We combine these in advanced acceptance score
+
+${A_r}^*~=~\frac{\sum_{j=1}^{G}\Bigl( \frac{2^{\lambda\mathcal{R}_j}}{\exp(\kappa*(r_{j}^{\Delta} - r_{j}^{\hat{e}} ))}\Bigr)}{\sqrt{\log_2(2+\nu\Psi)}}*{\exp(-\beta C_d)}$
+
+Here, $G$ is the number of gestures. While $r_{j}^{\Delta}$ and $r_{j}^{\hat{e}}$ denote ranks of the $j^{th}$ gesture wrt the estimated biometric estimates and the ground truth respectively. $\lambda,~\kappa,~\nu,~\text{and}~\beta$ are the scaling factors.
+
+We further normalize this into $nA_r^*(\Delta)$. Mathematically, 
+
+$nA_r^*(\Delta)=\frac{A_r^{*}(\Delta)}{A_r^{*}(\hat{e})}$
+
+Where, $A_r^*(\Delta)$ and $A_r^*(\hat{e})$ represents $A_r^*$ values for the output DGBQA scores and ground truth, i.e.,
+
+$A_r^*(\hat{e})=\sum_{j=1}^{G}2^{\lambda \Bigl[ \gamma\Bigl({\frac{G-{r_{j}^{\hat{e}}}+1}{G}\Bigr){\hat{e}\left[r_{j}^{\hat{e}}\right]}}+\Bigl(\frac{r_{j}^{\hat{e}}}{G}\Bigr)\Bigl(1-\hat{e}\left[r_{j}^{\hat{e}}\right]\Bigr) \Bigr]}$
+
+## Requirements
+
+1. numpy
+2. sckit-learn
+3. scipy
+4. tensorflow $\geq$ 2.8.0
+
+## How to use
+
+1. Advanced Acceptance Score
+
+```python
+from biomQaunt.advancedAcceptance import comp_advancedAcceptance
+nAr_star = comp_advancedAcceptance(biometricParams,
+                                   groundTruth,
+                                   embeddings,
+                                   labels,
+                                   G=numGestures)
+```
+
+2. Rank deviation
+
+```python
+from biomQaunt.rankDev import rankDev
+r_prime = rankDev(1-groundTruth,
+                  biometricParams,
+                  G=numGestures)
+```
+
+3. Relevance
+
+```python
+import numpy as np
+from biomQaunt.acceptanceScore import compAr
+
+def preProcess(inputVec):
+    inputVec = (inputVec - np.mean(inputVec))/np.std(inputVec)
+    return inputVec/np.linalg.norm(inputVec)
+
+relevance = compAr(preProcess(biometricParams),
+                   preProcess(groundTruth),
+                   normalizer=False,
+                   relevance=True)
+```
+
+4. ICGD score
+
+```python
+import tensorflow as tf
+from biomQaunt.icgd import compICGD
+
+def normalisation_layer(x):   
+    return(tf.math.l2_normalize(x, axis=1, epsilon=1e-12))
+
+embeddings = tf.keras.layers.Lambda(normalisation_layer)(embeddings)
+
+icgdScore = icgdScore(embeddings.numpy(),
+                     labels)
+```
+
+5. Trend match distance
+
+```python
+from biomQaunt.trendMatch import compTrendMatchDist
+psi = rankDev(biometricParams,
+              groundTruth,
+              G=numGestures)
+```

biomquant-0.0.1/biomQuant/acceptanceScore.py

@@ -0,0 +1,118 @@
+######## Importing libraries
+import numpy as np
+
+###### Rank Computation
+def rank_compute_acc(rank_vector,val_to_rank):
+
+    """
+    Function to derive rank of a particular value
+
+    INPUTS:-
+    1) rank_vector: Sorted Vector in which ranking is to be performed
+    2) val_to_rank: Value whoose rank is to be derived
+
+    OUTPUTS:-
+    1) rank_val: Ranked Value - The best is rank '1', but we use index of '0' all along but just the Relevance Function
+    """
+    #rank_vector_sort = -np.sort(-rank_vector) # Sorting the Vector: The biggest value is the better-most value
+
+    for item_idx,item in enumerate(rank_vector): # Iterating over the vector
+        if(item == val_to_rank): # Match-Found
+            rank_val = item_idx # Rank Assignment 
+            break
+
+    return rank_val
+
+####### Acceptance Score
+def compAr(dgbqa,
+            e_prime,
+            G,
+            normalizer, 
+            relevance, 
+            lambda_scale=2,
+            kappa=1,
+            ):
+ 
+    """
+    Function to compute Acceptance Score: Sum over all Gestures(Relevance/Rank Deviation)
+
+    INPUTS:-
+    1) dgbqa: Array of unranked but normalized DGBQA score values
+    2) e_prime: Array of unranked but normalized (1 - EER) values
+    3) G: Total number of gestures considered for analysis
+    3) normalizer: If True, Ar for e_prime will be computed. Default value = False
+    4) relevance: If True, relevance value is reuturned. Default value = False 
+
+    OUTPUTS:-
+    1) Ar: Acceptance Score: Sum over all Gestures(Relevance/Rank Deviation)
+    """
+
+    ##### Defining Essentials
+    e_prime_sort = -(np.sort(-e_prime)) # Sorted e_prime
+    dgbqa_sort = -(np.sort(-dgbqa)) # Sorted DGBQA-Score Values
+    dgbqa_re = [] # DGBQA-Scores Ordered as per the e_prime_sort  
+    arrangement_idx = [] # List to store arrangement orders of e_prime, with the values starting from 0, and ending at G-1
+    Ar = 0 # Initializing Acceptance Value as zero
+    #lambda_scale = 2 # Scaling factor for relevance
+    gamma = 2 # Scaling Factor for the first term in relevance formulation
+    #kappa = 1  # Scaling Factor for the Rank-Deviation Penalty
+
+    if(normalizer == False): # Checking if the Ar is being estimated for the normalizer or not
+
+        ##### Aranging DGBQA Scores as per e_prime's order
+        for idx, val in enumerate(e_prime_sort):
+
+            for idx_search, val_search in enumerate(e_prime):
+
+                if(val == val_search):
+                    arrangement_idx.append(idx_search) # Finding Index on e_prime that matches with e_prime_sort
+                    dgbqa_re.append(dgbqa[idx_search]) # Appending terms in dgbqa_re as per the order in e_prime_sort: The best rank is the first term
+                    break
+
+            #print(arrangement_idx)
+
+        ##### Ar Estimation
+        for r_e_j, dgbqa_r_e_j in enumerate(dgbqa_re): # Iterating over all the gestures in the set
+
+            if(relevance == False):
+
+                #### Relevance Gain
+                R_j = gamma*((G-(r_e_j+1)+1)/G)*dgbqa_r_e_j + ((r_e_j+1)/G)*(1 - dgbqa_r_e_j)
+                R_j = 2**(lambda_scale*R_j)
+
+                #### Rank Deviation Penalty
+                ### Rank Computation
+                rank_dgbqa = rank_compute_acc(np.array(dgbqa_sort),dgbqa_r_e_j) # Rank Derived as per DGBQA-Score Estimates
+                rank_e_prime = rank_compute_acc(np.array(dgbqa_re),dgbqa_r_e_j) # Rank Derived as per e-prime-sort based sorting of DGBQA-Scores
+
+                ### Rank Deviation
+                rank_dev_j = np.exp(kappa*np.abs(rank_dgbqa - rank_e_prime)) 
+
+                #### Ar Estimate for the Current Gesture
+                Ar_j = R_j/rank_dev_j
+                Ar = Ar + Ar_j # Adding this to the Metric
+                #print(r_e_j,R_j,np.abs(rank_dgbqa - rank_e_prime),rank_dev_j,Ar_j)
+
+            else:
+
+                R_j = gamma*((G-(r_e_j+1)+1)/G)*dgbqa_r_e_j + ((r_e_j+1)/G)*(1 - dgbqa_r_e_j)
+                Ar = Ar + R_j # Adding this to the Metric
+
+        return Ar
+     
+    else:
+
+        ##### Ar Estimation
+        for r_e_j, eprime_r_e_j in enumerate(e_prime_sort): # Iterating over all the gestures in the set
+            
+            #### Relevance Gain
+            R_j = gamma*((G - (r_e_j+1)+1)/G)*eprime_r_e_j + ((r_e_j+1)/G)*(1 - eprime_r_e_j)
+            #print(r_e_j,R_j)
+            R_j = 2**(lambda_scale*R_j)
+            #print(r_e_j,R_j)
+
+            #### Ar Estimate for the Current Gesture
+            Ar_j = R_j
+            Ar = Ar + Ar_j # Adding this to the Metric
+
+        return Ar

biomquant-0.0.1/biomQuant/advancedAcceptance.py

@@ -0,0 +1,88 @@
+from rankDev import *
+from icgd import *
+from trendMatch import *
+from acceptanceScore import *
+
+def comp_advancedAcceptance(biomQuant,
+                            e_prime,
+                            embeddings,
+                            labels,
+                            beta=0.75,
+                            nu=1,
+                            kappa=1,
+                            lambdaVal=2,
+                            G=10,
+                            normalize=True
+                            ):
+    
+    """
+    Function to return normalized or vanilla advanced acceptance score
+
+    INPUTS:-
+    1) biomQaunt: Biometric characteristics corresponding to G gestures
+    2) e_prime: Ground truth scores for the G gestures
+    3) embeddings: Embeddings for ICGD score computation
+    4) labels: Gesture labels
+    5) beta: Scaling parameter for ICGD score
+    6) nu: Scaling parameter for trend match distance
+    7) kappa: Scaling parameter for rank deviation
+    8) lambdaVal: Scaling parameter for Relevance
+    9) G: Total number of gestures
+    10) normalize: If True, the nAr* is returned. Default: True
+
+    OUTPUTS:-
+    1) Ar*: Advanced acceptance score, normalized version.
+    """
+
+    def preProcess(inputVec):
+        inputVec = (inputVec - np.mean(inputVec))/np.std(inputVec)
+        return inputVec/np.linalg.norm(inputVec)
+    
+    biomQuant = preProcess(biomQuant)
+    e_prime = preProcess(e_prime)
+
+    Ar = compAr(biomQuant,
+                e_prime,
+                G,
+                normalizer=False,
+                relevance=False,
+                lambda_scale=lambdaVal,
+                kappa=kappa) # Acceptance score (relevance + rank deviation)
+
+    icgdScore = compICGD(embeddings,
+                         labels) # ICGD score
+    
+    psi = compTrendMatchDist(biomQuant,
+                             e_prime,
+                             G) # Trend match distance
+    
+    if normalize==False:
+        return Ar*((np.log2(2+nu*psi))**(-1/2))*np.exp(-beta*icgdScore)
+    
+    else:
+        Ar_max = compAr(biomQuant,
+                        e_prime,
+                        G,
+                        normalizer=True,
+                        relevance=False,
+                        lambda_scale=lambdaVal,
+                        kappa=kappa) # Ar(e_prime)
+        
+        return (Ar*((np.log2(2+nu*psi))**(-1/2))*np.exp(-beta*icgdScore))/(Ar_max)
+    
+
+
+if __name__ == "__main__":
+
+    biomQuant = np.random.normal(size=(11,))
+    e_prime = np.random.normal(size=(11,))
+
+    embeddings = np.random.normal(size=(100,32))
+    labels = np.random.randint(low=0,high=10,size=(100,))
+
+    print(comp_advancedAcceptance(biomQuant,
+                                  e_prime,
+                                  embeddings,
+                                  labels))
+    
+

biomquant-0.0.1/biomQuant/icgd.py

@@ -0,0 +1,75 @@
+######## Importing libraries
+import numpy as np
+import tensorflow as tf
+
+###### CGID and Decorrelated-CGID Score
+
+##### Mask Generation
+#### Positive Mask
+def get_positive_mask(labels):
+        """
+        Return a 2D mask where mask[a, p] is True iff a and p are distinct and have same label.
+        Args:
+            labels: tf.int32 `Tensor` with shape [batch_size]
+        Returns:
+            mask: tf.bool `Tensor` with shape [batch_size, batch_size]
+        """
+        # Check that i and j are distinct
+        indices_equal = tf.cast(tf.eye(labels.shape[0]), tf.bool)
+        indices_not_equal = tf.logical_not(indices_equal)
+
+        # Check if labels[i] == labels[j]
+        # Uses broadcasting where the 1st argument has shape (1, batch_size) and the 2nd (batch_size, 1)
+        labels_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))
+
+        # Combine the two masks``
+        mask = tf.logical_and(indices_not_equal, labels_equal)
+
+        return mask
+    
+###### Negative Mask - Different Mask
+def get_negative_mask(labels):
+    """Return a 2D mask where mask[a, n] is True iff a and n have distinct labels.
+    Args:
+        labels: tf.int32 `Tensor` with shape [batch_size]
+    Returns:
+        mask: tf.bool `Tensor` with shape [batch_size, batch_size]
+    """
+    # Check if labels[i] != labels[k]
+    # Uses broadcasting where the 1st argument has shape (1, batch_size) and the 2nd (batch_size, 1)
+    labels_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))
+
+    mask = tf.logical_not(labels_equal)
+
+    return mask
+
+####### ICGD
+def compICGD(f_theta,y_hgr):
+      
+    """
+    Function to compute ICGD score
+          
+    INPUTS:-
+    1) f_theta: Embeddings of the shape (N,d); N-Total Examples, d: Embedding Dimensions
+    2) y_hgr: HGR labels of the shape (N,)
+    
+    OUTPUTS:-
+    1) icgdScore: Average of masked gram matrix
+    """
+
+    ##### L2-Normalization
+    f_theta = tf.math.l2_normalize(f_theta,axis=1)
+
+    ##### Different Gesture Mask Computation
+    delta_bar = get_negative_mask(y_hgr)
+    delta_bar = np.reshape(delta_bar.numpy(),(delta_bar.shape[0],delta_bar.shape[1]))
+
+    ##### Gramian Matrix Formation
+    G_bar = tf.cast(tf.linalg.matmul(f_theta,f_theta,transpose_b=True),dtype=tf.float32)
+    cgid_score_matrix = np.multiply(delta_bar,G_bar.numpy())
+    cgid_score_matrix_mask = (cgid_score_matrix >= 0)
+    #plot_heatmap(cgid_score_matrix*cgid_score_matrix_mask,filepath)
+
+    ##### CGID-Score
+    icgdScore = (np.sum(cgid_score_matrix*cgid_score_matrix_mask))/(np.sum(cgid_score_matrix_mask))
+    return icgdScore

biomquant-0.0.1/biomQuant/rankDev.py

@@ -0,0 +1,62 @@
+######## Importing libraries                                                                                         
+import numpy as np
+
+####### Rank-Deviation
+###### Rank Derivation
+def rank_compute(rank_vector,val_to_rank,reverse_flag):
+
+    """
+    Function to derive rank of a particular value
+
+    INPUTS:-
+    1) rank_vector: Vector in which ranking is to be performed
+    2) val_to_rank: Value whoose rank is to be derived
+    3) reverse_flag: Flag to signify if the order of sort is to be reversed
+
+    OUTPUTS:-
+    1) rank_val: Ranked Value - The best is rank '0'
+    """ 
+
+    if(reverse_flag == True):
+        rank_vector_sort = -(np.sort(-rank_vector))
+    else:
+        rank_vector_sort = np.sort(rank_vector) # Sorting the Vector    
+    for item_idx,item in enumerate(rank_vector_sort): # Iterating over the vector
+        if(item == val_to_rank): # Match-Found
+            rank_val = item_idx # Rank Assignment 
+            break
+
+    return rank_val
+
+###### Avg. Rank Deviation
+def rankDev(eer_vec,dgbqa_vec,G_Total):
+    
+    """
+    Computation of average rank deviation
+    
+    INPUTS:-
+    1) eer_vec: Vector of EER values
+    2) dgbqa_vec: Vector of DGBQA values
+    3) G_Total: Total gestures in the vector
+    
+    OUTPUTS:-
+    1) avg_rank_deviation: Total Deviation in Rank/Total Number of Gestures
+    """
+    
+    rank_deviation = 0 # Total Rank Deviation
+    
+    for g_idx in range(G_Total):
+        
+        #### Values of the Current Gesture
+        eer_val_curr = eer_vec[g_idx] # EER Value
+        dgbqa_val_curr = dgbqa_vec[g_idx] # DGBQA Value
+        
+        #### Rank of the Current Gesture
+        eer_rank_curr = rank_compute(eer_vec,eer_val_curr,True) # EER Rank
+        dgbqa_rank_curr = rank_compute(dgbqa_vec,dgbqa_val_curr,False) # DGBQA Rank
+        
+        #### Rank Difference
+        rank_deviation =  rank_deviation + np.abs(eer_rank_curr - dgbqa_rank_curr)
+        
+    avg_rank_deviation = rank_deviation/G_Total # Computing Avg. over all the gestures
+    return avg_rank_deviation

biomquant-0.0.1/biomQuant/trendMatch.py

@@ -0,0 +1,77 @@
+######## Importing libraries
+import numpy as np
+
+####### Pattern Match Distance
+def compTrendMatchDist(dgbqa,e_prime,G):
+
+    """
+    Function to compute Pattern-Match Distance
+
+    INPUTS:-
+    1) dgbqa: Array of unranked but normalized DGBQA score values
+    2) e_prime: Array of unranked but normalized (1 - EER) values
+    3) G: Total number of gestures considered for analysis
+
+    OUTPUTS:-
+    1) pm_dist: Pattern-Match Distance
+    """
+    ##### Defining Essentials
+    e_prime_sort = -np.sort(-np.array(e_prime)) # Sorting e_prime
+    dgbqa_re = [] # DGBQA-Scores Ordered as per the e_prime_sort
+    arrangement_idx = [] # List to store arrangement orders of e_prime, with the values starting from 0, and ending at G-1
+    pm_dist = 0 # Initializing pm_dist as 0
+    dgbqa_re_f = [] # Low-to-High Ranked List of DGBQA-Score sorted as per e_prime  
+    e_prime_sort_f = [] # Low-to-High Ranked List of e_prime values
+
+    ##### e_prime in reverse order
+    for idx in range(len(e_prime_sort)):
+        e_prime_sort_f.append(e_prime_sort[len(e_prime_sort)-idx-1])
+
+    e_prime_sort_f = np.array(e_prime_sort_f) # Array Formation
+
+    ##### Aranging DGBQA Scores as per e_prime's order
+    for idx, val in enumerate(e_prime_sort):
+
+        for idx_search, val_search in enumerate(e_prime):
+
+            if(val == val_search):
+                arrangement_idx.append(idx_search) # Finding Index on e_prime that matches with e_prime_sort
+                dgbqa_re.append(dgbqa[idx_search]) # Appending terms in dgbqa_re as per the order in e_prime_sort: The best rank is the first term
+                break
+
+    dgbqa_re_b = np.array(dgbqa_re) # Array Formation
+    
+    ##### Aranging DGBQA Scores as per e_prime's order in Low to High
+    for idx in range(len(dgbqa_re)):
+        dgbqa_re_f.append(dgbqa_re[len(dgbqa_re)-idx-1])
+
+    dgbqa_re_f = np.array(dgbqa_re_f) # Array Formation 
+
+    ##### Pattern-Matching Distance Estimation
+
+    #### Slope Computation
+    tan_theta_f = dgbqa_re_f[1:] - dgbqa_re_f[:-1] # Forward Movement Slopes
+    tan_theta_b = tan_theta_f # Backward Movement Slope is Similar as the Forward Movement Slope, just estimation method differs
+
+    #### Forward Value Computation
+    ### Estimation
+    e_bar_f = e_prime_sort_f[:-1] + tan_theta_f # e2_bar_f to eG_bar_f
+    eG_bar_f = e_bar_f[-1] # Extracting Last Value
+    e_bar_f = e_bar_f[:-1] # Storing Middle 'G-2' Values
+
+    ### Error Computation
+    error_f = np.sum(np.abs(e_bar_f - e_prime_sort_f[1:-1])) + 2*(np.abs(eG_bar_f - e_prime_sort_f[-1]))
+
+    #### Backward Value Computation
+    ### Estimation
+    e_bar_b = e_prime_sort_f[1:] - tan_theta_f # e1_bar to e(G-1)_bar_f
+    e1_bar_b = e_bar_b[0] # Extracting First Value
+    e_bar_b = e_bar_b[1:] # Storing Middle 'G-2' Values
+
+    ### Error Compuation
+    error_b = np.sum(np.abs(e_bar_b - e_prime_sort_f[1:-1])) + 2*(np.abs(e1_bar_b - e_prime_sort_f[0])) 
+    
+    #### Pattern-Matching Distance
+    pm_dist = 0.5*(error_f + error_b)
+
+    return pm_dist

biomquant-0.0.1/biomQuant.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: biomQuant
+Version: 0.0.1
+Summary: A package consisting of evaluation measures for gesture biometric quantification.
+Home-page: https://github.com/Mjolnir2307/measurementSuite
+Author: Mjolnir2307
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: summary
+
+# biomQuant
+
+A package consisting of evaluation measures for gesture biometric quantification.
+
+This package provide four measures:
+
+1. Rank deviation ($\hat{r}$)
+2. Relevance ($\mathcal{R}$)
+3. Trend match distance ($\Psi$)
+4. ICGD Score ($C_d$)
+
+We combine these in advanced acceptance score
+
+${A_r}^*~=~\frac{\sum_{j=1}^{G}\Bigl( \frac{2^{\lambda\mathcal{R}_j}}{\exp(\kappa*(r_{j}^{\Delta} - r_{j}^{\hat{e}} ))}\Bigr)}{\sqrt{\log_2(2+\nu\Psi)}}*{\exp(-\beta C_d)}$
+
+Here, $G$ is the number of gestures. While $r_{j}^{\Delta}$ and $r_{j}^{\hat{e}}$ denote ranks of the $j^{th}$ gesture wrt the estimated biometric estimates and the ground truth respectively. $\lambda,~\kappa,~\nu,~\text{and}~\beta$ are the scaling factors.
+
+We further normalize this into $nA_r^*(\Delta)$. Mathematically, 
+
+$nA_r^*(\Delta)=\frac{A_r^{*}(\Delta)}{A_r^{*}(\hat{e})}$
+
+Where, $A_r^*(\Delta)$ and $A_r^*(\hat{e})$ represents $A_r^*$ values for the output DGBQA scores and ground truth, i.e.,
+
+$A_r^*(\hat{e})=\sum_{j=1}^{G}2^{\lambda \Bigl[ \gamma\Bigl({\frac{G-{r_{j}^{\hat{e}}}+1}{G}\Bigr){\hat{e}\left[r_{j}^{\hat{e}}\right]}}+\Bigl(\frac{r_{j}^{\hat{e}}}{G}\Bigr)\Bigl(1-\hat{e}\left[r_{j}^{\hat{e}}\right]\Bigr) \Bigr]}$
+
+## Requirements
+
+1. numpy
+2. sckit-learn
+3. scipy
+4. tensorflow $\geq$ 2.8.0
+
+## How to use
+
+1. Advanced Acceptance Score
+
+```python
+from biomQaunt.advancedAcceptance import comp_advancedAcceptance
+nAr_star = comp_advancedAcceptance(biometricParams,
+                                   groundTruth,
+                                   embeddings,
+                                   labels,
+                                   G=numGestures)
+```
+
+2. Rank deviation
+
+```python
+from biomQaunt.rankDev import rankDev
+r_prime = rankDev(1-groundTruth,
+                  biometricParams,
+                  G=numGestures)
+```
+
+3. Relevance
+
+```python
+import numpy as np
+from biomQaunt.acceptanceScore import compAr
+
+def preProcess(inputVec):
+    inputVec = (inputVec - np.mean(inputVec))/np.std(inputVec)
+    return inputVec/np.linalg.norm(inputVec)
+
+relevance = compAr(preProcess(biometricParams),
+                   preProcess(groundTruth),
+                   normalizer=False,
+                   relevance=True)
+```
+
+4. ICGD score
+
+```python
+import tensorflow as tf
+from biomQaunt.icgd import compICGD
+
+def normalisation_layer(x):   
+    return(tf.math.l2_normalize(x, axis=1, epsilon=1e-12))
+
+embeddings = tf.keras.layers.Lambda(normalisation_layer)(embeddings)
+
+icgdScore = icgdScore(embeddings.numpy(),
+                     labels)
+```
+
+5. Trend match distance
+
+```python
+from biomQaunt.trendMatch import compTrendMatchDist
+psi = rankDev(biometricParams,
+              groundTruth,
+              G=numGestures)
+```

biomquant-0.0.1/biomQuant.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE.txt
+README.md
+setup.py
+biomQuant/__init__.py
+biomQuant/acceptanceScore.py
+biomQuant/advancedAcceptance.py
+biomQuant/icgd.py
+biomQuant/rankDev.py
+biomQuant/trendMatch.py
+biomQuant.egg-info/PKG-INFO
+biomQuant.egg-info/SOURCES.txt
+biomQuant.egg-info/dependency_links.txt
+biomQuant.egg-info/top_level.txt

biomquant-0.0.1/biomQuant.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

biomquant-0.0.1/biomQuant.egg-info/top_level.txt

@@ -0,0 +1 @@
+biomQuant

biomquant-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

biomquant-0.0.1/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+from os import path
+
+working_directory = path.abspath(path.dirname(__file__))
+
+with open(path.join(working_directory, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+setup(
+    name='biomQuant', # name of packe which will be package dir below project
+    version='0.0.1',
+    url='https://github.com/Mjolnir2307/measurementSuite',
+    author='Mjolnir2307',
+    description='A package consisting of evaluation measures for gesture biometric quantification.',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    packages=find_packages(),
+    install_requires=[],
+)