1. algorithms
  2. robertodaza
  3. competition-proof1
  4. 2

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
features tutorial/atvs_keystroke/1 Input
id system/text/1 Input
scores aythamimm/keystroke_model/8 Output 
xxxxxxxxxx
152
 
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._features={}
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
            # outputs data
127
            outputs["scores"].write({
128
                'given_name_average':       features11,
129
                'given_name_std':           features12,
130
                'given_name_mad':           features13,
131
                'family_name_average':      features21,
132
                'family_name_std':          features22,
133
                'family_name_mad':          features23,
134
                'email_average':            features31,
135
                'email_std':                features32,
136
                'email_mad':                features33,
137
                'nationality_average':      features41,
138
                'nationality_std':          features42,
139
                'nationality_mad':          features43,
140
                'id_number_average':        features51,
141
                'id_number_std':            features52,
142
                'id_number_mad':            features53,
143
            })
144
          
145
            self._features1 = []
146
            self._features2 = []
147
            self._features3 = []
148
            self._features4 = []
149
            self._features5 = []
150
            self._a=self._a+1
151
        return True
152
​

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/aythamimm/atvs_keystroke_btas_benchmark/1/borrar1 atvskeystroke/1@A aythamimm/keystroke_btas15_analyzer/1
Created with Raphaël 2.1.2[compare]aythamimm/keystroke_btas15_enroll/4robertodaza/competition-proof1/12015Sep14robertodaza/competition-proof1/2robertodaza/competition-proof1/4robertodaza/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