1. algorithms
  2. robertodaza
  3. borrarahora
  4. 14

This algorithm is a legacy one. The API has changed since its implementation. New versions and forks will need to be updated.
This algorithm is splittable

Algorithms have at least one input and one output. All algorithm endpoints are organized in groups. Groups are used by the platform to indicate which inputs and outputs are synchronized together. The first group is automatically synchronized with the channel defined by the block in which the algorithm is deployed.

Group: main

Endpoint Name Data Format Nature
template_client_id system/text/1 Input
features tutorial/atvs_keystroke/1 Input
id system/text/1 Input
scores robertodaza/example-a/5 Output 
xxxxxxxxxx
160
 
1
import numpy
2
​
3
def mad(lst):  
4
    if len(lst) < 1:
5
        return None
6
    if not(isinstance(lst[0], list)):      
7
        vec=[];
8
        m=numpy.median(lst);
9
        for i in range(len(lst)):
10
            vec.append(abs(lst[i]-m));
11
        return numpy.median(vec)
12
    else:
13
        mad_vec=[];
14
        for i in range(len(lst[0])):
15
            vec=[];          
16
            for j in range(len(lst)):
17
                vec.append(lst[j][i]);
18
​
19
            m=numpy.mean(vec);          
20
          
21
            vec=[];          
22
            for j in range(len(lst)):
23
                vec.append(abs(lst[j][i]-m));
24
              
25
            mad_vec.append(numpy.mean(vec)+0.00001);
26
​
27
        return mad_vec
28
​
29
class Algorithm:
30
​
31
    def __init__(self):
32
        self._features1 = []
33
        self._features2 = []
34
        self._features3 = []
35
        self._features4 = []
36
        self._features5 = []  
37
        self._a=0
38
        self._templates={}
39
    def process(self, inputs, outputs):
40
​
41
        # collect all the features for the current template
42
        data = inputs['features'].data
43
      
44
        f1 = data.holdtime.given_name
45
        f2 = data.rplatency.given_name
46
        feature_vector=[]
47
        l_f=len(f1)
48
        for i_k in range(l_f):
49
            feature_vector.append(float(f1[i_k]))
50
      
51
        l_f=len(f2)
52
        for i_k in range(l_f):
53
            feature_vector.append(float(f2[i_k]))            
54
              
55
        self._features1.append(feature_vector)
56
                    
57
        f1 = data.holdtime.family_name
58
        f2 = data.rplatency.family_name
59
        feature_vector=[]
60
        l_f=len(f1)
61
        for i_k in range(l_f):
62
            feature_vector.append(float(f1[i_k]))
63
      
64
        l_f=len(f2)
65
        for i_k in range(l_f):
66
            feature_vector.append(float(f2[i_k]))            
67
              
68
        self._features2.append(feature_vector)
69
              
70
        f1 = data.holdtime.email
71
        f2 = data.rplatency.email
72
        feature_vector=[]
73
        l_f=len(f1)
74
        for i_k in range(l_f):
75
            feature_vector.append(float(f1[i_k]))
76
      
77
        l_f=len(f2)
78
        for i_k in range(l_f):
79
            feature_vector.append(float(f2[i_k]))            
80
              
81
        self._features3.append(feature_vector)
82
      
83
        f1 = data.holdtime.nationality
84
        f2 = data.rplatency.nationality
85
        feature_vector=[]
86
        l_f=len(f1)
87
        for i_k in range(l_f):
88
            feature_vector.append(float(f1[i_k]))
89
      
90
        l_f=len(f2)
91
        for i_k in range(l_f):
92
            feature_vector.append(float(f2[i_k]))            
93
              
94
        self._features4.append(feature_vector)
95
      
96
        f1 = data.holdtime.id_number
97
        f2 = data.rplatency.id_number
98
        feature_vector=[]
99
        l_f=len(f1)
100
        for i_k in range(l_f):
101
            feature_vector.append(float(f1[i_k]))
102
      
103
        l_f=len(f2)
104
        for i_k in range(l_f):
105
            feature_vector.append(float(f2[i_k]))            
106
              
107
        self._features5.append(feature_vector)
108
              
109
        # Calculate mean and std
110
        if inputs["id"].isDataUnitDone():
111
            features11 = numpy.average(self._features1, axis=0)
112
            features12 = numpy.std(self._features1, axis=0)
113
            features13 = mad(self._features1)
114
            features21 = numpy.average(self._features2, axis=0)
115
            features22 = numpy.std(self._features2, axis=0)
116
            features23 = mad(self._features2)    
117
            features31 = numpy.average(self._features3, axis=0)
118
            features32 = numpy.std(self._features3, axis=0)
119
            features33 = mad(self._features3)
120
            features41 = numpy.average(self._features4, axis=0)
121
            features42 = numpy.std(self._features4, axis=0)
122
            features43 = mad(self._features4)
123
            features51 = numpy.average(self._features5, axis=0)
124
            features52 = numpy.std(self._features5, axis=0)
125
            features53 = mad(self._features5)
126
            template_id = inputs['id'].data.text
127
            self._templates[template_id] = dict(
128
                        client_id = inputs['template_client_id'].data.text,  
129
                        given_name_average = features11,
130
                        given_name_std = features12,
131
                        given_name_mad = features13,
132
                        family_name_average= features21,
133
                        family_name_std= features22,
134
                        family_name_mad= features23,
135
                        email_average= features31,
136
                        email_std= features32,
137
                        email_mad= features33,
138
                        nationality_average= features41,
139
                        nationality_std= features42,
140
                        nationality_mad= features43,
141
                        id_number_average= features51,
142
                        id_number_std= features52,
143
                        id_number_mad= features53,
144
                      
145
                    )
146
            self._a=self._a+1
147
            # outputs data
148
            outputs["scores"].write({
149
                'score': numpy.int32(template_id)
150
              
151
            })
152
          
153
            self._features1 = []
154
            self._features2 = []
155
            self._features3 = []
156
            self._features4 = []
157
            self._features5 = []
158
          
159
        return True
160
​

The code for this algorithm in Python
The ruler at 80 columns indicate suggested POSIX line breaks (for readability).
The editor will automatically enlarge to accomodate the entirety of your input
Use keyboard shortcuts for search/replace and faster editing. For example, use Ctrl-F (PC) or Cmd-F (Mac) to search through this box

This algorithm is designed to be used as a simple enrollment strategy of keystroke data. It enrolls a model from several features by computing the average and standard deviation of the enrollment features.

Note

All features must have the same length.

Experiments

Updated Name Databases/Protocols Analyzers
robertodaza/robertodaza/example1/1/borrarahora122211111 atvskeystroke/1@A robertodaza/proof1-template_id/10
Created with Raphaël 2.1.2[compare]robertodaza/borrarahora/11robertodaza/borrarahora/142016Jan21

This table shows the number of times this algorithm has been successfully run using the given environment. Note this does not provide sufficient information to evaluate if the algorithm will run when submitted to different conditions.

Terms of Service | Contact Information | BEAT platform version 2.2.1b0 | © Idiap Research Institute - 2013-2025