├── LICENSE
├── samples
    └── Seq2Seq.csv
├── .gitignore
├── README.md
└── TaPR.py


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


--------------------------------------------------------------------------------
/samples/Seq2Seq.csv:
--------------------------------------------------------------------------------
 1 | 1754,2800,1
 2 | 3080,3690,2
 3 | 5299,5400,3
 4 | 6063,6220,3
 5 | 6838,6948,4
 6 | 7314,7680,4
 7 | 7700,8233,5
 8 | 8345,8446,6
 9 | 11472,12510,5
10 | 12602,12845,7
11 | 15442,16200,8
12 | 16337,16654,6
13 | 92560,92670,9
14 | 93452,93826,10
15 | 93988,94186,7
16 | 102756,102994,11
17 | 103092,103900,12
18 | 103444,103675,8
19 | 104106,104337,13
20 | 116206,116651,14
21 | 116766,117013,9
22 | 117020,117794,15
23 | 118016,118023,16
24 | 118027,118030,10
25 | 118032,118032,17
26 | 119921,120134,18
27 | 120596,120818,11
28 | 127438,127596,19
29 | 128648,128863,20
30 | 129143,129247,12
31 | 132918,133560,21
32 | 133628,133901,22
33 | 133938,133978,13
34 | 134383,134437,23
35 | 141159,141290,24
36 | 143012,143756,14
37 | 143881,144139,25
38 | 186701,186936,26
39 | 187572,187795,15
40 | 198357,199601,27
41 | 199978,200225,28
42 | 202801,202867,16
43 | 227963,228145,29
44 | 228638,228800,30
45 | 230385,230442,17
46 | 231861,232090,31
47 | 264041,264296,32
48 | 280030,281371,18
49 | 302739,302963,33
50 | 303301,303428,34
51 | 347829,348241,19
52 | 348618,348798,35
53 | 349017,349250,36
54 | 349725,349937,20
55 | 361822,361993,37
56 | 363662,363763,38
57 | 371605,371813,21
58 | 371906,372113,39
59 | 372455,372579,40
60 | 389638,390273,22
61 | 390536,390793,41
62 | 436575,437159,42
63 | 437305,437771,23
64 | 438113,438660,43
65 | 438267,438583,44
66 | 438665,438989,24
67 | 439210,439455,45
68 | 444307,445219,46
69 | 445454,445684,25
70 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | dist/
 14 | downloads/
 15 | eggs/
 16 | .eggs/
 17 | lib/
 18 | lib64/
 19 | parts/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | *.egg-info/
 24 | .installed.cfg
 25 | *.egg
 26 | MANIFEST
 27 | 
 28 | # PyInstaller
 29 | #  Usually these files are written by a python script from a template
 30 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 31 | *.manifest
 32 | *.spec
 33 | 
 34 | # Installer logs
 35 | pip-log.txt
 36 | pip-delete-this-directory.txt
 37 | 
 38 | # Unit test / coverage reports
 39 | htmlcov/
 40 | .tox/
 41 | .coverage
 42 | .coverage.*
 43 | .cache
 44 | nosetests.xml
 45 | coverage.xml
 46 | *.cover
 47 | .hypothesis/
 48 | .pytest_cache/
 49 | 
 50 | # Translations
 51 | *.mo
 52 | *.pot
 53 | 
 54 | # Django stuff:
 55 | *.log
 56 | local_settings.py
 57 | db.sqlite3
 58 | 
 59 | # Flask stuff:
 60 | instance/
 61 | .webassets-cache
 62 | 
 63 | # Scrapy stuff:
 64 | .scrapy
 65 | 
 66 | # Sphinx documentation
 67 | docs/_build/
 68 | 
 69 | # PyBuilder
 70 | target/
 71 | 
 72 | # Jupyter Notebook
 73 | .ipynb_checkpoints
 74 | 
 75 | # pyenv
 76 | .python-version
 77 | 
 78 | # celery beat schedule file
 79 | celerybeat-schedule
 80 | 
 81 | # SageMath parsed files
 82 | *.sage.py
 83 | 
 84 | # Environments
 85 | .env
 86 | .venv
 87 | env/
 88 | venv/
 89 | ENV/
 90 | env.bak/
 91 | venv.bak/
 92 | 
 93 | # Spyder project settings
 94 | .spyderproject
 95 | .spyproject
 96 | 
 97 | # Rope project settings
 98 | .ropeproject
 99 | 
100 | # mkdocs documentation
101 | /site
102 | 
103 | # mypy
104 | .mypy_cache/
105 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # A new version is released!
 2 | 
 3 | I found that there is a limitation of TaPR.
 4 | So, I propose a new version, "enhanced Time-series aware Precision and Recall (eTaPR)."
 5 | 
 6 | Please check the below repository.  
 7 | https://github.com/saurf4ng/eTaPR
 8 | 
 9 | 
10 | 
11 | 
12 | # Time-series Aware Precision and Recall
13 | 
14 | This script is developed on Python3.6.
15 | 
16 | 
17 | ## Input files (encoded by UTF-8)
18 | 
19 | This script supports two kinds of file format. (Assume that normal and anomaly labels are '1' and '-1', respectively.)
20 | 
21 | 1. Label series: each line consists of [(label)('\n')] as belows:
22 | 
23 | ```
24 | 1
25 | -1
26 | -1
27 | 1
28 | 1
29 | ```
30 | 
31 | 2. Range: each line consists of [(first_index),(last_index),(attack_name)('\n')] as belows:
32 |           For example, ./sample/Seq2Seq.csv follows this format.
33 | 
34 | ```
35 | 1754,2800,1
36 | 3080,3690,2
37 | 5299,5400,3
38 | ```
39 | 
40 | 
41 | ## Running
42 | 
43 | python ./TaPR.py -i <prediction_file> -c <anomaly_file> {-a} <alpha> {-t} <theta> {-d} <delta> {-l} <label> {-p}
44 | 
45 | Here is a description of all command line options, inputs, and parameters:
46 | 
47 | ```
48 | -i: File with predictions
49 | -c: File with anomalies (i.e., ground truth)
50 | -t: Parameter theta for detection scoring 
51 | 	Set as float value from 0 to 1
52 |     Default = 0.5
53 | -d: Parameter delta for subsequent scoring
54 | 	Set as zero or more larger integer value
55 |     Defualt = 0
56 | -l: Normal and anomaly labels
57 | 	Set as two integers separate by ','
58 |     Default = 1,-1
59 | -p: Enable printing the list of detected anomalies and correct predictions
60 |     No need input values 
61 | -a: Parameter alpha indicating weight for the detection score
62 |     Default = 0.5
63 | ```
64 | 
65 | If you need to see help menue, please type below operation:
66 | 
67 | ```
68 | python ./TaPR.py -h
69 | ```
70 | 
71 | 
72 | ## Examples
73 | 
74 | Below two examples produce indentical results.
75 | 
76 | ```
77 | python ./TaPR.py -i sample/ocsvm.csv -a sample/swat.csv -t 0.5 -d 180 -l 1,-1
78 | ```
79 | 
80 | ```
81 | python ./TaPR.py -i sample/ocsvm.csv -a sample/swat.csv -d 180
82 | ```
83 | 
84 | ## Cite
85 | The details of this work is going to be published on the 28th international conference on Information and Knowledge Management (CIKM) 2019 as belows.
86 | 
87 | ```
88 | @inproceedings{hwang2019time,
89 |   title={Time-Series Aware Precision and Recall for Anomaly Detection: Considering Variety of Detection Result and Addressing Ambiguous Labeling},
90 |   author={Hwang, Won-Seok and Yun, Jeong-Han and Kim, Jonguk and Kim, Hyoung Chun},
91 |   booktitle={Proceedings of the 28th ACM International Conference on Information and Knowledge Management},
92 |   pages={2241--2244},
93 |   year={2019},
94 |   organization={ACM}
95 | }
96 | ```
97 | 


--------------------------------------------------------------------------------
/TaPR.py:
--------------------------------------------------------------------------------
  1 | import sys, getopt
  2 | import time, datetime
  3 | from typing import Callable
  4 | import math
  5 | 
  6 | 
  7 | # To store a single anomaly
  8 | class Term:
  9 |     def __init__(self, first, last, name):
 10 |         self._first_timestamp = first
 11 |         self._last_timestamp = last
 12 |         self._name = name
 13 | 
 14 |     def set_time(self, first, last):
 15 |         self._first_timestamp = first
 16 |         self._last_timestamp = last
 17 | 
 18 |     def get_time(self):
 19 |         return self._first_timestamp, self._last_timestamp
 20 | 
 21 |     def set_name(self, str):
 22 |         self._name = str
 23 | 
 24 |     def get_name(self):
 25 |         return self._name
 26 | 
 27 |     def __eq__(self, other):
 28 |         return self._first_timestamp == other.get_time()[0] and self._last_timestamp == other.get_time()[1]
 29 | 
 30 | 
 31 | class TaPR:
 32 |     def __init__(self, label, theta, delta):
 33 |         self._predictions = []  # list of Terms
 34 |         self._anomalies = []    # list of Terms
 35 |         self._ambiguous_inst = [] # list of Terms
 36 | 
 37 |         self._set_predictions = False
 38 |         self._set_anomalies = False
 39 | 
 40 |         assert(len(label) == 2)
 41 |         self._normal_lbl = label[0]
 42 |         self._anomal_lbl = label[1]
 43 | 
 44 |         self._theta = theta
 45 |         self._delta = delta
 46 |         pass
 47 | 
 48 |     def load_predictions(self, filename):
 49 |         ntoken = self._check_file_format(filename)
 50 | 
 51 |         if ntoken == 1:
 52 |             self._predictions = self._load_timeseries_file(filename)
 53 |         else:
 54 |             self._predictions = self._load_range_file(filename)
 55 |         self._set_prediction = True
 56 | 
 57 | 
 58 |     def load_anomalies(self, filename):
 59 |         ntoken = self._check_file_format(filename)
 60 | 
 61 |         if ntoken == 1:
 62 |             self._anomalies = self._load_timeseries_file(filename)
 63 |         else:
 64 |             self._anomalies = self._load_range_file(filename)
 65 |         self._set_anomalies = True
 66 | 
 67 |         self._gen_ambiguous()
 68 | 
 69 | 
 70 |     def _gen_ambiguous(self):
 71 |         for i in range(len(self._anomalies)):
 72 |             start_id = self._anomalies[i].get_time()[1] + 1
 73 |             end_id = start_id + self._delta -1
 74 | 
 75 |             #if the next anomaly occurs during the theta, update the end_id
 76 |             if i+1 < len(self._anomalies) and end_id > self._anomalies[i+1].get_time()[0]:
 77 |                 end_id = self._anomalies[i+1].get_time()[0]
 78 | 
 79 |             self._ambiguous_inst.append(Term(start_id, end_id, str(i)))
 80 | 
 81 | 
 82 |     def _check_file_format(self, filename):
 83 |         # check the file's format
 84 |         f = open(filename, 'r', encoding='utf-8', newline='')
 85 |         line = f.readline()
 86 |         token = line.strip().split(',')
 87 |         f.close()
 88 |         return len(token)
 89 | 
 90 |     def _load_range_file(self, filename):
 91 |         temp_list = []
 92 |         f = open(filename, 'r', encoding='utf-8', newline='')
 93 |         for line in f.readlines():
 94 |             items = line.strip().split(',')
 95 |             if len(items) > 2:
 96 |                 temp_list.append(Term(int(items[0]), int(items[1]), str(items[2])))
 97 |             else:
 98 |                 temp_list.append(Term(int(items[0]), int(items[1]), 'undefined'))
 99 |         f.close()
100 |         return temp_list
101 | 
102 |     def _load_timeseries_file(self, filename):
103 |         return_list = []
104 |         start_id = -1
105 |         id = 0
106 |         range_id = 1
107 |         #set prev_val as a value different to normal and anomalous labels
108 |         prev_val = self._anomal_lbl-1
109 |         if prev_val == self._normal_lbl:
110 |             prev_val -= 1
111 | 
112 |         f = open(filename, 'r', encoding='utf-8', newline='')
113 |         for line in f.readlines():
114 |             val = int(line.strip().split()[0])
115 | 
116 |             if val == self._anomal_lbl and prev_val == self._normal_lbl:
117 |                 start_id = id
118 |             elif val == self._normal_lbl and prev_val == self._anomal_lbl:
119 |                 return_list.append(Term(start_id, id - 1, str(range_id)))
120 |                 range_id += 1
121 |                 start_id = 0
122 |             elif start_id == -1 and val == self._anomal_lbl:
123 |                 start_id = 0
124 | 
125 |             id += 1
126 |             prev_val = val
127 |         f.close()
128 |         if start_id != 0:
129 |             return_list.append(Term(start_id, id-1, str(range_id)))
130 | 
131 |         return return_list
132 | 
133 | 
134 |     def get_n_predictions(self):
135 |         return len(self._predictions)
136 | 
137 |     def get_n_anomalies(self):
138 |         return len(self._anomalies)
139 | 
140 |     # return a value with the detected anomaly list
141 |     def TaR_d(self) -> {float, list}:
142 |         total_score = 0.0
143 |         detected_anomalies = []
144 |         for anomaly_id in range(len(self._anomalies)):
145 |             anomaly = self._anomalies[anomaly_id]
146 |             ambiguous = self._ambiguous_inst[anomaly_id]
147 | 
148 |             max_score = self._sum_of_func(anomaly.get_time()[0], anomaly.get_time()[1],
149 |                                           anomaly.get_time()[0], anomaly.get_time()[1], self._uniform_func)
150 | 
151 |             score = 0.0
152 |             for prediction in self._predictions:
153 |                 score += self._overlap_and_subsequent_score(anomaly, ambiguous, prediction)
154 | 
155 |             if min(1.0, score / max_score) > self._theta:
156 |                 total_score += 1.0
157 |                 detected_anomalies.append(anomaly)
158 | 
159 |         if len(self._anomalies) == 0:
160 |             return 0.0, []
161 |         else:
162 |             return total_score / len(self._anomalies), detected_anomalies
163 | 
164 |     # return a value with the detected prediction lists
165 |     def TaP_d(self) -> {float, list}:
166 |         correct_predictions = []
167 |         total_score = 0.0
168 |         for prediction in self._predictions:
169 |             max_score = prediction.get_time()[1] - prediction.get_time()[0] + 1
170 | 
171 |             score = 0.0
172 |             for anomaly_id in range(len(self._anomalies)):
173 |                 anomaly = self._anomalies[anomaly_id]
174 |                 ambiguous = self._ambiguous_inst[anomaly_id]
175 | 
176 |                 score += self._overlap_and_subsequent_score(anomaly, ambiguous, prediction)
177 | 
178 |             if (score/max_score) > self._theta:
179 |                 total_score += 1.0
180 |                 correct_predictions.append(prediction)
181 | 
182 |         if len(self._predictions) == 0:
183 |             return 0.0, []
184 |         else:
185 |             return total_score / len(self._predictions), correct_predictions
186 | 
187 | 
188 |     def _detect(self, src_range: Term, ranges: list, theta: int) -> bool:
189 |         rest_len = src_range.get_time()[1] - src_range.get_time()[0] + 1
190 |         for dst_range in ranges:
191 |             len = self._overlapped_len(src_range, dst_range)
192 |             if len != -1:
193 |                 rest_len -= len
194 |         return (float)(rest_len) / (src_range.get_time()[1] - src_range.get_time()[0] + 1) <= (1.0 - theta)
195 | 
196 |     def _overlapped_len(self, range1: Term, range2: Term) -> int:
197 |         detected_start = max(range1.get_time()[0], range2.get_time()[0])
198 |         detected_end = min(range1.get_time()[1], range2.get_time()[1])
199 | 
200 |         if detected_end < detected_start:
201 |             return 0
202 |         else:
203 |             return detected_end - detected_start + 1
204 | 
205 |     def _min_max_norm(self, value: int, org_min: int, org_max: int, new_min: int, new_max: int) -> float:
206 |         return (float)(new_min) + (float)(value - org_min) * (new_max - new_min) / (org_max - org_min)
207 | 
208 |     def _decaying_func(self, val: float) -> float:
209 |         assert (-6 <= val <= 6)
210 |         return 1 / (1 + math.exp(val))
211 | 
212 |     def _ascending_func(self, val: float) -> float:
213 |         assert (-6 <= val <= 6)
214 |         return 1 / (1 + math.exp(val * -1))
215 | 
216 |     def _uniform_func(self, val: float) -> float:
217 |         return 1.0
218 | 
219 |     def _sum_of_func(self, start_time: int, end_time: int, org_start: int, org_end: int,
220 |                      func: Callable[[float], float]) -> float:
221 |         val = 0.0
222 |         for timestamp in range(start_time, end_time + 1):
223 |             val += func(self._min_max_norm(timestamp, org_start, org_end, -6, 6))
224 |         return val
225 | 
226 |     def _overlap_and_subsequent_score(self, anomaly: Term, ambiguous: Term, prediction: Term) -> float:
227 |         score = 0.0
228 | 
229 |         detected_start = max(anomaly.get_time()[0], prediction.get_time()[0])
230 |         detected_end = min(anomaly.get_time()[1], prediction.get_time()[1])
231 | 
232 |         score += self._sum_of_func(detected_start, detected_end,
233 |                                    anomaly.get_time()[0], anomaly.get_time()[1], self._uniform_func)
234 | 
235 |         detected_start = max(ambiguous.get_time()[0], prediction.get_time()[0])
236 |         detected_end = min(ambiguous.get_time()[1], prediction.get_time()[1])
237 | 
238 |         score += self._sum_of_func(detected_start, detected_end,
239 |                                    ambiguous.get_time()[0], ambiguous.get_time()[1], self._decaying_func)
240 | 
241 |         return score
242 | 
243 |     def TaR_p(self) -> float:
244 |         total_score = 0.0
245 |         for anomaly_id in range(len(self._anomalies)):
246 |             anomaly = self._anomalies[anomaly_id]
247 |             ambiguous = self._ambiguous_inst[anomaly_id]
248 | 
249 |             max_score = self._sum_of_func(anomaly.get_time()[0], anomaly.get_time()[1],
250 |                                           anomaly.get_time()[0], anomaly.get_time()[1], self._uniform_func)
251 | 
252 |             score = 0.0
253 |             for prediction in self._predictions:
254 |                 score += self._overlap_and_subsequent_score(anomaly, ambiguous, prediction)
255 | 
256 |             total_score += min(1.0, score/max_score)
257 | 
258 |         if len(self._anomalies) == 0:
259 |             return 0.0
260 |         else:
261 |             return total_score / len(self._anomalies)
262 | 
263 |     def TaP_p(self) -> float:
264 |         total_score = 0.0
265 |         for prediction in self._predictions:
266 |             max_score = prediction.get_time()[1] - prediction.get_time()[0] + 1
267 | 
268 |             score = 0.0
269 |             for anomaly_id in range(len(self._anomalies)):
270 |                 anomaly = self._anomalies[anomaly_id]
271 |                 ambiguous = self._ambiguous_inst[anomaly_id]
272 | 
273 |                 score += self._overlap_and_subsequent_score(anomaly, ambiguous, prediction)
274 | 
275 |             total_score += score/max_score
276 | 
277 |         if len(self._predictions) == 0:
278 |             return 0.0
279 |         else:
280 |             return total_score / len(self._predictions)
281 | 
282 | 
283 | def main(argv):
284 |     predict_file = ''
285 |     anomaly_file = ''
286 |     delta = 0
287 |     theta = 0.5
288 |     alpha = 0.5
289 |     label = [1,-1]
290 |     print_detail = False
291 | 
292 |     try:
293 |         opts, args = getopt.getopt(argv, "hpi:c:d:t:l:a:", ["input file=", "attack file=", "delta=(default:0)", "theta=(default:0.5)", "label=[normal,anomaly](default:1,-1)", "alpha=(default:0.5)"])
294 |     except getopt.GetoptError:
295 |         print('Getopt Error')
296 |         sys.exit(2)
297 |     for opt, arg in opts:
298 |         if opt == '-h':
299 |             print('evaluation.py -i <prediction_file> -c <anomaly_file> {-p} {-a} <alpha> {-t} <theta> {-d} <delta> {-l} <label>')
300 |             buf = '''-i: File with predictions
301 | -c: File with anomalies (i.e., correct answer)
302 | -t: Parameter theta for detection scoring 
303 |     Set as float value from 0 to 1
304 |     Default = 0.5
305 | -d: Parameter delta for subsequent scoring
306 |     Set as zero or more larger integer value
307 |     Defualt = 0
308 | -l: Normal and anomaly labels
309 |     Set as two integers separate by ','
310 |     Default = 1,-1
311 | -p: Enable printing the list of detected anomalies and correct predictions
312 |     No need input values 
313 | -a: Parameter alpha indicating weight for the detection score
314 |     Default = 0.5
315 |             '''
316 |             print(buf)
317 |             sys.exit()
318 |         elif opt == '-p':
319 |             print_detail = True
320 |         elif opt in ("-i"):
321 |             predict_file = arg
322 |         elif opt in ("-c"):
323 |             anomaly_file = arg
324 |         elif opt in ("-d"):
325 |             delta = int(arg)
326 |         elif opt in ("-t"):
327 |             theta = float(arg)
328 |             assert (0.0 <= theta and theta <= 1.0)
329 |         elif opt in ("-l"):
330 |             label = str(arg).strip().split(',')
331 |             label = [int(label[0]), int(label[1])]
332 |         elif opt in ("-a"):
333 |             alpha = float(arg)
334 |             assert(0.0 <= alpha and alpha <= 1.0)
335 | 
336 |     if len(predict_file) == 0:
337 |         print('Error: Input the prediction file after -i.')
338 |         return
339 | 
340 |     if len(anomaly_file) == 0:
341 |         print('Error: Input the anomaly file (ground truth) after -a.')
342 |         return
343 | 
344 |     ev = TaPR(label, theta, delta)
345 | 
346 |     ev.load_anomalies(anomaly_file)
347 |     ev.load_predictions(predict_file)
348 | 
349 | 
350 |     tard_value, detected_list = ev.TaR_d()
351 |     tarp_value = ev.TaR_p()
352 | 
353 |     print('\n[TaR]:',  "%0.5f"%(alpha*tard_value + (1-alpha)*tarp_value))
354 |     print("\t* Detection score:", "%0.5f"%tard_value)
355 |     if print_detail:
356 |         buf = '\t\tdetected anomalies: '
357 |         if len(detected_list) == 0:
358 |             buf += "None  "
359 |         else:
360 |             for value in detected_list:
361 |                 buf += value.get_name() + '(' + str(value.get_time()[0]) + ':' + str(value.get_time()[1]) + '), '
362 |         print(buf[:-2])
363 |     print("\t* Portion score:", "%0.5f"%tarp_value, "\n")
364 | 
365 | 
366 |     tapd_value, correct_list = ev.TaP_d()
367 |     tapp_value = ev.TaP_p()
368 |     print('[TaP]:', "%0.5f"%(alpha*tapd_value + (1-alpha)*tapp_value))
369 | 
370 |     print("\t* Detection score:", "%0.5f"%tapd_value)
371 |     if print_detail:
372 |         buf = '\t\tcorrect predictions: '
373 |         if len(correct_list) == 0:
374 |             buf += "None  "
375 |         else:
376 |             for value in correct_list:
377 |                 buf += value.get_name() + '(' + str(value.get_time()[0]) + ':' + str(value.get_time()[1]) + '), '
378 |         print(buf[:-2])
379 |     print("\t* Portion score:", "%0.5f"%tapp_value, "\n")
380 | 
381 | 
382 | 
383 | if __name__ == '__main__':
384 |     main(sys.argv[1:])
385 | 


--------------------------------------------------------------------------------