From a2bd09a9dfb36219bd8c50ef004fb1313d3ebb5f Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Wed, 12 Jan 2022 11:29:21 +0100
Subject: [PATCH 01/13] refactor dataset config

---
 benchmark/AEL_benchmark.py        | 135 +----------
 benchmark/Drain_benchmark.py      | 132 +----------
 benchmark/IPLoM_benchmark.py      | 133 +----------
 benchmark/LFA_benchmark.py        | 101 +-------
 benchmark/LKE_benchmark.py        | 118 +---------
 benchmark/Lenma_benchmark.py      | 121 +---------
 benchmark/LogCluster_benchmark.py | 117 +---------
 benchmark/LogMine_benchmark.py    | 148 +-----------
 benchmark/LogSettings.py          | 369 ++++++++++++++++++++++++++++++
 benchmark/LogSig_benchmark.py     | 116 +---------
 benchmark/MoLFI_benchmark.py      | 101 +-------
 benchmark/SHISO_benchmark.py      | 165 +------------
 benchmark/SLCT_benchmark.py       | 118 +---------
 benchmark/Spell_benchmark.py      | 117 +---------
 14 files changed, 384 insertions(+), 1607 deletions(-)
 create mode 100644 benchmark/LogSettings.py

diff --git a/benchmark/AEL_benchmark.py b/benchmark/AEL_benchmark.py
index 6064f262..4ca2b7b9 100644
--- a/benchmark/AEL_benchmark.py
+++ b/benchmark/AEL_benchmark.py
@@ -5,143 +5,12 @@
 from logparser import AEL, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'AEL_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'minEventCount': 2,
-        'merge_percent' : 0.5
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+'],
-        'minEventCount': 2,
-        'merge_percent' : 0.4
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'minEventCount': 2,
-        'merge_percent' : 0.4
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'minEventCount': 2,
-        'merge_percent' : 0.4
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'minEventCount': 2,
-        'merge_percent' : 0.5
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'minEventCount': 5,
-        'merge_percent' : 0.4
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'minEventCount': 2,
-        'merge_percent' : 0.4
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'minEventCount': 2,
-        'merge_percent' : 0.4
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'minEventCount': 2,
-        'merge_percent' : 0.6
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'minEventCount': 2,
-        'merge_percent' : 0.6
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'minEventCount': 2,
-        'merge_percent' : 0.6
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'minEventCount': 2,
-        'merge_percent' : 0.4
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\s?sec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        'minEventCount': 2,
-        'merge_percent' : 0.4
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'minEventCount': 10,
-        'merge_percent' : 0.7
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'minEventCount': 6,
-        'merge_percent' : 0.5
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'minEventCount': 2,
-        'merge_percent' : 0.6
-        }
-}
-
 bechmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
+for dataset, setting in benchmark_settings.items():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
     log_file = os.path.basename(setting['log_file'])
diff --git a/benchmark/Drain_benchmark.py b/benchmark/Drain_benchmark.py
index d42e1118..3ea7f2c7 100644
--- a/benchmark/Drain_benchmark.py
+++ b/benchmark/Drain_benchmark.py
@@ -5,140 +5,10 @@
 from logparser import Drain, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'Drain_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'st': 0.5,
-        'depth': 4
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+'],
-        'st': 0.5,
-        'depth': 4        
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'st': 0.5,
-        'depth': 4
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'st': 0.5,
-        'depth': 4        
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'st': 0.5,
-        'depth': 4        
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'st': 0.5,
-        'depth': 4
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'st': 0.5,
-        'depth': 4        
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'st': 0.7,
-        'depth': 5      
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'st': 0.39,
-        'depth': 6        
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'st': 0.2,
-        'depth': 6   
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'st': 0.2,
-        'depth': 4
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'st': 0.5,
-        'depth': 4        
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        'st': 0.6,
-        'depth': 3
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'st': 0.6,
-        'depth': 5   
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'st': 0.5,
-        'depth': 5
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'st': 0.7,
-        'depth': 6   
-        },
-}
 
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
diff --git a/benchmark/IPLoM_benchmark.py b/benchmark/IPLoM_benchmark.py
index 0dcf04db..62a11563 100644
--- a/benchmark/IPLoM_benchmark.py
+++ b/benchmark/IPLoM_benchmark.py
@@ -5,141 +5,10 @@
 from logparser import IPLoM, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/'  # The input directory of log file
 output_dir = 'IPLoM_result/'  # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'CT': 0.35,
-        'lowerBound': 0.25,
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?']
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'CT': 0.4,
-        'lowerBound': 0.2,
-        'regex': [r'(\d+\.){3}\d+']
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'CT': 0.35,
-        'lowerBound': 0.3,
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+']
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'CT': 0.4,
-        'lowerBound': 0.7,
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?']
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'CT': 0.4,
-        'lowerBound': 0.01,
-        'regex': [r'core\.\d+']
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'CT': 0.58,
-        'lowerBound': 0.25,
-        'regex': [r'=\d+']
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'CT': 0.3,
-        'lowerBound': 0.2,
-        'regex': [r'(\d+\.){3}\d+']
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'CT': 0.3,
-        'lowerBound': 0.25,
-        'regex': [r'0x.*?\s']
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'CT': 0.3,
-        'lowerBound': 0.3,
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}']
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'CT': 0.25,
-        'lowerBound': 0.3,
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b']
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'CT': 0.25,
-        'lowerBound': 0.3,
-        'regex': []
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'CT': 0.3,
-        'lowerBound': 0.4,
-        'regex': [r'(\d+\.){3}\d+']
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'CT': 0.9,
-        'lowerBound': 0.25,
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'CT': 0.78,
-        'lowerBound': 0.25,
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+']
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'CT': 0.9,
-        'lowerBound': 0.25,
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+']
-    },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'CT': 0.3,
-        'lowerBound': 0.25,
-        'regex': [r'([\w-]+\.){2,}[\w-]+']
-        }
-}
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
diff --git a/benchmark/LFA_benchmark.py b/benchmark/LFA_benchmark.py
index a01af8fe..56253c3d 100644
--- a/benchmark/LFA_benchmark.py
+++ b/benchmark/LFA_benchmark.py
@@ -5,109 +5,10 @@
 from logparser import LFA, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'LFA_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?']
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+']
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+']
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?']
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+']
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+']
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+']
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s']
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}']
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b']
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': []
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+']
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        },
-        
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+']
-        }
-}
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
diff --git a/benchmark/LKE_benchmark.py b/benchmark/LKE_benchmark.py
index 89c8c797..db4d6a74 100644
--- a/benchmark/LKE_benchmark.py
+++ b/benchmark/LKE_benchmark.py
@@ -5,126 +5,10 @@
 from logparser import LKE, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'LKE_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'split_threshold': 3
-        },
-
-    'Hadoop': {
-        'log_file':  'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'split_threshold': 2 
-        # 3
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'split_threshold': 5
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'split_threshold': 20
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'split_threshold': 30
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'split_threshold': 10
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'split_threshold': 2
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'split_threshold': 4
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'split_threshold': 10
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'split_threshold': 260,
-        },
-    
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'split_threshold': 50, 
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'split_threshold': 5
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        'split_threshold': 3
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'split_threshold': 100
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'split_threshold': 8
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'split_threshold': 600
-        }
-}
-
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
diff --git a/benchmark/Lenma_benchmark.py b/benchmark/Lenma_benchmark.py
index 20cba376..6d640cf9 100644
--- a/benchmark/Lenma_benchmark.py
+++ b/benchmark/Lenma_benchmark.py
@@ -5,129 +5,10 @@
 from logparser import LenMa, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'Lenma_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'threshold': 0.9
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+'],
-        'threshold': 0.9
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'threshold': 0.9
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'threshold': 0.9
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'threshold': 0.7
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'threshold': 0.8
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'threshold': 0.6
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'threshold': 0.78
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'threshold': 0.88
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'threshold': 0.86
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'threshold': 0.5
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'CT': 0.3,
-        'lowerBound': 0.4,
-        'regex': [r'(\d+\.){3}\d+'],
-        'threshold': 0.91
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'CT': 0.3,
-        'lowerBound': 0.25,
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        'threshold': 1
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'threshold': 0.9
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'threshold': 1
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'threshold': 0.86
-        },
-}
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
diff --git a/benchmark/LogCluster_benchmark.py b/benchmark/LogCluster_benchmark.py
index 9901a600..bc4cdb17 100644
--- a/benchmark/LogCluster_benchmark.py
+++ b/benchmark/LogCluster_benchmark.py
@@ -5,125 +5,10 @@
 from logparser import LogCluster, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'LogCluster_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'rsupport': 10
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+'],
-        'rsupport': 10
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'rsupport': 10
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'rsupport': 0.5
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'rsupport': 2
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'rsupport': 0.1
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'rsupport': 2
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'rsupport': 0.2
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'rsupport': 40
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'rsupport': 1,
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'rsupport': 7,
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'rsupport': 30
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'\b[KGTM]?B\b'],
-        'rsupport': 10
-        },
-
-   'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'rsupport': 0.1,
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'rsupport': 3,
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'rsupport': 0.2,
-        },
-}
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
diff --git a/benchmark/LogMine_benchmark.py b/benchmark/LogMine_benchmark.py
index ff5c77bc..301c3fff 100644
--- a/benchmark/LogMine_benchmark.py
+++ b/benchmark/LogMine_benchmark.py
@@ -5,156 +5,10 @@
 from logparser import LogMine, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'LogMine_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'max_dist': 0.005,
-        'k': 1,
-        'levels': 2
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+'],
-        'max_dist': 0.005,
-        'k': 1,
-        'levels': 2
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'max_dist': 0.01,
-        'k': 1,
-        'levels': 2
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'max_dist': 0.001,
-        'k': 1,
-        'levels': 2
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'max_dist': 0.01,
-        'k': 2,
-        'levels': 2
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'max_dist': 0.0001,
-        'k': 0.8,
-        'levels': 2
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'max_dist': 0.005,
-        'k': 1,
-        'levels': 2
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'max_dist': 0.003,
-        'k': 1,
-        'levels': 2
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'max_dist': 0.006,
-        'k': 1,
-        'levels': 2
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'max_dist': 0.01,
-        'k': 1     ,   
-        'levels': 2
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'max_dist': 0.008,
-        'k': 1,
-        'levels': 2
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'max_dist': 0.005,
-        'k': 1,
-        'levels': 2
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        'max_dist': 0.002,
-        'k': 1,
-        'levels': 2
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'max_dist': 0.001,
-        'k': 1,
-        'levels': 2
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'max_dist': 0.001,
-        'k': 0.1,
-        'levels': 2
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'max_dist': 0.004,
-        'k': 1,
-        'levels': 2
-        },
-}
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
diff --git a/benchmark/LogSettings.py b/benchmark/LogSettings.py
new file mode 100644
index 00000000..b36f4e2c
--- /dev/null
+++ b/benchmark/LogSettings.py
@@ -0,0 +1,369 @@
+input_dir = '../logs/' # The input directory of the log file
+
+benchmark_settings = {
+    'HDFS': {
+        'log_file': 'HDFS/HDFS_2k.log', # The input log file name
+        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
+        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'], # Regular expression list for optional preprocessing (default: [])
+        'minEventCount': 2, # AEL: The minimum number of events in a bin
+        'merge_percent': 0.5, # AEL: The percentage of different tokens
+        'st': 0.5, # Drain: Similarity threshold
+        'depth': 4, # Drain: Depth of all leaf nodes
+        'CT': 0.35, # IPLoM: The cluster goodness threshold (default: 0.35)
+        'lowerBound': 0.25, # IPLoM: The lower bound distance (default: 0.25)
+        'threshold': 0.9, # TODO Lenma: description (default: 0.9)
+        'split_threshold': 3, # LKE: The threshold used to determine group splitting (default: 4)
+        'rsupport': 10, # LogCluster: The minimum threshold of relative support, 10 denotes 10%
+        'k': 1, # LogMine: The message distance weight (default: 1)
+        'levels': 2, # LogMine: The levels of hierarchy of patterns
+        'groupNum': 15, # LogSig: The number of message groups to partition
+        'mergeThreshold': 0.1, # SHISO: Threshold for searching the most similar template in the children
+        'formatLookupThreshold': 0.3, # SHISO: Lowerbound to find the most similar node to adjust
+        'superFormatThreshold': 0.85, # SHISO: Threshold of average LCS length, determing whether or not to create a super format
+        'support': 120, # SLCT: The minimum support threshold
+        'tau': 0.7 # Spell: Message type threshold (default: 0.5)
+    },
+
+    'Hadoop': {
+        'log_file': 'Hadoop/Hadoop_2k.log',
+        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>',
+        'regex': [r'(\d+\.){3}\d+'],
+        'minEventCount': 2,
+        'merge_percent': 0.4,
+        'st': 0.5,
+        'depth': 4,
+        'CT': 0.4,
+        'lowerBound': 0.2,
+        'threshold': 0.9,
+        'split_threshold': 2,
+        'rsupport': 10,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 30,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 125,
+        'tau': 0.7
+    },
+
+    'Spark': {
+        'log_file': 'Spark/Spark_2k.log',
+        'log_format': '<Date> <Time> <Level> <Component>: <Content>',
+        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
+        'minEventCount': 2,
+        'merge_percent': 0.4,
+        'CT': 0.35,
+        'lowerBound': 0.3,
+        'threshold': 0.9,
+        'split_threshold': 5,
+        'rsupport': 10,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 20,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 30,
+        'tau': 0.55
+    },
+
+    'Zookeeper': {
+        'log_file': 'Zookeeper/Zookeeper_2k.log',
+        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
+        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
+        'minEventCount': 2,
+        'merge_percent': 0.4,
+        'st': 0.5,
+        'depth': 4,
+        'CT': 0.4,
+        'lowerBound': 0.7,
+        'threshold': 0.9,
+        'split_threshold': 20,
+        'rsupport': 0.5,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 46,
+        'mergeThreshold': 0.003,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 10,
+        'tau': 0.7
+    },
+
+    'BGL': {
+        'log_file': 'BGL/BGL_2k.log',
+        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
+        'regex': [r'core\.\d+'],
+        'minEventCount': 2,
+        'merge_percent': 0.5,
+        'st': 0.5,
+        'depth': 4,
+        'CT': 0.4,
+        'lowerBound': 0.01,
+        'threshold': 0.7,
+        'split_threshold': 30,
+        'rsupport': 2,
+        'k': 2,
+        'levels': 2,
+        'groupNum': 500,
+        'mergeThreshold': 0.005,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 6,
+        'tau': 0.75
+    },
+
+    'HPC': {
+        'log_file': 'HPC/HPC_2k.log',
+        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
+        'regex': [r'=\d+'],
+        'minEventCount': 5,
+        'merge_percent': 0.4,
+        'st': 0.5,
+        'depth': 4,
+        'CT': 0.58,
+        'lowerBound': 0.25,
+        'threshold': 0.8,
+        'split_threshold': 10,
+        'rsupport': 0.1,
+        'k': 0.8,
+        'levels': 2,
+        'groupNum': 800,
+        'mergeThreshold': 0.003,
+        'formatLookupThreshold': 0.6,
+        'superFormatThreshold': 0.4,
+        'support': 7,
+        'tau': 0.65
+    },
+
+    'Thunderbird': {
+        'log_file': 'Thunderbird/Thunderbird_2k.log',
+        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
+        'regex': [r'(\d+\.){3}\d+'],
+        'minEventCount': 2,
+        'merge_percent': 0.4,
+        'st': 0.5,
+        'depth': 4,
+        'CT': 0.3,
+        'lowerBound': 0.2,
+        'threshold': 0.6,
+        'split_threshold': 2,
+        'rsupport': 2,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 25,
+        'mergeThreshold': 0.0002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 10,
+        'tau': 0.5
+    },
+
+    'Windows': {
+        'log_file': 'Windows/Windows_2k.log',
+        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
+        'regex': [r'0x.*?\s'],
+        'minEventCount': 2,
+        'merge_percent': 0.4,
+        'st': 0.7,
+        'depth': 5,
+        'CT': 0.3,
+        'lowerBound': 0.25,
+        'threshold': 0.78,
+        'split_threshold': 4,
+        'rsupport': 0.2,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 42,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 3,
+        'tau': 0.7
+    },
+
+    'Linux': {
+        'log_file': 'Linux/Linux_2k.log',
+        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
+        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
+        'minEventCount': 2,
+        'merge_percent': 0.6,
+        'st': 0.39,
+        'depth': 6,
+        'CT': 0.3,
+        'lowerBound': 0.3,
+        'threshold': 0.88,
+        'split_threshold': 10,
+        'rsupport': 40,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 25,
+        'mergeThreshold': 0.005,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.4,
+        'support': 100,
+        'tau': 0.55
+    },
+
+    'Andriod': {
+        'log_file': 'Andriod/Andriod_2k.log',
+        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
+        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
+        'minEventCount': 2,
+        'merge_percent': 0.6,
+        'st': 0.2,
+        'depth': 6,
+        'CT': 0.25,
+        'lowerBound': 0.3,
+        'threshold': 0.86,
+        'split_threshold': 260,
+        'rsupport': 1,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 900,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 1,
+        'tau': 0.95
+    },
+
+    'HealthApp': {
+        'log_file': 'HealthApp/HealthApp_2k.log',
+        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
+        'regex': [],
+        'minEventCount': 2,
+        'merge_percent': 0.6,
+        'st': 0.2,
+        'depth': 4,
+        'CT': 0.25,
+        'lowerBound': 0.3,
+        'threshold': 0.5,
+        'split_threshold': 50,
+        'rsupport': 7,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 200,
+        'mergeThreshold': 0.0001,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 100,
+        'tau': 0.5
+    },
+
+    'Apache': {
+        'log_file': 'Apache/Apache_2k.log',
+        'log_format': '\[<Time>\] \[<Level>\] <Content>',
+        'regex': [r'(\d+\.){3}\d+'],
+        'minEventCount': 2,
+        'merge_percent': 0.4,
+        'st': 0.5,
+        'depth': 4,
+        'CT': 0.3,
+        'lowerBound': 0.4,
+        'threshold': 0.91,
+        'split_threshold': 5,
+        'rsupport': 30,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 8,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 5,
+        'tau': 0.6
+    },
+
+    'Proxifier': {
+        'log_file': 'Proxifier/Proxifier_2k.log',
+        'log_format': '\[<Time>\] <Program> - <Content>',
+        'regex': [r'<\d+\s?sec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
+        'minEventCount': 2,
+        'merge_percent': 0.4,
+        'st': 0.6,
+        'depth': 3,
+        'CT': 0.9,
+        'lowerBound': 0.25,
+        'threshold': 1,
+        'split_threshold': 3,
+        'rsupport': 10,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 10,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 8,
+        'tau': 0.85
+    },
+
+    'OpenSSH': {
+        'log_file': 'OpenSSH/OpenSSH_2k.log',
+        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
+        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
+        'minEventCount': 10,
+        'merge_percent': 0.7,
+        'st': 0.6,
+        'depth': 5,
+        'CT': 0.78,
+        'lowerBound': 0.25,
+        'threshold': 0.9,
+        'split_threshold': 100,
+        'rsupport': 0.1,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 40,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 45,
+        'tau': 0.8
+    },
+
+    'OpenStack': {
+        'log_file': 'OpenStack/OpenStack_2k.log',
+        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
+        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
+        'minEventCount': 6,
+        'merge_percent': 0.5,
+        'st': 0.5,
+        'depth': 5,
+        'CT': 0.9,
+        'lowerBound': 0.25,
+        'threshold': 1,
+        'split_threshold': 8,
+        'rsupport': 3,
+        'k': 0.1,
+        'levels': 2,
+        'groupNum': 50,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 18,
+        'tau': 0.9
+    },
+
+    'Mac': {
+        'log_file': 'Mac/Mac_2k.log',
+        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
+        'regex': [r'([\w-]+\.){2,}[\w-]+'],
+        'minEventCount': 2,
+        'merge_percent': 0.6,
+        'st': 0.7,
+        'depth': 6,
+        'CT': 0.3,
+        'lowerBound': 0.25,
+        'threshold': 0.86,
+        'split_threshold': 600,
+        'rsupport': 0.2,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 250,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 3,
+        'tau': 0.6
+    }
+}
diff --git a/benchmark/LogSig_benchmark.py b/benchmark/LogSig_benchmark.py
index daa0aaf1..2d9d4ea5 100644
--- a/benchmark/LogSig_benchmark.py
+++ b/benchmark/LogSig_benchmark.py
@@ -5,123 +5,11 @@
 from logparser import LogSig, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'LogSig_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'groupNum': 15
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'groupNum': 30
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'groupNum': 20
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'groupNum': 46
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'groupNum': 500
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'groupNum': 800
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'groupNum': 25
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'groupNum': 42
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'groupNum': 25
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'groupNum': 900
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'groupNum': 200
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'groupNum': 8
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        'groupNum': 10
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'groupNum': 40
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'groupNum': 50
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'groupNum': 250  
-        },
-}
+from LogSettings import benchmark_settings, input_dir
 
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
diff --git a/benchmark/MoLFI_benchmark.py b/benchmark/MoLFI_benchmark.py
index 648216e9..4ba8d2a9 100644
--- a/benchmark/MoLFI_benchmark.py
+++ b/benchmark/MoLFI_benchmark.py
@@ -5,109 +5,10 @@
 from logparser import MoLFI, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'MoLFI_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?']
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+']
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+']
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?']
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+']
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+']
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+']
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s']
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}']
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b']
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': []
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+']
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        },
-        
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+']
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+']
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+']
-        }
-}
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.items():
     print('\n=== Evaluation on %s ==='%dataset)
diff --git a/benchmark/SHISO_benchmark.py b/benchmark/SHISO_benchmark.py
index 8e60fdc9..e98f7373 100644
--- a/benchmark/SHISO_benchmark.py
+++ b/benchmark/SHISO_benchmark.py
@@ -5,173 +5,10 @@
 from logparser import SHISO, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'SHISO_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.1,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.003,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.005,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'maxChildNum': 3,
-        'mergeThreshold': 0.003,
-        'formatLookupThreshold': 0.6,
-        'superFormatThreshold': 0.4
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.0002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'maxChildNum': 3,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'maxChildNum': 3,
-        'mergeThreshold': 0.005,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.4
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85        
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.0001,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85        
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'\b[KGTM]?B\b'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'maxChildNum': 4,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85
-    },
-}
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
diff --git a/benchmark/SLCT_benchmark.py b/benchmark/SLCT_benchmark.py
index 46fb7cdd..7257116f 100644
--- a/benchmark/SLCT_benchmark.py
+++ b/benchmark/SLCT_benchmark.py
@@ -4,126 +4,10 @@
 from logparser import SLCT, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/' # The input directory of log file
 output_dir = 'SLCT_result/' # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'support': 120
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+'],
-        'support': 125
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'support': 30
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'support': 10
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'support': 6
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'support': 7
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'support': 10
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'support': 3
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'support': 100
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'support': 1
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'support': 100
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'support': 5
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        'support': 8
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'support': 45
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'support': 18
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'support': 3
-        }
-}
-
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
diff --git a/benchmark/Spell_benchmark.py b/benchmark/Spell_benchmark.py
index eb95d073..386c1704 100644
--- a/benchmark/Spell_benchmark.py
+++ b/benchmark/Spell_benchmark.py
@@ -5,125 +5,10 @@
 from logparser import Spell, evaluator
 import os
 import pandas as pd
+from LogSettings import benchmark_settings, input_dir
 
-
-input_dir = '../logs/'  # The input directory of log file
 output_dir = 'Spell_result/'  # The output directory of parsing results
 
-benchmark_settings = {
-    'HDFS': {
-        'log_file': 'HDFS/HDFS_2k.log',
-        'log_format': '<Date> <Time> <Pid> <Level> <Component>: <Content>',
-        'regex': [r'blk_-?\d+', r'(\d+\.){3}\d+(:\d+)?'],
-        'tau': 0.7
-        },
-
-    'Hadoop': {
-        'log_file': 'Hadoop/Hadoop_2k.log',
-        'log_format': '<Date> <Time> <Level> \[<Process>\] <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+'],
-        'tau': 0.7
-        },
-
-    'Spark': {
-        'log_file': 'Spark/Spark_2k.log',
-        'log_format': '<Date> <Time> <Level> <Component>: <Content>', 
-        'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
-        'tau': 0.55
-        },
-
-    'Zookeeper': {
-        'log_file': 'Zookeeper/Zookeeper_2k.log',
-        'log_format': '<Date> <Time> - <Level>  \[<Node>:<Component>@<Id>\] - <Content>',
-        'regex': [r'(/|)(\d+\.){3}\d+(:\d+)?'],
-        'tau': 0.7
-        },
-
-    'BGL': {
-        'log_file': 'BGL/BGL_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <Node> <Time> <NodeRepeat> <Type> <Component> <Level> <Content>',
-        'regex': [r'core\.\d+'],
-        'tau': 0.75
-        },
-
-    'HPC': {
-        'log_file': 'HPC/HPC_2k.log',
-        'log_format': '<LogId> <Node> <Component> <State> <Time> <Flag> <Content>',
-        'regex': [r'=\d+'],
-        'tau': 0.65
-        },
-
-    'Thunderbird': {
-        'log_file': 'Thunderbird/Thunderbird_2k.log',
-        'log_format': '<Label> <Timestamp> <Date> <User> <Month> <Day> <Time> <Location> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'tau': 0.5
-        },
-
-    'Windows': {
-        'log_file': 'Windows/Windows_2k.log',
-        'log_format': '<Date> <Time>, <Level>                  <Component>    <Content>',
-        'regex': [r'0x.*?\s'],
-        'tau': 0.7
-        },
-
-    'Linux': {
-        'log_file': 'Linux/Linux_2k.log',
-        'log_format': '<Month> <Date> <Time> <Level> <Component>(\[<PID>\])?: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'\d{2}:\d{2}:\d{2}'],
-        'tau': 0.55
-        },
-
-    'Andriod': {
-        'log_file': 'Andriod/Andriod_2k.log',
-        'log_format': '<Date> <Time>  <Pid>  <Tid> <Level> <Component>: <Content>',
-        'regex': [r'(/[\w-]+)+', r'([\w-]+\.){2,}[\w-]+', r'\b(\-?\+?\d+)\b|\b0[Xx][a-fA-F\d]+\b|\b[a-fA-F\d]{4,}\b'],
-        'tau': 0.95
-        },
-
-    'HealthApp': {
-        'log_file': 'HealthApp/HealthApp_2k.log',
-        'log_format': '<Time>\|<Component>\|<Pid>\|<Content>',
-        'regex': [],
-        'tau': 0.5
-        },
-
-    'Apache': {
-        'log_file': 'Apache/Apache_2k.log',
-        'log_format': '\[<Time>\] \[<Level>\] <Content>',
-        'regex': [r'(\d+\.){3}\d+'],
-        'tau': 0.6
-        },
-
-    'Proxifier': {
-        'log_file': 'Proxifier/Proxifier_2k.log',
-        'log_format': '\[<Time>\] <Program> - <Content>',
-        'regex': [r'<\d+\ssec', r'([\w-]+\.)+[\w-]+(:\d+)?', r'\d{2}:\d{2}(:\d{2})*', r'[KGTM]B'],
-        'tau': 0.85
-        },
-
-    'OpenSSH': {
-        'log_file': 'OpenSSH/OpenSSH_2k.log',
-        'log_format': '<Date> <Day> <Time> <Component> sshd\[<Pid>\]: <Content>',
-        'regex': [r'(\d+\.){3}\d+', r'([\w-]+\.){2,}[\w-]+'],
-        'tau': 0.8
-        },
-
-    'OpenStack': {
-        'log_file': 'OpenStack/OpenStack_2k.log',
-        'log_format': '<Logrecord> <Date> <Time> <Pid> <Level> <Component> \[<ADDR>\] <Content>',
-        'regex': [r'((\d+\.){3}\d+,?)+', r'/.+?\s', r'\d+'],
-        'tau': 0.9
-        },
-
-    'Mac': {
-        'log_file': 'Mac/Mac_2k.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [r'([\w-]+\.){2,}[\w-]+'],
-        'tau': 0.6
-        },
-}
-
 bechmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)

From 7e4f8882aa4ff9846aaab7085921336c179a8f3d Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Wed, 12 Jan 2022 12:25:14 +0100
Subject: [PATCH 02/13] fixed typos

---
 README.md                         | 2 +-
 benchmark/AEL_benchmark.py        | 8 ++++----
 benchmark/Drain_benchmark.py      | 8 ++++----
 benchmark/IPLoM_benchmark.py      | 8 ++++----
 benchmark/LFA_benchmark.py        | 8 ++++----
 benchmark/LKE_benchmark.py        | 8 ++++----
 benchmark/Lenma_benchmark.py      | 8 ++++----
 benchmark/LogCluster_benchmark.py | 8 ++++----
 benchmark/LogMine_benchmark.py    | 8 ++++----
 benchmark/LogSig_benchmark.py     | 8 ++++----
 benchmark/MoLFI_benchmark.py      | 8 ++++----
 benchmark/SHISO_benchmark.py      | 8 ++++----
 benchmark/SLCT_benchmark.py       | 6 +++---
 benchmark/Spell_benchmark.py      | 8 ++++----
 14 files changed, 52 insertions(+), 52 deletions(-)

diff --git a/README.md b/README.md
index cf6dfb59..bbf93fd7 100644
--- a/README.md
+++ b/README.md
@@ -50,7 +50,7 @@ All the log parsers have been evaluated across 16 different logs available in [l
 <p align="center"><a href="https://arxiv.org/abs/1811.03509"><img src="./docs/img/parsers.png" width="768"></a></p>
 
 <details>
- <summary>:point_down: Check the detailed bechmarking result table (click to expand)</summary>
+ <summary>:point_down: Check the detailed benchmarking result table (click to expand)</summary>
  
  <p align="center"><a href="https://arxiv.org/abs/1811.03509"><img src="./docs/img/accuracy.png" width="908"></a></p>
  
diff --git a/benchmark/AEL_benchmark.py b/benchmark/AEL_benchmark.py
index 4ca2b7b9..13745473 100644
--- a/benchmark/AEL_benchmark.py
+++ b/benchmark/AEL_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'AEL_result/' # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.items():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -23,11 +23,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('AEL_bechmark_result.csv')
+df_result.T.to_csv('AEL_benchmark_result.csv')
diff --git a/benchmark/Drain_benchmark.py b/benchmark/Drain_benchmark.py
index 3ea7f2c7..ecf965d9 100644
--- a/benchmark/Drain_benchmark.py
+++ b/benchmark/Drain_benchmark.py
@@ -10,7 +10,7 @@
 output_dir = 'Drain_result/' # The output directory of parsing results
 
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -23,11 +23,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('Drain_bechmark_result.csv')
+df_result.T.to_csv('Drain_benchmark_result.csv')
diff --git a/benchmark/IPLoM_benchmark.py b/benchmark/IPLoM_benchmark.py
index 62a11563..d301c06c 100644
--- a/benchmark/IPLoM_benchmark.py
+++ b/benchmark/IPLoM_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'IPLoM_result/'  # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -23,11 +23,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('IPLoM_bechmark_result.csv')
+df_result.T.to_csv('IPLoM_benchmark_result.csv')
diff --git a/benchmark/LFA_benchmark.py b/benchmark/LFA_benchmark.py
index 56253c3d..683d2636 100644
--- a/benchmark/LFA_benchmark.py
+++ b/benchmark/LFA_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'LFA_result/' # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -22,11 +22,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('LFA_bechmark_result.csv')
+df_result.T.to_csv('LFA_benchmark_result.csv')
diff --git a/benchmark/LKE_benchmark.py b/benchmark/LKE_benchmark.py
index db4d6a74..e37d323e 100644
--- a/benchmark/LKE_benchmark.py
+++ b/benchmark/LKE_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'LKE_result/' # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -23,10 +23,10 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('LKE_bechmark_result.csv')
+df_result.T.to_csv('LKE_benchmark_result.csv')
diff --git a/benchmark/Lenma_benchmark.py b/benchmark/Lenma_benchmark.py
index 6d640cf9..730631ff 100644
--- a/benchmark/Lenma_benchmark.py
+++ b/benchmark/Lenma_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'Lenma_result/' # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -22,11 +22,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('Lenma_bechmark_result.csv')
+df_result.T.to_csv('Lenma_benchmark_result.csv')
diff --git a/benchmark/LogCluster_benchmark.py b/benchmark/LogCluster_benchmark.py
index bc4cdb17..71697a00 100644
--- a/benchmark/LogCluster_benchmark.py
+++ b/benchmark/LogCluster_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'LogCluster_result/' # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -22,11 +22,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('LogCluster_bechmark_result.csv')
+df_result.T.to_csv('LogCluster_benchmark_result.csv')
diff --git a/benchmark/LogMine_benchmark.py b/benchmark/LogMine_benchmark.py
index 301c3fff..895ec960 100644
--- a/benchmark/LogMine_benchmark.py
+++ b/benchmark/LogMine_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'LogMine_result/' # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -24,11 +24,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('LogMine_bechmark_result.csv')
+df_result.T.to_csv('LogMine_benchmark_result.csv')
diff --git a/benchmark/LogSig_benchmark.py b/benchmark/LogSig_benchmark.py
index 2d9d4ea5..f0fec632 100644
--- a/benchmark/LogSig_benchmark.py
+++ b/benchmark/LogSig_benchmark.py
@@ -11,7 +11,7 @@
 
 from LogSettings import benchmark_settings, input_dir
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -24,10 +24,10 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('LogSig_bechmark_result.csv')
+df_result.T.to_csv('LogSig_benchmark_result.csv')
diff --git a/benchmark/MoLFI_benchmark.py b/benchmark/MoLFI_benchmark.py
index 4ba8d2a9..57a85ea5 100644
--- a/benchmark/MoLFI_benchmark.py
+++ b/benchmark/MoLFI_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'MoLFI_result/' # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.items():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -22,11 +22,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('MoLFI_bechmark_result.csv')
+df_result.T.to_csv('MoLFI_benchmark_result.csv')
diff --git a/benchmark/SHISO_benchmark.py b/benchmark/SHISO_benchmark.py
index e98f7373..f8f9bdcd 100644
--- a/benchmark/SHISO_benchmark.py
+++ b/benchmark/SHISO_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'SHISO_result/' # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -24,11 +24,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('SHISO_bechmark_result.csv')
+df_result.T.to_csv('SHISO_benchmark_result.csv')
diff --git a/benchmark/SLCT_benchmark.py b/benchmark/SLCT_benchmark.py
index 7257116f..8b338e9d 100644
--- a/benchmark/SLCT_benchmark.py
+++ b/benchmark/SLCT_benchmark.py
@@ -8,7 +8,7 @@
 
 output_dir = 'SLCT_result/' # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -22,11 +22,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
 df_result.T.to_csv('SLCT_benchmark_result.csv')
diff --git a/benchmark/Spell_benchmark.py b/benchmark/Spell_benchmark.py
index 386c1704..cd378486 100644
--- a/benchmark/Spell_benchmark.py
+++ b/benchmark/Spell_benchmark.py
@@ -9,7 +9,7 @@
 
 output_dir = 'Spell_result/'  # The output directory of parsing results
 
-bechmark_result = []
+benchmark_result = []
 for dataset, setting in benchmark_settings.iteritems():
     print('\n=== Evaluation on %s ==='%dataset)
     indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
@@ -23,11 +23,11 @@
                            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
                            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
                            )
-    bechmark_result.append([dataset, F1_measure, accuracy])
+    benchmark_result.append([dataset, F1_measure, accuracy])
 
 
 print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
+df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
 df_result.set_index('Dataset', inplace=True)
 print(df_result)
-df_result.T.to_csv('Spell_bechmark_result.csv')
+df_result.T.to_csv('Spell_benchmark_result.csv')

From 34cb409d07ec7734c115e8e68e6a39fad338c5fa Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Wed, 12 Jan 2022 18:09:40 +0100
Subject: [PATCH 03/13] remove dupicate code

---
 .gitignore                        |  1 +
 benchmark/AEL_benchmark.py        | 33 -------------
 benchmark/Benchmark.py            | 77 +++++++++++++++++++++++++++++++
 benchmark/Drain_benchmark.py      | 33 -------------
 benchmark/IPLoM_benchmark.py      | 33 -------------
 benchmark/LFA_benchmark.py        | 32 -------------
 benchmark/LKE_benchmark.py        | 32 -------------
 benchmark/Lenma_benchmark.py      | 32 -------------
 benchmark/LogCluster_benchmark.py | 32 -------------
 benchmark/LogMine_benchmark.py    | 34 --------------
 benchmark/LogSettings.py          | 34 ++++++++++++++
 benchmark/LogSig_benchmark.py     | 33 -------------
 benchmark/MoLFI_benchmark.py      | 32 -------------
 benchmark/SHISO_benchmark.py      | 34 --------------
 benchmark/SLCT_benchmark.py       | 32 -------------
 benchmark/Spell_benchmark.py      | 33 -------------
 16 files changed, 112 insertions(+), 425 deletions(-)
 delete mode 100644 benchmark/AEL_benchmark.py
 create mode 100644 benchmark/Benchmark.py
 delete mode 100644 benchmark/Drain_benchmark.py
 delete mode 100644 benchmark/IPLoM_benchmark.py
 delete mode 100644 benchmark/LFA_benchmark.py
 delete mode 100644 benchmark/LKE_benchmark.py
 delete mode 100644 benchmark/Lenma_benchmark.py
 delete mode 100644 benchmark/LogCluster_benchmark.py
 delete mode 100644 benchmark/LogMine_benchmark.py
 delete mode 100644 benchmark/LogSig_benchmark.py
 delete mode 100644 benchmark/MoLFI_benchmark.py
 delete mode 100644 benchmark/SHISO_benchmark.py
 delete mode 100644 benchmark/SLCT_benchmark.py
 delete mode 100644 benchmark/Spell_benchmark.py

diff --git a/.gitignore b/.gitignore
index 8ad09ebf..f6da5bc9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 # Self-defined
 *result/
+*benchmark_result.csv
 slct
 
 # Byte-compiled / optimized / DLL files
diff --git a/benchmark/AEL_benchmark.py b/benchmark/AEL_benchmark.py
deleted file mode 100644
index 13745473..00000000
--- a/benchmark/AEL_benchmark.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import AEL, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'AEL_result/' # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.items():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = AEL.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir,
-                             minEventCount=setting['minEventCount'], merge_percent=setting['merge_percent'], rex=setting['regex'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('AEL_benchmark_result.csv')
diff --git a/benchmark/Benchmark.py b/benchmark/Benchmark.py
new file mode 100644
index 00000000..c2db1355
--- /dev/null
+++ b/benchmark/Benchmark.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+
+import sys
+sys.path.append('../')
+from logparser import evaluator, AEL, Drain, IPLoM, LenMa, LFA, LKE, LogCluster, LogMine, LogSig,  SHISO, SLCT, Spell
+from LogSettings import benchmark_settings, input_dir
+import pandas as pd
+import os
+
+
+# How to construct a parser for specific parameters
+parsers = {
+    "AEL": lambda setting: AEL.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir,
+                                         minEventCount=setting['minEventCount'], merge_percent=setting['merge_percent'], rex=setting['regex']),
+    "Drain": lambda setting: Drain.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], depth=setting['depth'], st=setting['st']),
+    "IPLoM": lambda setting: IPLoM.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir,
+                                             CT=setting['CT'], lowerBound=setting['lowerBound'], rex=setting['regex']),
+    "Lenma": lambda setting: LenMa.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], threshold=setting['threshold']),
+    "LFA": lambda setting: LFA.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex']),
+    "LKE": lambda setting: LKE.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'],
+                                         split_threshold=setting['split_threshold']),
+    "LogCluster": lambda setting: LogCluster.LogParser(indir, setting['log_format'], output_dir, rex=setting['regex'], rsupport=setting['rsupport']),
+    "LogMine": lambda setting: LogMine.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir,
+                                                 rex=setting['regex'], max_dist=setting['max_dist'], k=setting['k'],
+                                                 levels=setting['levels']),
+    "LogSig": lambda setting: LogSig.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], groupNum=setting['groupNum']),
+    #"MoLFI": lambda setting: MoLFI.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex']),
+    "SHISO": lambda setting: SHISO.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'],
+                                             maxChildNum=setting['maxChildNum'], mergeThreshold=setting['mergeThreshold'],
+                                             formatLookupThreshold=setting['formatLookupThreshold'], superFormatThreshold=setting['superFormatThreshold']),
+    "SLCT": lambda setting: SLCT.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir,
+                                           rex=setting['regex'], support=setting['support']),
+    "Spell": lambda setting:  Spell.LogParser(log_format=setting['log_format'], indir=indir,
+                                              outdir=output_dir, rex=setting['regex'], tau=setting['tau'])
+}
+
+bm_parsers = []
+for arg in sys.argv:
+  if arg in parsers:
+    bm_parsers.append(arg)
+if bm_parsers == []:
+  bm_parsers = parsers.keys()
+
+bm_datasets = []
+for arg in sys.argv:
+  if arg in benchmark_settings.keys():
+    bm_datasets.append(arg)
+if bm_datasets == []:
+  bm_datasets = benchmark_settings.keys()
+
+print("\n== Benchmarking " + ', '.join(bm_parsers) + " on " + ', '.join(bm_datasets) + " ==\n")
+
+for bm_parser_name in bm_parsers:
+    bm_parser = parsers[bm_parser_name]
+    # The output directory of parsing results
+    output_dir = bm_parser_name + '_result/'
+    benchmark_result = []
+    for dataset, setting in benchmark_settings.iteritems():
+        if not (dataset in bm_datasets):
+          continue
+        print('\n=== Evaluation of %s on %s ===' % (bm_parser_name, dataset))
+        indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
+        log_file = os.path.basename(setting['log_file'])
+        bm_parser(setting).parse(log_file)
+
+        F1_measure, accuracy = evaluator.evaluate(
+            groundtruth=os.path.join(indir, log_file + '_structured.csv'),
+            parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
+        )
+        benchmark_result.append([dataset, F1_measure, accuracy])
+
+    print('\n=== Overall evaluation results ===')
+    df_result = pd.DataFrame(benchmark_result, columns=[
+                             'Dataset', 'F1_measure', 'Accuracy'])
+    df_result.set_index('Dataset', inplace=True)
+    print(df_result)
+    df_result.T.to_csv(bm_parser_name + '_benchmark_result.csv')
diff --git a/benchmark/Drain_benchmark.py b/benchmark/Drain_benchmark.py
deleted file mode 100644
index ecf965d9..00000000
--- a/benchmark/Drain_benchmark.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import Drain, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'Drain_result/' # The output directory of parsing results
-
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = Drain.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], depth=setting['depth'], st=setting['st'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('Drain_benchmark_result.csv')
diff --git a/benchmark/IPLoM_benchmark.py b/benchmark/IPLoM_benchmark.py
deleted file mode 100644
index d301c06c..00000000
--- a/benchmark/IPLoM_benchmark.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import IPLoM, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'IPLoM_result/'  # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = IPLoM.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir,
-                             CT=setting['CT'], lowerBound=setting['lowerBound'], rex=setting['regex'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('IPLoM_benchmark_result.csv')
diff --git a/benchmark/LFA_benchmark.py b/benchmark/LFA_benchmark.py
deleted file mode 100644
index 683d2636..00000000
--- a/benchmark/LFA_benchmark.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LFA, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'LFA_result/' # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = LFA.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('LFA_benchmark_result.csv')
diff --git a/benchmark/LKE_benchmark.py b/benchmark/LKE_benchmark.py
deleted file mode 100644
index e37d323e..00000000
--- a/benchmark/LKE_benchmark.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LKE, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'LKE_result/' # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = LKE.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], 
-                           split_threshold=setting['split_threshold'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('LKE_benchmark_result.csv')
diff --git a/benchmark/Lenma_benchmark.py b/benchmark/Lenma_benchmark.py
deleted file mode 100644
index 730631ff..00000000
--- a/benchmark/Lenma_benchmark.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LenMa, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'Lenma_result/' # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = LenMa.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], threshold=setting['threshold'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('Lenma_benchmark_result.csv')
diff --git a/benchmark/LogCluster_benchmark.py b/benchmark/LogCluster_benchmark.py
deleted file mode 100644
index 71697a00..00000000
--- a/benchmark/LogCluster_benchmark.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LogCluster, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'LogCluster_result/' # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = LogCluster.LogParser(indir, setting['log_format'], output_dir, rex=setting['regex'], rsupport=setting['rsupport'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('LogCluster_benchmark_result.csv')
diff --git a/benchmark/LogMine_benchmark.py b/benchmark/LogMine_benchmark.py
deleted file mode 100644
index 895ec960..00000000
--- a/benchmark/LogMine_benchmark.py
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LogMine, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'LogMine_result/' # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = LogMine.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, 
-                               rex=setting['regex'], max_dist=setting['max_dist'], k=setting['k'], 
-                               levels=setting['levels'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('LogMine_benchmark_result.csv')
diff --git a/benchmark/LogSettings.py b/benchmark/LogSettings.py
index b36f4e2c..bc77971d 100644
--- a/benchmark/LogSettings.py
+++ b/benchmark/LogSettings.py
@@ -14,9 +14,11 @@
         'threshold': 0.9, # TODO Lenma: description (default: 0.9)
         'split_threshold': 3, # LKE: The threshold used to determine group splitting (default: 4)
         'rsupport': 10, # LogCluster: The minimum threshold of relative support, 10 denotes 10%
+        'max_dist': 0.005,
         'k': 1, # LogMine: The message distance weight (default: 1)
         'levels': 2, # LogMine: The levels of hierarchy of patterns
         'groupNum': 15, # LogSig: The number of message groups to partition
+        'maxChildNum': 4,
         'mergeThreshold': 0.1, # SHISO: Threshold for searching the most similar template in the children
         'formatLookupThreshold': 0.3, # SHISO: Lowerbound to find the most similar node to adjust
         'superFormatThreshold': 0.85, # SHISO: Threshold of average LCS length, determing whether or not to create a super format
@@ -37,9 +39,11 @@
         'threshold': 0.9,
         'split_threshold': 2,
         'rsupport': 10,
+        'max_dist': 0.005,
         'k': 1,
         'levels': 2,
         'groupNum': 30,
+        'maxChildNum': 4,
         'mergeThreshold': 0.002,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -53,14 +57,18 @@
         'regex': [r'(\d+\.){3}\d+', r'\b[KGTM]?B\b', r'([\w-]+\.){2,}[\w-]+'],
         'minEventCount': 2,
         'merge_percent': 0.4,
+        'st': 0.5,
+        'depth': 4,
         'CT': 0.35,
         'lowerBound': 0.3,
         'threshold': 0.9,
         'split_threshold': 5,
         'rsupport': 10,
+        'max_dist': 0.01,
         'k': 1,
         'levels': 2,
         'groupNum': 20,
+        'maxChildNum': 4,
         'mergeThreshold': 0.002,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -81,9 +89,11 @@
         'threshold': 0.9,
         'split_threshold': 20,
         'rsupport': 0.5,
+        'max_dist': 0.001,
         'k': 1,
         'levels': 2,
         'groupNum': 46,
+        'maxChildNum': 4,
         'mergeThreshold': 0.003,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -104,9 +114,11 @@
         'threshold': 0.7,
         'split_threshold': 30,
         'rsupport': 2,
+        'max_dist': 0.01,
         'k': 2,
         'levels': 2,
         'groupNum': 500,
+        'maxChildNum': 4,
         'mergeThreshold': 0.005,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -127,9 +139,11 @@
         'threshold': 0.8,
         'split_threshold': 10,
         'rsupport': 0.1,
+        'max_dist': 0.0001,
         'k': 0.8,
         'levels': 2,
         'groupNum': 800,
+        'maxChildNum': 3,
         'mergeThreshold': 0.003,
         'formatLookupThreshold': 0.6,
         'superFormatThreshold': 0.4,
@@ -150,9 +164,11 @@
         'threshold': 0.6,
         'split_threshold': 2,
         'rsupport': 2,
+        'max_dist': 0.005,
         'k': 1,
         'levels': 2,
         'groupNum': 25,
+        'maxChildNum': 4,
         'mergeThreshold': 0.0002,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -173,10 +189,12 @@
         'threshold': 0.78,
         'split_threshold': 4,
         'rsupport': 0.2,
+        'max_dist': 0.003,
         'k': 1,
         'levels': 2,
         'groupNum': 42,
         'mergeThreshold': 0.002,
+        'maxChildNum': 3,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
         'support': 3,
@@ -196,9 +214,11 @@
         'threshold': 0.88,
         'split_threshold': 10,
         'rsupport': 40,
+        'max_dist': 0.006,
         'k': 1,
         'levels': 2,
         'groupNum': 25,
+        'maxChildNum': 3,
         'mergeThreshold': 0.005,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.4,
@@ -219,9 +239,11 @@
         'threshold': 0.86,
         'split_threshold': 260,
         'rsupport': 1,
+        'max_dist': 0.01,
         'k': 1,
         'levels': 2,
         'groupNum': 900,
+        'maxChildNum': 4,
         'mergeThreshold': 0.002,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -242,9 +264,11 @@
         'threshold': 0.5,
         'split_threshold': 50,
         'rsupport': 7,
+        'max_dist': 0.008,
         'k': 1,
         'levels': 2,
         'groupNum': 200,
+        'maxChildNum': 4,
         'mergeThreshold': 0.0001,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -265,9 +289,11 @@
         'threshold': 0.91,
         'split_threshold': 5,
         'rsupport': 30,
+        'max_dist': 0.005,
         'k': 1,
         'levels': 2,
         'groupNum': 8,
+        'maxChildNum': 4,
         'mergeThreshold': 0.002,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -288,9 +314,11 @@
         'threshold': 1,
         'split_threshold': 3,
         'rsupport': 10,
+        'max_dist': 0.002,
         'k': 1,
         'levels': 2,
         'groupNum': 10,
+        'maxChildNum': 4,
         'mergeThreshold': 0.002,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -311,9 +339,11 @@
         'threshold': 0.9,
         'split_threshold': 100,
         'rsupport': 0.1,
+        'max_dist': 0.001,
         'k': 1,
         'levels': 2,
         'groupNum': 40,
+        'maxChildNum': 4,
         'mergeThreshold': 0.002,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -334,9 +364,11 @@
         'threshold': 1,
         'split_threshold': 8,
         'rsupport': 3,
+        'max_dist': 0.001,
         'k': 0.1,
         'levels': 2,
         'groupNum': 50,
+        'maxChildNum': 4,
         'mergeThreshold': 0.002,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
@@ -357,9 +389,11 @@
         'threshold': 0.86,
         'split_threshold': 600,
         'rsupport': 0.2,
+        'max_dist': 0.004,
         'k': 1,
         'levels': 2,
         'groupNum': 250,
+        'maxChildNum': 4,
         'mergeThreshold': 0.002,
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.85,
diff --git a/benchmark/LogSig_benchmark.py b/benchmark/LogSig_benchmark.py
deleted file mode 100644
index f0fec632..00000000
--- a/benchmark/LogSig_benchmark.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LogSig, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'LogSig_result/' # The output directory of parsing results
-
-from LogSettings import benchmark_settings, input_dir
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = LogSig.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], groupNum=setting['groupNum'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('LogSig_benchmark_result.csv')
diff --git a/benchmark/MoLFI_benchmark.py b/benchmark/MoLFI_benchmark.py
deleted file mode 100644
index 57a85ea5..00000000
--- a/benchmark/MoLFI_benchmark.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import MoLFI, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'MoLFI_result/' # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.items():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = MoLFI.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('MoLFI_benchmark_result.csv')
diff --git a/benchmark/SHISO_benchmark.py b/benchmark/SHISO_benchmark.py
deleted file mode 100644
index f8f9bdcd..00000000
--- a/benchmark/SHISO_benchmark.py
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import SHISO, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'SHISO_result/' # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = SHISO.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'],
-                            maxChildNum=setting['maxChildNum'], mergeThreshold=setting['mergeThreshold'],
-                            formatLookupThreshold=setting['formatLookupThreshold'], superFormatThreshold=setting['superFormatThreshold'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('SHISO_benchmark_result.csv')
diff --git a/benchmark/SLCT_benchmark.py b/benchmark/SLCT_benchmark.py
deleted file mode 100644
index 8b338e9d..00000000
--- a/benchmark/SLCT_benchmark.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-import sys
-sys.path.append('../')
-from logparser import SLCT, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'SLCT_result/' # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = SLCT.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, 
-                            rex=setting['regex'], support=setting['support'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('SLCT_benchmark_result.csv')
diff --git a/benchmark/Spell_benchmark.py b/benchmark/Spell_benchmark.py
deleted file mode 100644
index cd378486..00000000
--- a/benchmark/Spell_benchmark.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import Spell, evaluator
-import os
-import pandas as pd
-from LogSettings import benchmark_settings, input_dir
-
-output_dir = 'Spell_result/'  # The output directory of parsing results
-
-benchmark_result = []
-for dataset, setting in benchmark_settings.iteritems():
-    print('\n=== Evaluation on %s ==='%dataset)
-    indir = os.path.join(input_dir, os.path.dirname(setting['log_file']))
-    log_file = os.path.basename(setting['log_file'])
-
-    parser = Spell.LogParser(log_format=setting['log_format'], indir=indir,
-                             outdir=output_dir, rex=setting['regex'], tau=setting['tau'])
-    parser.parse(log_file)
-    
-    F1_measure, accuracy = evaluator.evaluate(
-                           groundtruth=os.path.join(indir, log_file + '_structured.csv'),
-                           parsedresult=os.path.join(output_dir, log_file + '_structured.csv')
-                           )
-    benchmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(benchmark_result, columns=['Dataset', 'F1_measure', 'Accuracy'])
-df_result.set_index('Dataset', inplace=True)
-print(df_result)
-df_result.T.to_csv('Spell_benchmark_result.csv')

From 3ff399e021c532c9dc914b703a75f0008342bbb8 Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Mon, 17 Jan 2022 10:33:55 +0100
Subject: [PATCH 04/13] added parameter comments

---
 benchmark/LogSettings.py | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/benchmark/LogSettings.py b/benchmark/LogSettings.py
index bc77971d..e322492a 100644
--- a/benchmark/LogSettings.py
+++ b/benchmark/LogSettings.py
@@ -14,11 +14,11 @@
         'threshold': 0.9, # TODO Lenma: description (default: 0.9)
         'split_threshold': 3, # LKE: The threshold used to determine group splitting (default: 4)
         'rsupport': 10, # LogCluster: The minimum threshold of relative support, 10 denotes 10%
-        'max_dist': 0.005,
+        'max_dist': 0.005, # LogMine: The maximum distance between any log message in a cluster and the cluster representative
         'k': 1, # LogMine: The message distance weight (default: 1)
         'levels': 2, # LogMine: The levels of hierarchy of patterns
         'groupNum': 15, # LogSig: The number of message groups to partition
-        'maxChildNum': 4,
+        'maxChildNum': 4, # SHISO: The maximum number of children for each internal node
         'mergeThreshold': 0.1, # SHISO: Threshold for searching the most similar template in the children
         'formatLookupThreshold': 0.3, # SHISO: Lowerbound to find the most similar node to adjust
         'superFormatThreshold': 0.85, # SHISO: Threshold of average LCS length, determing whether or not to create a super format
@@ -399,5 +399,29 @@
         'superFormatThreshold': 0.85,
         'support': 3,
         'tau': 0.6
+    },
+    'messages': {
+        'log_file': 'SSH.log',
+        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
+        'regex': [],
+        'minEventCount': 2,
+        'merge_percent': 0.6,
+        'st': 0.7,
+        'depth': 6,
+        'CT': 0.3,
+        'lowerBound': 0.25,
+        'threshold': 0.86,
+        'split_threshold': 600,
+        'rsupport': 0.2,
+        'max_dist': 0.004,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 250,
+        'maxChildNum': 4,
+        'mergeThreshold': 0.002,
+        'formatLookupThreshold': 0.3,
+        'superFormatThreshold': 0.85,
+        'support': 3,
+        'tau': 0.6
     }
 }

From cb88196ccce2886f184638121fff4cbc271f9873 Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Fri, 4 Mar 2022 19:10:58 +0100
Subject: [PATCH 05/13] ready for python3

---
 benchmark/Benchmark.py                        |  2 +-
 benchmark/LogSettings.py                      | 24 -------------------
 logparser/AEL/AEL.py                          |  2 +-
 logparser/Drain/Drain.py                      |  2 +-
 logparser/IPLoM/IPLoM.py                      |  2 +-
 logparser/LFA/LFA.py                          |  2 +-
 logparser/LFA/__init__.py                     |  2 +-
 logparser/LKE/LKE.py                          |  2 +-
 logparser/LKE/__init__.py                     |  2 +-
 logparser/LenMa/LenMa.py                      |  4 ++--
 logparser/LenMa/__init__.py                   |  2 +-
 .../LenMa/templateminer/lenma_template.py     |  6 ++---
 logparser/LogCluster/LogCluster.py            |  2 +-
 logparser/LogCluster/__init__.py              |  2 +-
 logparser/LogMine/LogMine.py                  | 18 +++++++-------
 logparser/LogMine/__init__.py                 |  2 +-
 logparser/LogSig/LogSig.py                    |  2 +-
 logparser/LogSig/__init__.py                  |  2 +-
 .../MoLFI/main/org/core/operators/mutation.py |  2 +-
 .../org/core/utility/Chromosome_Generator.py  |  2 +-
 .../core/utility/log_message_adaptation.py    |  2 +-
 .../MoLFI/main/org/core/validation/oracle.py  |  2 +-
 .../utility/test_log_message_adaptation.py    |  2 +-
 logparser/SHISO/SHISO.py                      |  4 ++--
 logparser/SHISO/__init__.py                   |  2 +-
 logparser/SLCT/SLCT.py                        |  2 +-
 logparser/SLCT/__init__.py                    |  2 +-
 logparser/Spell/Spell.py                      |  2 +-
 logparser/logmatch/regexmatch.py              |  2 +-
 logparser/utils/evaluator.py                  |  8 +++----
 logparser/utils/logloader.py                  |  2 +-
 31 files changed, 45 insertions(+), 69 deletions(-)

diff --git a/benchmark/Benchmark.py b/benchmark/Benchmark.py
index c2db1355..c480bc43 100644
--- a/benchmark/Benchmark.py
+++ b/benchmark/Benchmark.py
@@ -55,7 +55,7 @@
     # The output directory of parsing results
     output_dir = bm_parser_name + '_result/'
     benchmark_result = []
-    for dataset, setting in benchmark_settings.iteritems():
+    for dataset, setting in benchmark_settings.items():
         if not (dataset in bm_datasets):
           continue
         print('\n=== Evaluation of %s on %s ===' % (bm_parser_name, dataset))
diff --git a/benchmark/LogSettings.py b/benchmark/LogSettings.py
index e322492a..fe1d2029 100644
--- a/benchmark/LogSettings.py
+++ b/benchmark/LogSettings.py
@@ -399,29 +399,5 @@
         'superFormatThreshold': 0.85,
         'support': 3,
         'tau': 0.6
-    },
-    'messages': {
-        'log_file': 'SSH.log',
-        'log_format': '<Month>  <Date> <Time> <User> <Component>\[<PID>\]( \(<Address>\))?: <Content>',
-        'regex': [],
-        'minEventCount': 2,
-        'merge_percent': 0.6,
-        'st': 0.7,
-        'depth': 6,
-        'CT': 0.3,
-        'lowerBound': 0.25,
-        'threshold': 0.86,
-        'split_threshold': 600,
-        'rsupport': 0.2,
-        'max_dist': 0.004,
-        'k': 1,
-        'levels': 2,
-        'groupNum': 250,
-        'maxChildNum': 4,
-        'mergeThreshold': 0.002,
-        'formatLookupThreshold': 0.3,
-        'superFormatThreshold': 0.85,
-        'support': 3,
-        'tau': 0.6
     }
 }
diff --git a/logparser/AEL/AEL.py b/logparser/AEL/AEL.py
index c643daa5..0d2ed154 100644
--- a/logparser/AEL/AEL.py
+++ b/logparser/AEL/AEL.py
@@ -5,7 +5,7 @@
 """
 
 import sys
-import re
+import regex as re
 import os
 import hashlib
 import pandas as pd
diff --git a/logparser/Drain/Drain.py b/logparser/Drain/Drain.py
index 258a3b22..a27d17b6 100644
--- a/logparser/Drain/Drain.py
+++ b/logparser/Drain/Drain.py
@@ -4,7 +4,7 @@
 License     : MIT
 """
 
-import re
+import regex as re
 import os
 import numpy as np
 import pandas as pd
diff --git a/logparser/IPLoM/IPLoM.py b/logparser/IPLoM/IPLoM.py
index e862b82a..f50dfccb 100644
--- a/logparser/IPLoM/IPLoM.py
+++ b/logparser/IPLoM/IPLoM.py
@@ -9,7 +9,7 @@
 from datetime import datetime
 import os
 import gc
-import re
+import regex as re
 import pandas as pd
 import hashlib
 import string
diff --git a/logparser/LFA/LFA.py b/logparser/LFA/LFA.py
index 9d097910..565782ca 100644
--- a/logparser/LFA/LFA.py
+++ b/logparser/LFA/LFA.py
@@ -7,7 +7,7 @@
 import sys
 import os
 import gc
-import re
+import regex as re
 import hashlib
 import math
 import pandas as pd
diff --git a/logparser/LFA/__init__.py b/logparser/LFA/__init__.py
index 64221587..13b67f55 100644
--- a/logparser/LFA/__init__.py
+++ b/logparser/LFA/__init__.py
@@ -1 +1 @@
-from LFA import *
\ No newline at end of file
+from .LFA import *
\ No newline at end of file
diff --git a/logparser/LKE/LKE.py b/logparser/LKE/LKE.py
index 09c567b6..f841416d 100644
--- a/logparser/LKE/LKE.py
+++ b/logparser/LKE/LKE.py
@@ -7,7 +7,7 @@
 import math
 from datetime import datetime
 from ..logmatch import regexmatch
-import re
+import regex as re
 import os
 import sys
 import pandas as pd
diff --git a/logparser/LKE/__init__.py b/logparser/LKE/__init__.py
index 3c902905..53ef7893 100644
--- a/logparser/LKE/__init__.py
+++ b/logparser/LKE/__init__.py
@@ -1 +1 @@
-from LKE import *
\ No newline at end of file
+from .LKE import *
\ No newline at end of file
diff --git a/logparser/LenMa/LenMa.py b/logparser/LenMa/LenMa.py
index 3075ee92..5491da7f 100644
--- a/logparser/LenMa/LenMa.py
+++ b/logparser/LenMa/LenMa.py
@@ -4,9 +4,9 @@
 License: MIT
 """
 
-from templateminer import lenma_template 
+from .templateminer import lenma_template 
 import pandas as pd
-import re
+import regex as re
 import os
 import hashlib
 from collections import defaultdict
diff --git a/logparser/LenMa/__init__.py b/logparser/LenMa/__init__.py
index 3cd28764..04b74a9f 100644
--- a/logparser/LenMa/__init__.py
+++ b/logparser/LenMa/__init__.py
@@ -1 +1 @@
-from LenMa import *
+from .LenMa import *
diff --git a/logparser/LenMa/templateminer/lenma_template.py b/logparser/LenMa/templateminer/lenma_template.py
index cb5e0ca7..057197ad 100644
--- a/logparser/LenMa/templateminer/lenma_template.py
+++ b/logparser/LenMa/templateminer/lenma_template.py
@@ -8,9 +8,9 @@
 import numpy as np
 from sklearn.metrics import accuracy_score
 from sklearn.metrics.pairwise import cosine_similarity
-import template
+from .template import Template, TemplateManager
 
-class LenmaTemplate(template.Template):
+class LenmaTemplate(Template):
     def __init__(self, index=None, words=None, logid=None, json=None):
         if json is not None:
             # restore from the jsonized data.
@@ -146,7 +146,7 @@ def print_wordlens(self):
     def get_logids(self):
         return self._logid
 
-class LenmaTemplateManager(template.TemplateManager):
+class LenmaTemplateManager(TemplateManager):
     def __init__(self,
                  threshold=0.9,
                  predefined_templates=None):
diff --git a/logparser/LogCluster/LogCluster.py b/logparser/LogCluster/LogCluster.py
index 25f2c403..722041bb 100644
--- a/logparser/LogCluster/LogCluster.py
+++ b/logparser/LogCluster/LogCluster.py
@@ -6,7 +6,7 @@
 
 import os
 import pandas as pd
-import re
+import regex as re
 import hashlib
 from datetime import datetime
 import subprocess
diff --git a/logparser/LogCluster/__init__.py b/logparser/LogCluster/__init__.py
index 186c4f19..8fd7ef28 100644
--- a/logparser/LogCluster/__init__.py
+++ b/logparser/LogCluster/__init__.py
@@ -1 +1 @@
-from LogCluster import *
\ No newline at end of file
+from .LogCluster import *
\ No newline at end of file
diff --git a/logparser/LogMine/LogMine.py b/logparser/LogMine/LogMine.py
index 0221703e..0ba8443e 100644
--- a/logparser/LogMine/LogMine.py
+++ b/logparser/LogMine/LogMine.py
@@ -5,9 +5,9 @@
 """
 
 import sys
-import re
+import regex as re
 import os
-import alignment
+from .alignment import *
 import copy
 import hashlib
 import pandas as pd
@@ -126,14 +126,14 @@ def pair_merge(self, loga, logb):
         return " ".join(logn)
 
     def print_cluster(self, cluster):
-        print "------start------"
-        print "level: {}".format(cluster.level)
-        print "idxs: {}".format(cluster.logs_idx)
-        print "patterns: {}".format(cluster.patterns)
-        print "count: {}".format(len(cluster.patterns))
+        print("------start------")
+        print("level: {}".format(cluster.level))
+        print("idxs: {}".format(cluster.logs_idx))
+        print("patterns: {}".format(cluster.patterns))
+        print("count: {}".format(len(cluster.patterns)))
         for idx in cluster.logs_idx:
-            print self.df_log.iloc[idx]['Content_']
-        print "------end------"
+            print(self.df_log.iloc[idx]['Content_'])
+        print("------end------")
 
     def msgDist(self, seqP, seqQ):
         dis = 1
diff --git a/logparser/LogMine/__init__.py b/logparser/LogMine/__init__.py
index 9de008a5..fea2ea3e 100644
--- a/logparser/LogMine/__init__.py
+++ b/logparser/LogMine/__init__.py
@@ -1 +1 @@
-from LogMine import *
\ No newline at end of file
+from .LogMine import *
\ No newline at end of file
diff --git a/logparser/LogSig/LogSig.py b/logparser/LogSig/LogSig.py
index 9fa7aa78..da3b2264 100644
--- a/logparser/LogSig/LogSig.py
+++ b/logparser/LogSig/LogSig.py
@@ -9,7 +9,7 @@
 import math
 import time
 import operator
-import re
+import regex as re
 import os
 import pandas as pd
 import hashlib
diff --git a/logparser/LogSig/__init__.py b/logparser/LogSig/__init__.py
index f7ed9430..d5c4ee0e 100644
--- a/logparser/LogSig/__init__.py
+++ b/logparser/LogSig/__init__.py
@@ -1 +1 @@
-from LogSig import *
\ No newline at end of file
+from .LogSig import *
\ No newline at end of file
diff --git a/logparser/MoLFI/main/org/core/operators/mutation.py b/logparser/MoLFI/main/org/core/operators/mutation.py
index 012d1514..af7b7d0b 100644
--- a/logparser/MoLFI/main/org/core/operators/mutation.py
+++ b/logparser/MoLFI/main/org/core/operators/mutation.py
@@ -1,5 +1,5 @@
 import random
-import re
+import regex as re
 
 from numpy.core.defchararray import startswith
 from ..chromosome.chromosome import Chromosome
diff --git a/logparser/MoLFI/main/org/core/utility/Chromosome_Generator.py b/logparser/MoLFI/main/org/core/utility/Chromosome_Generator.py
index 6e229c88..585e1aac 100644
--- a/logparser/MoLFI/main/org/core/utility/Chromosome_Generator.py
+++ b/logparser/MoLFI/main/org/core/utility/Chromosome_Generator.py
@@ -1,5 +1,5 @@
 import random
-import re
+import regex as re
 import hashlib
 import sys
 from contextlib import suppress
diff --git a/logparser/MoLFI/main/org/core/utility/log_message_adaptation.py b/logparser/MoLFI/main/org/core/utility/log_message_adaptation.py
index 41bcc642..01baa110 100644
--- a/logparser/MoLFI/main/org/core/utility/log_message_adaptation.py
+++ b/logparser/MoLFI/main/org/core/utility/log_message_adaptation.py
@@ -1,4 +1,4 @@
-import re
+import regex as re
 
 from numpy.core.defchararray import startswith
 
diff --git a/logparser/MoLFI/main/org/core/validation/oracle.py b/logparser/MoLFI/main/org/core/validation/oracle.py
index 35cb5058..5219574f 100644
--- a/logparser/MoLFI/main/org/core/validation/oracle.py
+++ b/logparser/MoLFI/main/org/core/validation/oracle.py
@@ -1,4 +1,4 @@
-import re
+import regex as re
 
 
 class OracleTemplates:
diff --git a/logparser/MoLFI/test/org/core/utility/test_log_message_adaptation.py b/logparser/MoLFI/test/org/core/utility/test_log_message_adaptation.py
index 5aed3790..e3e5f633 100644
--- a/logparser/MoLFI/test/org/core/utility/test_log_message_adaptation.py
+++ b/logparser/MoLFI/test/org/core/utility/test_log_message_adaptation.py
@@ -1,4 +1,4 @@
-import re
+import regex as re
 import unittest
 
 from numpy.core.defchararray import startswith
diff --git a/logparser/SHISO/SHISO.py b/logparser/SHISO/SHISO.py
index 813bf9ee..4dc8836b 100644
--- a/logparser/SHISO/SHISO.py
+++ b/logparser/SHISO/SHISO.py
@@ -4,11 +4,11 @@
 License     : MIT
 """
 
-import re
+import regex as re
 import os
 import time
 from nltk import ngrams
-from Queue import *
+from queue import *
 import numpy as np
 import pandas as pd
 import hashlib
diff --git a/logparser/SHISO/__init__.py b/logparser/SHISO/__init__.py
index 99931274..c4641790 100644
--- a/logparser/SHISO/__init__.py
+++ b/logparser/SHISO/__init__.py
@@ -1 +1 @@
-from SHISO import *
\ No newline at end of file
+from .SHISO import *
\ No newline at end of file
diff --git a/logparser/SLCT/SLCT.py b/logparser/SLCT/SLCT.py
index 6184a8f2..2d03d664 100644
--- a/logparser/SLCT/SLCT.py
+++ b/logparser/SLCT/SLCT.py
@@ -8,7 +8,7 @@
 
 import hashlib
 import pandas as pd
-import re
+import regex as re
 from datetime import datetime
 from ..logmatch import regexmatch
 import subprocess
diff --git a/logparser/SLCT/__init__.py b/logparser/SLCT/__init__.py
index a97e7d73..3e7d343e 100644
--- a/logparser/SLCT/__init__.py
+++ b/logparser/SLCT/__init__.py
@@ -1 +1 @@
-from SLCT import *
\ No newline at end of file
+from .SLCT import *
\ No newline at end of file
diff --git a/logparser/Spell/Spell.py b/logparser/Spell/Spell.py
index 259ba892..9bf7ed78 100644
--- a/logparser/Spell/Spell.py
+++ b/logparser/Spell/Spell.py
@@ -5,7 +5,7 @@
 """
 
 import sys
-import re
+import regex as re
 import os
 import numpy as np
 import pandas as pd
diff --git a/logparser/logmatch/regexmatch.py b/logparser/logmatch/regexmatch.py
index 7d7510cc..ea3a2eea 100644
--- a/logparser/logmatch/regexmatch.py
+++ b/logparser/logmatch/regexmatch.py
@@ -29,7 +29,7 @@
 
 from ..utils import logloader
 from collections import defaultdict, Counter, OrderedDict
-import re
+import regex as re
 import pandas as pd
 import os
 from datetime import datetime
diff --git a/logparser/utils/evaluator.py b/logparser/utils/evaluator.py
index 1595d919..a37e816b 100644
--- a/logparser/utils/evaluator.py
+++ b/logparser/utils/evaluator.py
@@ -7,7 +7,7 @@
 import sys
 import pandas as pd
 from collections import defaultdict
-import scipy.misc
+import scipy.special
 
 
 def evaluate(groundtruth, parsedresult):
@@ -58,13 +58,13 @@ def get_accuracy(series_groundtruth, series_parsedlog, debug=False):
     real_pairs = 0
     for count in series_groundtruth_valuecounts:
         if count > 1:
-            real_pairs += scipy.misc.comb(count, 2)
+            real_pairs += scipy.special.comb(count, 2)
 
     series_parsedlog_valuecounts = series_parsedlog.value_counts()
     parsed_pairs = 0
     for count in series_parsedlog_valuecounts:
         if count > 1:
-            parsed_pairs += scipy.misc.comb(count, 2)
+            parsed_pairs += scipy.special.comb(count, 2)
 
     accurate_pairs = 0
     accurate_events = 0 # determine how many lines are correctly parsed
@@ -82,7 +82,7 @@ def get_accuracy(series_groundtruth, series_parsedlog, debug=False):
             print('(parsed_eventId, groundtruth_eventId) =', error_eventIds, 'failed', logIds.size, 'messages')
         for count in series_groundtruth_logId_valuecounts:
             if count > 1:
-                accurate_pairs += scipy.misc.comb(count, 2)
+                accurate_pairs += scipy.special.comb(count, 2)
 
     precision = float(accurate_pairs) / parsed_pairs
     recall = float(accurate_pairs) / real_pairs
diff --git a/logparser/utils/logloader.py b/logparser/utils/logloader.py
index a9980b72..22c22bb4 100644
--- a/logparser/utils/logloader.py
+++ b/logparser/utils/logloader.py
@@ -24,7 +24,7 @@
 
 import sys
 import pandas as pd
-import re
+import regex as re
 import multiprocessing as mp
 from itertools import groupby, count, chain
 import numpy as np

From 6d3a139c5224b08a2774cf3656125ab2d635d930 Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Fri, 4 Mar 2022 20:07:45 +0100
Subject: [PATCH 06/13] Fix bug that prevents IPLoM from terminating

---
 logparser/IPLoM/IPLoM.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/logparser/IPLoM/IPLoM.py b/logparser/IPLoM/IPLoM.py
index f50dfccb..58e4a192 100644
--- a/logparser/IPLoM/IPLoM.py
+++ b/logparser/IPLoM/IPLoM.py
@@ -628,7 +628,7 @@ def get_parameter_list(self, row):
         if "<*>" not in template_regex: return []
         template_regex = re.sub(r'([^A-Za-z0-9])', r'\\\1', template_regex)
         template_regex = re.sub(r'\\ +', r'[^A-Za-z0-9]+', template_regex)
-        template_regex = "^" + template_regex.replace("\<\*\>", "(.*?)") + "$"
+        template_regex = "^" + template_regex.replace("\<\*\>", "(.*)") + "$"
         parameter_list = re.findall(template_regex, row["Content"])
         parameter_list = parameter_list[0] if parameter_list else ()
         parameter_list = list(parameter_list) if isinstance(parameter_list, tuple) else [parameter_list]

From d101e9bfd5b4fb8cf9d4f610a3434184d8f96d81 Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Fri, 4 Mar 2022 20:21:38 +0100
Subject: [PATCH 07/13] activate MoLFI

---
 benchmark/Benchmark.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/benchmark/Benchmark.py b/benchmark/Benchmark.py
index c480bc43..5db72097 100644
--- a/benchmark/Benchmark.py
+++ b/benchmark/Benchmark.py
@@ -2,7 +2,7 @@
 
 import sys
 sys.path.append('../')
-from logparser import evaluator, AEL, Drain, IPLoM, LenMa, LFA, LKE, LogCluster, LogMine, LogSig,  SHISO, SLCT, Spell
+from logparser import evaluator, AEL, Drain, IPLoM, LenMa, LFA, LKE, LogCluster, LogMine, LogSig, MoLFI, SHISO, SLCT, Spell
 from LogSettings import benchmark_settings, input_dir
 import pandas as pd
 import os
@@ -24,7 +24,7 @@
                                                  rex=setting['regex'], max_dist=setting['max_dist'], k=setting['k'],
                                                  levels=setting['levels']),
     "LogSig": lambda setting: LogSig.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], groupNum=setting['groupNum']),
-    #"MoLFI": lambda setting: MoLFI.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex']),
+    "MoLFI": lambda setting: MoLFI.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex']),
     "SHISO": lambda setting: SHISO.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'],
                                              maxChildNum=setting['maxChildNum'], mergeThreshold=setting['mergeThreshold'],
                                              formatLookupThreshold=setting['formatLookupThreshold'], superFormatThreshold=setting['superFormatThreshold']),

From 531733fded1f21c02197a97ad6c1639844c884ef Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Fri, 4 Mar 2022 20:21:48 +0100
Subject: [PATCH 08/13] add requirements.txt

---
 requirements.txt | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 requirements.txt

diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 00000000..d393b08f
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,4 @@
+deap
+numpy
+nltk
+pandas
\ No newline at end of file

From f922fa5fc98c533dbdb358ac27038698b3906f92 Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Fri, 4 Mar 2022 20:29:21 +0100
Subject: [PATCH 09/13] Complete requirements.txt

---
 requirements.txt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index d393b08f..f70a0a43 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,6 @@
 deap
 numpy
 nltk
-pandas
\ No newline at end of file
+pandas
+scipy
+sklearn
\ No newline at end of file

From 02d11559a779d0414c6f71715a61d109a41cb6e8 Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Sat, 5 Mar 2022 12:48:21 +0100
Subject: [PATCH 10/13] LogMine python3 compatible

---
 logparser/LogMine/LogMine.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/logparser/LogMine/LogMine.py b/logparser/LogMine/LogMine.py
index 0ba8443e..998b0fcc 100644
--- a/logparser/LogMine/LogMine.py
+++ b/logparser/LogMine/LogMine.py
@@ -119,7 +119,7 @@ def sequential_merge(self, logs):
         return log_merged
 
     def pair_merge(self, loga, logb):
-        loga, logb = alignment.water(loga.split(), logb.split())
+        loga, logb = water(loga.split(), logb.split())
         logn = []
         for idx, value in enumerate(loga):
             logn.append('<*>' if value != logb[idx] else value)

From e4a449de24205ddd56054eb1bf864486055215a8 Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Sat, 5 Mar 2022 22:39:50 +0100
Subject: [PATCH 11/13] SHISO and SLCT compatible with python3

---
 logparser/SHISO/SHISO.py         | 4 ++--
 logparser/logmatch/regexmatch.py | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/logparser/SHISO/SHISO.py b/logparser/SHISO/SHISO.py
index 4dc8836b..ae4e1efe 100644
--- a/logparser/SHISO/SHISO.py
+++ b/logparser/SHISO/SHISO.py
@@ -135,7 +135,7 @@ def Sim(self, seq1, seq2):
             i += 1
 
 
-        for idx in xrange(i, len(largeSeq)):
+        for idx in range(i, len(largeSeq)):
             word2 = largeSeq[i]
             numerator += self.wordDist( '', word2 )
 
@@ -326,7 +326,7 @@ def outputResult(self, node):
 
     def printTree(self, node, dep):
         pStr = ''   
-        for i in xrange(dep):
+        for i in range(dep):
             pStr += '\t'
 
         if len(node.format) == 0:
diff --git a/logparser/logmatch/regexmatch.py b/logparser/logmatch/regexmatch.py
index ea3a2eea..24ba5ceb 100644
--- a/logparser/logmatch/regexmatch.py
+++ b/logparser/logmatch/regexmatch.py
@@ -115,7 +115,7 @@ def match(self, log_filepath, template_filepath):
 
     def _dump_match_result(self, log_filename, log_dataframe):
         log_dataframe.to_csv(os.path.join(self.outdir, log_filename + '_structured.csv'), index=False)
-        template_freq_list = [[eventId, template, freq] for (eventId, template), freq in self.template_freq_dict.iteritems()]
+        template_freq_list = [[eventId, template, freq] for (eventId, template), freq in self.template_freq_dict.items()]
         template_freq_df = pd.DataFrame(template_freq_list, columns=['EventId', 'EventTemplate', 'Occurrences'])
         template_freq_df.to_csv(os.path.join(self.outdir, log_filename + '_templates.csv'), index=False)
 
@@ -148,7 +148,7 @@ def regex_match(msg, template_match_dict, optimized):
             if len(match_dict) > 1:
                 match_dict = OrderedDict(sorted(match_dict.items(), 
                      key=lambda x: (len(x[1][1]), -x[1][1].count('<*>')), reverse=True))
-            for regex, event in match_dict.iteritems():
+            for regex, event in match_dict.items():
                 parameter_list = re.findall(regex, msg.strip())
                 if parameter_list:
                     matched_event = event
@@ -160,7 +160,7 @@ def regex_match(msg, template_match_dict, optimized):
         if len(match_dict) > 1:
             match_dict = OrderedDict(sorted(match_dict.items(), 
                  key=lambda x: (len(x[1][1]), -x[1][1].count('<*>')), reverse=True))
-        for regex, event in match_dict.iteritems():
+        for regex, event in match_dict.items():
             parameter_list = re.findall(regex, msg.strip())
             if parameter_list:
                 matched_event = event

From 53b9d82a8c5e5a8f3fbb7b388938ae756aaf3d79 Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Sun, 6 Mar 2022 12:02:09 +0100
Subject: [PATCH 12/13] optimized parameters for Linux dataset

---
 benchmark/LogSettings.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/benchmark/LogSettings.py b/benchmark/LogSettings.py
index fe1d2029..99ee47e8 100644
--- a/benchmark/LogSettings.py
+++ b/benchmark/LogSettings.py
@@ -211,7 +211,7 @@
         'depth': 6,
         'CT': 0.3,
         'lowerBound': 0.3,
-        'threshold': 0.88,
+        'threshold': 0.8,
         'split_threshold': 10,
         'rsupport': 40,
         'max_dist': 0.006,
@@ -223,7 +223,7 @@
         'formatLookupThreshold': 0.3,
         'superFormatThreshold': 0.4,
         'support': 100,
-        'tau': 0.55
+        'tau': 0.6
     },
 
     'Andriod': {

From cecc6732ce057b4b981a62fdc1ec789abebed8a7 Mon Sep 17 00:00:00 2001
From: Juri Dispan <juri.dispan@uni-ulm.de>
Date: Sun, 6 Mar 2022 12:02:22 +0100
Subject: [PATCH 13/13] Lenma -> LenMa

---
 benchmark/Benchmark.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/benchmark/Benchmark.py b/benchmark/Benchmark.py
index 5db72097..19bb88f1 100644
--- a/benchmark/Benchmark.py
+++ b/benchmark/Benchmark.py
@@ -15,7 +15,7 @@
     "Drain": lambda setting: Drain.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], depth=setting['depth'], st=setting['st']),
     "IPLoM": lambda setting: IPLoM.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir,
                                              CT=setting['CT'], lowerBound=setting['lowerBound'], rex=setting['regex']),
-    "Lenma": lambda setting: LenMa.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], threshold=setting['threshold']),
+    "LenMa": lambda setting: LenMa.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'], threshold=setting['threshold']),
     "LFA": lambda setting: LFA.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex']),
     "LKE": lambda setting: LKE.LogParser(log_format=setting['log_format'], indir=indir, outdir=output_dir, rex=setting['regex'],
                                          split_threshold=setting['split_threshold']),