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/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
deleted file mode 100644
index 6064f262..00000000
--- a/benchmark/AEL_benchmark.py
+++ /dev/null
@@ -1,164 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import AEL, evaluator
-import os
-import pandas as pd
-
-
-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():
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/Benchmark.py b/benchmark/Benchmark.py
new file mode 100644
index 00000000..19bb88f1
--- /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, MoLFI, 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.items():
+        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 d42e1118..00000000
--- a/benchmark/Drain_benchmark.py
+++ /dev/null
@@ -1,163 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import Drain, evaluator
-import os
-import pandas as pd
-
-
-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():
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/IPLoM_benchmark.py b/benchmark/IPLoM_benchmark.py
deleted file mode 100644
index 0dcf04db..00000000
--- a/benchmark/IPLoM_benchmark.py
+++ /dev/null
@@ -1,164 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import IPLoM, evaluator
-import os
-import pandas as pd
-
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/LFA_benchmark.py b/benchmark/LFA_benchmark.py
deleted file mode 100644
index a01af8fe..00000000
--- a/benchmark/LFA_benchmark.py
+++ /dev/null
@@ -1,131 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LFA, evaluator
-import os
-import pandas as pd
-
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/LKE_benchmark.py b/benchmark/LKE_benchmark.py
deleted file mode 100644
index 89c8c797..00000000
--- a/benchmark/LKE_benchmark.py
+++ /dev/null
@@ -1,148 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LKE, evaluator
-import os
-import pandas as pd
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/Lenma_benchmark.py b/benchmark/Lenma_benchmark.py
deleted file mode 100644
index 20cba376..00000000
--- a/benchmark/Lenma_benchmark.py
+++ /dev/null
@@ -1,151 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LenMa, evaluator
-import os
-import pandas as pd
-
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/LogCluster_benchmark.py b/benchmark/LogCluster_benchmark.py
deleted file mode 100644
index 9901a600..00000000
--- a/benchmark/LogCluster_benchmark.py
+++ /dev/null
@@ -1,147 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LogCluster, evaluator
-import os
-import pandas as pd
-
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/LogMine_benchmark.py b/benchmark/LogMine_benchmark.py
deleted file mode 100644
index ff5c77bc..00000000
--- a/benchmark/LogMine_benchmark.py
+++ /dev/null
@@ -1,180 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LogMine, evaluator
-import os
-import pandas as pd
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/LogSettings.py b/benchmark/LogSettings.py
new file mode 100644
index 00000000..99ee47e8
--- /dev/null
+++ b/benchmark/LogSettings.py
@@ -0,0 +1,403 @@
+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%
+        '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, # 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
+        '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,
+        'max_dist': 0.005,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 30,
+        'maxChildNum': 4,
+        '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,
+        '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,
+        '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,
+        'max_dist': 0.001,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 46,
+        'maxChildNum': 4,
+        '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,
+        'max_dist': 0.01,
+        'k': 2,
+        'levels': 2,
+        'groupNum': 500,
+        'maxChildNum': 4,
+        '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,
+        'max_dist': 0.0001,
+        'k': 0.8,
+        'levels': 2,
+        'groupNum': 800,
+        'maxChildNum': 3,
+        '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,
+        'max_dist': 0.005,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 25,
+        'maxChildNum': 4,
+        '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,
+        'max_dist': 0.003,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 42,
+        'mergeThreshold': 0.002,
+        'maxChildNum': 3,
+        '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.8,
+        '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,
+        'support': 100,
+        'tau': 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,
+        'st': 0.2,
+        'depth': 6,
+        'CT': 0.25,
+        'lowerBound': 0.3,
+        '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,
+        '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,
+        'max_dist': 0.008,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 200,
+        'maxChildNum': 4,
+        '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,
+        'max_dist': 0.005,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 8,
+        'maxChildNum': 4,
+        '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,
+        'max_dist': 0.002,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 10,
+        'maxChildNum': 4,
+        '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,
+        'max_dist': 0.001,
+        'k': 1,
+        'levels': 2,
+        'groupNum': 40,
+        'maxChildNum': 4,
+        '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,
+        'max_dist': 0.001,
+        'k': 0.1,
+        'levels': 2,
+        'groupNum': 50,
+        'maxChildNum': 4,
+        '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,
+        '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/benchmark/LogSig_benchmark.py b/benchmark/LogSig_benchmark.py
deleted file mode 100644
index daa0aaf1..00000000
--- a/benchmark/LogSig_benchmark.py
+++ /dev/null
@@ -1,145 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import LogSig, evaluator
-import os
-import pandas as pd
-
-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  
-        },
-}
-
-bechmark_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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/MoLFI_benchmark.py b/benchmark/MoLFI_benchmark.py
deleted file mode 100644
index 648216e9..00000000
--- a/benchmark/MoLFI_benchmark.py
+++ /dev/null
@@ -1,131 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import MoLFI, evaluator
-import os
-import pandas as pd
-
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/SHISO_benchmark.py b/benchmark/SHISO_benchmark.py
deleted file mode 100644
index 8e60fdc9..00000000
--- a/benchmark/SHISO_benchmark.py
+++ /dev/null
@@ -1,197 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import SHISO, evaluator
-import os
-import pandas as pd
-
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
diff --git a/benchmark/SLCT_benchmark.py b/benchmark/SLCT_benchmark.py
deleted file mode 100644
index 46fb7cdd..00000000
--- a/benchmark/SLCT_benchmark.py
+++ /dev/null
@@ -1,148 +0,0 @@
-#!/usr/bin/env python
-import sys
-sys.path.append('../')
-from logparser import SLCT, evaluator
-import os
-import pandas as pd
-
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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 eb95d073..00000000
--- a/benchmark/Spell_benchmark.py
+++ /dev/null
@@ -1,148 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../')
-from logparser import Spell, evaluator
-import os
-import pandas as pd
-
-
-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)
-    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')
-                           )
-    bechmark_result.append([dataset, F1_measure, accuracy])
-
-
-print('\n=== Overall evaluation results ===')
-df_result = pd.DataFrame(bechmark_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')
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..58e4a192 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
@@ -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]
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..998b0fcc 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
@@ -119,21 +119,21 @@ 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)
         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..ae4e1efe 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
@@ -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/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..24ba5ceb 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
@@ -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
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
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 00000000..f70a0a43
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,6 @@
+deap
+numpy
+nltk
+pandas
+scipy
+sklearn
\ No newline at end of file