1. algorithms
  2. robertodaza
  3. keystroke-btas15-scoring-proof1-explained
  4. 1

Forked from aythamimm/keystroke_btas15_scoring/1

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

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: probes

Endpoint Name Data Format Nature
comparison_ids system/array_1d_text/1 Input
keystroke tutorial/atvs_keystroke/1 Input
probe_client_id system/text/1 Input
scores elie_khoury/string_probe_scores/1 Output

Group: templates

Endpoint Name Data Format Nature
template_client_id system/text/1 Input
template_id system/text/1 Input
model_template aythamimm/keystroke_model/8 Input

Parameters allow users to change the configuration of an algorithm when scheduling an experiment

Name Description Type Default Range/Choices
field Data field used to generate the feature template string given_name given_name, family_name, email, nationality, id_number, all_five
distance Distance to obtain the matching score string Modified Scaled Manhattan Scaled Manhattan, Modified Scaled Manhattan, Combined Manhattan-Mahalanobis, Mahalanobis + Nearest Neighbor 
xxxxxxxxxx
263
 
1
import numpy
2
​
3
def modified_scaled_distance(in1,in2,in3): #Funcion que funciona con la media, la std , y el vector de prueba
4
    ##This is the distance 1 based on the manhattan distance or
5
    ##city block and a normalization  by standard deviation
6
  
7
    dif=[]
8
    mean_gal_features=in1
9
    std_gal_features=in2
10
    probe_features=in3
11
    l_features=len(probe_features)
12
      
13
    std_threshold=0.2*numpy.mean(std_gal_features);
14
    for i in range( l_features):
15
        if std_gal_features[i] < std_threshold:
16
            std_gal_features[i]=std_threshold  
17
  
18
    for i_dif in range(l_features):
19
        dif.append((abs(mean_gal_features[i_dif]-probe_features[i_dif]))/std_gal_features[i_dif])          
20
    score = 1/numpy.average(dif)  
21
    return score
22
​
23
def scaled_distance(in1,in2,in3):#distancia que funciona con  la media, la std , y el vector de prueba
24
    ##This is the distance 1 based on the manhattan distance or
25
    ##city block and a normalization  by standard deviation
26
  
27
    dif=[]
28
    mean_gal_features=in1  
29
    mad_gal_features=in2;  
30
    probe_features=in3
31
    l_features=len(probe_features)
32
      
33
    for i_dif in range(l_features):
34
        dif.append((abs(mean_gal_features[i_dif]-probe_features[i_dif]))/mad_gal_features[i_dif])          
35
    score = 1/numpy.sum(dif)  
36
    return score
37
​
38
class Algorithm:
39
​
40
    def __init__(self): #Difinimos variables globales    
41
        self.templates = None #por defecto None la primera vez
42
        self.field='given_name' #Por defecto el nombre
43
        self.distance='given_name'
44
​
45
    def setup(self, parameters): #Funcion que define los parametros      
46
        self.field = parameters.get('field', self.field)#si el parametro field no toma valor se deja el nombre si toma valor se pondra el que sea(correo,DNI,etc)?
47
        self.distance = parameters.get('distance', self.distance)
48
      
49
        return True
50
  
51
    def process(self, inputs, outputs):
52
​
53
        # retrieve all the templates once
54
        if self.templates is None:#La primera vez entra aqui
55
            self.templates = {}#define un diccionario
56
            group = inputs.groupOf('model_template')#mira en la entrada el grupo con model_template
57
​
58
            while group.hasMoreData():#Mientras tenga datos se ejecuta
59
                group.next()#no se que hace? pedir dato nuevo
60
​
61
                template_id = group['template_id'].data.text #string              
62
              
63
                if self.field == 'given_name':#Si es el nombre se ejecuta esto y guardamos la media,std y mad en cada template
64
                    template1=group['model_template'].data.given_name_average
65
                    template2=group['model_template'].data.given_name_std
66
                    template3=group['model_template'].data.given_name_mad
67
                if self.field == 'family_name':
68
                    template1=group['model_template'].data.family_name_average
69
                    template2=group['model_template'].data.family_name_std
70
                    template3=group['model_template'].data.family_name_mad
71
                if self.field == 'email':
72
                    template1=group['model_template'].data.email_average
73
                    template2=group['model_template'].data.email_std
74
                    template3=group['model_template'].data.email_mad
75
                if self.field == 'nationality':
76
                    template1=group['model_template'].data.nationality_average
77
                    template2=group['model_template'].data.nationality_std
78
                    template3=group['model_template'].data.nationality_mad
79
                if self.field == 'id_number':
80
                    template1=group['model_template'].data.id_number_average
81
                    template2=group['model_template'].data.id_number_std
82
                    template3=group['model_template'].data.id_number_mad
83
                if self.field == 'all_five':#si es todos lo hace con cada uno
84
                    template11=group['model_template'].data.given_name_average
85
                    template12=group['model_template'].data.given_name_std
86
                    template13=group['model_template'].data.given_name_mad  
87
                    template21=group['model_template'].data.family_name_average
88
                    template22=group['model_template'].data.family_name_std            
89
                    template23=group['model_template'].data.family_name_mad
90
                    template31=group['model_template'].data.email_average
91
                    template32=group['model_template'].data.email_std
92
                    template33=group['model_template'].data.email_mad
93
                    template41=group['model_template'].data.nationality_average
94
                    template42=group['model_template'].data.nationality_std
95
                    template43=group['model_template'].data.nationality_mad
96
                    template51=group['model_template'].data.id_number_average
97
                    template52=group['model_template'].data.id_number_std
98
                    template53=group['model_template'].data.id_number_mad
99
              
100
                if self.field != 'all_five':#si no son todos entra en el if y crea un diccionario en la posicion template_id que es el usuario?
101
                    self.templates[template_id] = dict(
102
                        client_id = group['template_client_id'].data.text,                  
103
                        model_average = template1,
104
                        model_std = template2,
105
                        model_mad = template3,
106
                    )
107
                if self.field == 'all_five':#si es todos hace esto, es un diccionario con todos
108
                    self.templates[template_id] = dict(
109
                        client_id = group['template_client_id'].data.text,                  
110
                        model_average1 = template11,
111
                        model_std1 = template12,
112
                        model_mad1 = template13,
113
                        model_average2 = template21,
114
                        model_std2 = template22,
115
                        model_mad2 = template23,
116
                        model_average3 = template31,
117
                        model_std3 = template32,
118
                        model_mad3 = template33,
119
                        model_average4 = template41,
120
                        model_std4 = template42,
121
                        model_mad4 = template43,
122
                        model_average5 = template51,
123
                        model_std5 = template52,
124
                        model_mad5 = template53,
125
                    )
126
​
127
        # process the probe
128
        comparison_ids = inputs['comparison_ids'].data.text#string? creo que es el identificador de comparacion
129
        data = inputs['keystroke'].data     #coge una de las muestras de ese usuario que entran
130
        if self.field == 'given_name':#si es el nombre coge el hotdtime y rplatency
131
            f1 = data.holdtime.given_name
132
            f2 = data.rplatency.given_name
133
        if self.field == 'family_name':
134
            f1 = data.holdtime.family_name
135
            f2 = data.rplatency.family_name
136
        if self.field == 'email':
137
            f1 = data.holdtime.email
138
            f2 = data.rplatency.email
139
        if self.field == 'nationality':
140
            f1 = data.holdtime.nationality
141
            f2 = data.rplatency.nationality      
142
        if self.field == 'id_number':
143
            f1 = data.holdtime.id_number
144
            f2 = data.rplatency.id_number
145
        if self.field == 'all_five':#Si es todo coge los cinco
146
            f11 = data.holdtime.given_name
147
            f12 = data.rplatency.given_name      
148
            f21 = data.holdtime.family_name
149
            f22 = data.rplatency.family_name    
150
            f31 = data.holdtime.email
151
            f32 = data.rplatency.email      
152
            f41 = data.holdtime.nationality
153
            f42 = data.rplatency.nationality
154
            f51 = data.holdtime.id_number
155
            f52 = data.rplatency.id_number
156
      
157
        if self.field != 'all_five':#si es distinto de los 5 pasw solo lo hace para uno
158
            feature_vector=[] #definimos una lista
159
            l_f=len(f1)#longitud de la lista
160
            for i_k in range(l_f):#vamos poniendo los valores en una fila y transformando a float
161
                feature_vector.append(float(f1[i_k]))
162
          
163
            l_f=len(f2)
164
            for i_k in range(l_f):#igual pero con rplatency
165
                feature_vector.append(float(f2[i_k]))      
166
      
167
            probe_features=feature_vector#igualamos el vector, se podria hacer en un paso?
168
          
169
        if self.field == 'all_five':#con los cindo si es all_five
170
            feature_vector1=[]
171
            l_f=len(f11)
172
            for i_k in range(l_f):
173
                feature_vector1.append(float(f11[i_k]))
174
      
175
            l_f=len(f12)
176
            for i_k in range(l_f):
177
                feature_vector1.append(float(f12[i_k]))      
178
      
179
            feature_vector2=[]
180
            l_f=len(f21)
181
            for i_k in range(l_f):
182
                feature_vector2.append(float(f21[i_k]))
183
      
184
            l_f=len(f22)
185
            for i_k in range(l_f):
186
                feature_vector2.append(float(f22[i_k]))
187
          
188
            feature_vector3=[]
189
            l_f=len(f31)
190
            for i_k in range(l_f):
191
                feature_vector3.append(float(f31[i_k]))
192
      
193
            l_f=len(f32)
194
            for i_k in range(l_f):
195
                feature_vector3.append(float(f32[i_k]))
196
          
197
            feature_vector4=[]
198
            l_f=len(f41)
199
            for i_k in range(l_f):
200
                feature_vector4.append(float(f41[i_k]))
201
      
202
            l_f=len(f42)
203
            for i_k in range(l_f):
204
                feature_vector4.append(float(f42[i_k]))
205
          
206
            feature_vector5=[]
207
            l_f=len(f51)
208
            for i_k in range(l_f):
209
                feature_vector5.append(float(f51[i_k]))
210
      
211
            l_f=len(f52)
212
            for i_k in range(l_f):
213
                feature_vector5.append(float(f52[i_k]))
214
      
215
            probe_features1=feature_vector1
216
            probe_features2=feature_vector2
217
            probe_features3=feature_vector3
218
            probe_features4=feature_vector4
219
            probe_features5=feature_vector5
220
      
221
        scores = []#difinimos score como lista
222
        for comparison_id in comparison_ids:
223
            template_client_identity = self.templates[comparison_id]['client_id']          
224
          
225
            if self.field != 'all_five':#Hacemos las distancias para solo un pasw
226
                if self.distance == 'Modified Scaled Manhattan':
227
                    score=modified_scaled_distance(self.templates[comparison_id]['model_average'],self.templates[comparison_id]['model_std'],probe_features);
228
                if self.distance == 'Scaled Manhattan':
229
                    score=scaled_distance(self.templates[comparison_id]['model_average'],self.templates[comparison_id]['model_mad'],probe_features);  
230
                  
231
              
232
            if self.field == 'all_five':#para los cinco pasw
233
                score=[] #podria quitarse?
234
                if self.distance == 'Modified Scaled Manhattan':
235
                    score.append(modified_scaled_distance(self.templates[comparison_id]['model_average1'],self.templates[comparison_id]['model_std1'],probe_features1))
236
                    score.append(modified_scaled_distance(self.templates[comparison_id]['model_average2'],self.templates[comparison_id]['model_std2'],probe_features2))
237
                    score.append(modified_scaled_distance(self.templates[comparison_id]['model_average3'],self.templates[comparison_id]['model_std3'],probe_features3))
238
                    score.append(modified_scaled_distance(self.templates[comparison_id]['model_average4'],self.templates[comparison_id]['model_std4'],probe_features4))
239
                    score.append(modified_scaled_distance(self.templates[comparison_id]['model_average5'],self.templates[comparison_id]['model_std5'],probe_features5))                  
240
              
241
                if self.distance == 'Scaled Manhattan':
242
                    score.append(scaled_distance(self.templates[comparison_id]['model_average1'],self.templates[comparison_id]['model_std1'],probe_features1))
243
                    score.append(scaled_distance(self.templates[comparison_id]['model_average2'],self.templates[comparison_id]['model_std2'],probe_features2))
244
                    score.append(scaled_distance(self.templates[comparison_id]['model_average3'],self.templates[comparison_id]['model_std3'],probe_features3))
245
                    score.append(scaled_distance(self.templates[comparison_id]['model_average4'],self.templates[comparison_id]['model_std4'],probe_features4))
246
                    score.append(scaled_distance(self.templates[comparison_id]['model_average5'],self.templates[comparison_id]['model_std5'],probe_features5))
247
                  
248
                score=numpy.average(score)#media de todos los scores por fila
249
          
250
          
251
            scores.append({
252
                'template_identity': template_client_identity,
253
                'score': score,
254
            })#difinimos dentro de la lista scores diccionarios con dos campos
255
​
256
        outputs['scores'].write({
257
                'client_identity': inputs['probe_client_id'].data.text,
258
                'scores': scores
259
            },          
260
        )
261
​
262
        return True
263
​

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

For a given set of feature vectors and enrollment set, the modified manhattan scaled distance is obtained. See [1] for details.

AGREEMENT ON THE USE OF THIS CODE AND ANY GENERATED DATA

I agree:

  1. to cite [1] in any paper of mine or my collaborators that makes any use of the software (codes) or data generated from these codes.

[1] A. Morales, M. Falanga, J. Fierrez, C. Sansone and J. Ortega-Garcia, &quot;Keystroke Dynamics Recognition based on Personal Data: A Comparative Experimental Evaluation Implementing Reproducible Research &quot;, in Proc. the IEEE Seventh International Conference on Biometrics: Theory, Applications and Systems, Arlington, Virginia, USA, September 2015

No experiments are using this algorithm.
Created with Raphaël 2.1.2[compare]aythamimm/keystroke_btas15_scoring/1robertodaza/keystroke-btas15-scoring-proof1-explained/1Sep152015Dec28
This algorithm was never executed.
Terms of Service | Contact Information | BEAT platform version 2.2.1b0 | © Idiap Research Institute - 2013-2025