opener-opinion-detector-base 2.0.0

data/core/python-scripts/generate_folds.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+
+import sys
+import getopt
+import logging
+import os
+import random
+from shutil import rmtree
+
+
+def usage(cmd):
+    print>>sys.stderr,'Usage: '+cmd+' options'
+    print>>sys.stderr,'Options:'
+    print>>sys.stderr,'\t-f --file: input file with a list of documents (required)'
+    print>>sys.stderr,'\t-n --num: num of folds to create (required)'
+    print>>sys.stderr,'\t-o --out: name of the main folder to store the subfolds (required)'
+    print>>sys.stderr,'\t-s --subfolder: prefix for the subfolders (optional, default "fold")'
+    print>>sys.stderr
+    print>>sys.stderr,'Examples'
+    print>>sys.stderr,'\tgenerate_folds.py -f vu.doclist.attitude.ula.xbank --num 10 -o out_folder'
+    print>>sys.stderr,'\tgenerate_folds.py -f vu.doclist.attitude.ula.xbank --num 10 -o out_folder --subfolder my_custom_fold'
+
+
+def generate_folds(input_file,num_folds,out_folder,name_subfolder='fold'):    
+    # Load the input file
+    logging.debug('Loading elements from '+input_file)
+    elements = []
+    fic = open(input_file,'rU')
+    for line in fic:
+        elements.append(line.strip())
+    fic.close()
+    logging.debug('Loaded '+str(len(elements))+' elements')
+    
+    '''
+    ##Get just the %percent
+    percent = 25
+    original_len = len(elements)
+    new_len = original_len*percent/100
+    elements = elements[:new_len]
+    '''
+    
+    ## Creating folders and subfolders:
+    if os.path.exists(out_folder):
+        print>>sys.stderr,'Output folder '+out_folder,'already exists'
+        rmtree(out_folder)
+        print>>sys.stderr,'It has been removed...'
+        #sys.exit(-1)
+        
+    logging.debug('Creating '+out_folder+' and subfolders')
+    folds = []
+    os.mkdir(out_folder)
+    for n in range(num_folds):
+        my_name = os.path.join(out_folder,name_subfolder+'_'+str(n))
+        os.mkdir(my_name)
+        logging.debug('Created '+my_name)
+        folds.append(my_name)
+    ###################################################
+    
+    ## Creating folds
+    size_of_fold = len(elements) / num_folds
+    my_begin = 0
+    my_end = size_of_fold
+    
+    random.shuffle(elements)
+    for n in range(num_folds):
+        this_fold = folds[n]
+        my_test = elements[my_begin:my_end]
+        my_train = elements[:my_begin]+elements[my_end:]
+        if len( set(my_test) & set(my_train)) != 0:
+            print>>sys.stderr,'Error overlapping'
+            print>>sys.stderr,my_train
+            print>>sys.stderr,my_test
+        my_begin = my_end
+        my_end = my_end + size_of_fold
+        
+        #Save the folds
+        fic_train = open(os.path.join(this_fold,'train'),'w')
+        logging.debug('Writing info to '+fic_train.name)
+        for ele in my_train:
+            fic_train.write(ele+'\n')
+        fic_train.close()
+        
+        fic_test  =open(os.path.join(this_fold,'test'),'w')
+        logging.debug('Writing info to '+fic_test.name)
+        for ele in my_test:
+            fic_test.write(ele+'\n')
+        fic_test.close()
+    ####
+    logging.debug('Finished OK')
+
+if __name__ == '__main__':
+    logging.basicConfig(stream=sys.stderr,format='%(asctime)s - %(levelname)s - %(message)s',level=logging.DEBUG)
+
+    input_file = None
+    num_folds = None
+    out_folder = None
+    name_subfolder = 'fold'
+    
+    try:
+        opts, args = getopt.getopt(sys.argv[1:],"f:n:o:s:",["file=","num=","out=","subfolder="])
+        for opt, arg in opts:
+            if opt in ['-f','--file']:
+                input_file = arg
+            elif opt in ['-n','--num']:
+                num_folds = int(arg)
+            elif opt in ['-o','--out']:
+                out_folder = arg
+            elif opt in ['-s','--subfolder']:
+                name_subfolder = arg
+    except getopt.GetoptError as e:
+        print>>sys.stderr,'Warning: ',str(e)
+        
+    if input_file is None:
+        print>>sys.stderr,'ERROR!!!! Input file missing'
+        print
+        usage(sys.argv[0])
+        sys.exit(-1)
+        
+    if num_folds is None:
+        print>>sys.stderr,'ERROR!!!! Num of folds missing'
+        print
+        usage(sys.argv[0])
+        sys.exit(-1)
+        
+    if out_folder is None:
+        print>>sys.stderr,'ERROR!!!! Out folder missing'
+        print
+        usage(sys.argv[0])
+        sys.exit(-1)
+        
+    ###### END
+    generate_folds(input_file,num_folds,out_folder)    
+
+ 

data/core/python-scripts/models.cfg

@@ -0,0 +1,10 @@
+#LANG|domain|pathtomodel|description
+en|hotel|final_models/en/hotel_cfg1|Trained with config1 in the last version of hotel annotations
+en|news|final_models/en/news_cfg1|Trained with config1 using only the sentences annotated with news
+nl|hotel|final_models/nl/hotel_cfg1|Trained with config1 in the last version of hotel annotations
+nl|news|final_models/nl/news_cfg1|Trained with config1 using only the sentences annotated with news
+de|hotel|final_models/de/hotel_cfg1|Trained with config1 in the last version of hotel annotations
+de|news|final_models/de/news_cfg1|Trained with config1 using only the sentences annotated with news
+fr|hotel|final_models/fr/hotel_cfg1|Trained with config1 in the last version of hotel annotations
+it|hotel|final_models/it/hotel_cfg1|Trained with config1 in the last version of hotel annotations
+es|hotel|final_models/es/hotel_cfg1|Trained with config1 in the last version of hotel annotations

data/core/python-scripts/my_templates/README

@@ -0,0 +1,33 @@
+Format
+
+--> lines starting with # are skipped
+
+1 token -2 -1 0
+
+-> The first 1 is the length of the template, in this case unigram
+-> Then 'n' labels that will be used (must match with the labels generated
+ by the feature extractor)
+--> Then the positions, in case of 2grams 3grams each position must be
+--> n/m/p
+
+The example would generate these templates:
+('token',-2)
+('token',-1)
+('token',0)
+
+
+Example with bigrams
+2 token token -2/-1 -1/0 0/1 1/2
+
+would generate:
+(('token',-2),('token',-1))
+(('token',-1),('token',0))
+(('token',1),('token',1))
+
+
+Example with tigrams (the example makes no sense)
+3 token lemma pos -2/0/4 9/8/3
+(('token',-2),('lemma',0),('pos',4))
+(('token',9),('lemma',8),('pos',3))
+
+ 

data/core/python-scripts/my_templates/templates_exp.only0.txt

@@ -0,0 +1,6 @@
+1 token 0 -1 1
+1 lemma 0 -1 1
+1 pos 0 -1 1
+1 pol/mod 0 -1 1
+1 phrase_type 0 -1 1
+1 poldomain 0 -1 1

data/core/python-scripts/my_templates/templates_exp.pol0.txt

@@ -0,0 +1,10 @@
+# sentence_id token_id token lemma pos term_id pol/mod mpqa_subjectivity mpqa_polarity 
+# entity property phrase_type y
+
+1 token -2 -1 0 1 2
+1 lemma -2 -1 0 1 2
+1 pos -2 -1 0 1 2
+1 pol/mod 0
+1 mpqa_subjectivity 0
+1 mpqa_polarity 0
+1 phrase_type -1 0 1

data/core/python-scripts/my_templates/templates_exp.red.txt

@@ -0,0 +1,7 @@
+# sentence_id token_id token lemma pos term_id pol/mod mpqa_subjectivity mpqa_polarity 
+# entity property phrase_type y
+
+1 token -2 -1 0 1 2
+1 lemma -2 -1 0 1 2
+1 pos -2 -1 0 1 2
+1 pol/mod -2 -1 0 1 2 

data/core/python-scripts/my_templates/templates_exp.txt

@@ -0,0 +1,10 @@
+# sentence_id token_id token lemma pos term_id pol/mod mpqa_subjectivity mpqa_polarity 
+# entity property phrase_type y
+
+1 token -2 -1 0 1 2
+1 lemma -2 -1 0 1 2
+1 pos -2 -1 0 1 2
+1 pol/mod -2 -1 0 1 2 
+1 mpqa_subjectivity -2 -1 0 1 2
+1 mpqa_polarity -2 -1 0 1 2
+1 phrase_type -1 0 1

data/core/python-scripts/my_templates/templates_holder.only0.txt

@@ -0,0 +1,11 @@
+# sentence_id token_id token lemma pos term_id pol/mod mpqa_subjectivity
+# mpqa_polarity
+# entity property phrase_type y
+
+1 token 0
+1 lemma 0
+1 pos 0
+1 entity 0
+1 property 0
+1 phrase_type 0
+1 aspect_training 0

data/core/python-scripts/my_templates/templates_holder.red.txt

@@ -0,0 +1,9 @@
+# sentence_id token_id token lemma pos term_id pol/mod mpqa_subjectivity
+# mpqa_polarity
+# entity property phrase_type y
+
+1 token -2 -1 0 1 2
+1 lemma -2 -1 0 1 2
+1 pos -2 -1 0 1 2
+1 entity -2 -1 0 1 2
+1 property -2 -1 0 1 2

data/core/python-scripts/my_templates/templates_holder.txt

@@ -0,0 +1,10 @@
+# sentence_id token_id token lemma pos term_id pol/mod mpqa_subjectivity
+# mpqa_polarity
+# entity property phrase_type y
+
+1 token -2 -1 0 1 2
+1 lemma -2 -1 0 1 2
+1 pos -2 -1 0 1 2
+1 entity -2 -1 0 1 2
+1 property -2 -1 0 1 2
+1 phrase_type -1 0 1

data/core/python-scripts/my_templates/templates_target.only0.txt

@@ -0,0 +1,11 @@
+# sentence_id token_id token lemma pos term_id pol/mod mpqa_subjectivity
+# mpqa_polarity 
+# entity property phrase_type y
+
+1 token 0 -1 1
+1 lemma 0 -1 1
+1 pos 0 -1 1
+1 entity 0 -1 1
+1 property 0 -1 1
+1 phrase_type 0 -1 1
+1 aspect_training 0 -1 1

data/core/python-scripts/my_templates/templates_target.red.txt

@@ -0,0 +1,9 @@
+# sentence_id token_id token lemma pos term_id pol/mod mpqa_subjectivity
+# mpqa_polarity 
+# entity property phrase_type y
+
+1 token -2 -1 0 1 2
+1 lemma -2 -1 0 1 2
+1 pos -2 -1 0 1 2
+1 entity -2 -1 0 1 2
+1 property -2 -1 0 1 2

data/core/python-scripts/my_templates/templates_target.txt

@@ -0,0 +1,10 @@
+# sentence_id token_id token lemma pos term_id pol/mod mpqa_subjectivity
+# mpqa_polarity 
+# entity property phrase_type y
+
+1 token -2 -1 0 1 2
+1 lemma -2 -1 0 1 2
+1 pos -2 -1 0 1 2
+1 entity -2 -1 0 1 2
+1 property -2 -1 0 1 2
+1 phrase_type -1 0 1

data/core/python-scripts/run_all_experiments.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+# This script runs a bunch of experiments given a list of KAF files
+# Input:
+#  $1 --> folder where store all the models 
+#  $2 --> list of kaf files for training
+# Output:
+#  standard output --> latex table with the results
+#  standard error  --> progress information
+# The script looks for all the subfolders called exp1 exp2 exp3 within the $exps_folder folder
+
+general_folder=$1
+
+if [ ! -d $general_folder ]; 
+then 
+  mkdir $general_folder;
+fi
+
+list_files=$2
+exps_folder=experiments
+
+echo "Output folder: $general_folder"
+echo "List of files: $list_files"
+echo "\begin{table}"
+echo "\begin{tabular}{c|c|c|c|c|c|c||c|c|c|c}"
+echo "\hline"
+echo "Type & \multicolumn{2}{|c|}{Expression} & \multicolumn{2}{|c|}{Target} & \multicolumn{2}{|c||}{Holder} & \multicolumn{2}{|c|}{Exp-Tar} & \multicolumn{2}{|c|}{Exp-Hol} \\\\"
+echo "\hline"
+echo "& P & R &  P & R &  P & R &  P & R &  P & R \\\\"
+
+for exp in $exps_folder/exp*
+do
+  #id=$1  folder=$2  list_files=$3  experiment_folder=$4 
+  echo `date +%T` starting experiment $exp >> /dev/stderr
+  id=`basename $exp`
+  outfolder=$general_folder/$id
+  # If the output folder not exists already
+  if [ ! -d $outfolder ]; then 
+    run_experiment.sh $id $outfolder $list_files $exp
+    echo `date +%T` Done >> /dev/stderr
+    echo "Done experiment $exp Files: $list_files Out: $general_folder" | mail -s "Experiment done" ruben.izquierdobevia@vu.nl
+  else 
+    echo "The experiment $exp on $outfolder already exists, skipped" >> /dev/stderr
+  fi
+done
+
+echo "\end{tabular}"
+echo "\end{table}"
+  

data/core/python-scripts/run_basic.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+import sys
+from subprocess import Popen,PIPE
+
+def run_basic(input_file,output_file):
+  cmd = '/home/izquierdo/opener_repos/opinion-detector-basic/core/opinion_detector_basic_multi.py'
+  fin = open(input_file,'r')
+  fout = open(output_file,'w')
+  basic_opinion_miner = Popen(cmd,stdin=fin, stdout=fout,stderr=PIPE,shell=True)
+  fin.close()
+  basic_opinion_miner.wait()
+  fout.close()
+  print 'Done'
+
+if __name__ == '__main__':
+  input = 'english00001_0123ff23e0d0dc0177f9b71a1928b674.kaf'
+  output = 'english00001_0123ff23e0d0dc0177f9b71a1928b674.basic.kaf'
+  run_basic(input,output)
+  

data/core/python-scripts/run_experiment.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# This script runs a given experiment
+# Input:
+# $1 the id used for the table latex for the experiment
+# $2 the output folder to store all the models and folds (for the validation)
+# $3 the list of files for the training
+# $4 the folder with the experiment (must contain a file called config.cfg with the configuration
+#
+# Output
+# Standard out --> 2 rows of the latex table (for the basic and deluxe)
+# Standard err --> progress of the program
+# The log of training/evaluation will be on the same folder there the exp, called $id.log
+id=$1
+folder=$2
+list_files=$3
+experiment_folder=$4
+
+numfolds=5
+base_out_folder=`dirname $folder`
+err_file=$base_out_folder/$id.log
+out_per_folds=$base_out_folder/$id.out_per_fold.tex
+
+tmpconfig=`mktemp`
+
+echo "[general]" > $tmpconfig
+echo "output_folder = $folder" >> $tmpconfig 
+echo "filename_training_list = $list_files" >> $tmpconfig 
+echo >> $tmpconfig 
+echo "[feature_templates]" >> $tmpconfig
+echo "expression = $experiment_folder/templates_exp.txt " >> $tmpconfig
+echo "holder = $experiment_folder/templates_hol.txt" >> $tmpconfig
+echo "target = $experiment_folder/templates_tar.txt" >> $tmpconfig
+echo >> $tmpconfig
+cat $experiment_folder/config.cfg >> $tmpconfig 
+
+echo Running experiment $id Logs: $err_file Out per fold: $out_per_folds >> /dev/stderr
+#Output to standard output
+cross_validation.py -n $numfolds -f $tmpconfig -id $id -out_folds $out_per_folds 2> $err_file
+
+rm $tmpconfig
+

data/core/python-scripts/scripts/__init__.py

@@ -0,0 +1 @@
+pass

data/core/python-scripts/scripts/config_manager.py

@@ -0,0 +1,314 @@
+import os
+import ConfigParser
+import shutil
+
+internal_config_filename= 'config.cfg'
+
+
+def load_templates_from_file(filename):
+    templates = []
+    fic = open(filename,'r')
+    for line in fic:
+        line = line.strip()
+        if line != '' and line[0]!='#': #Not empty lines or starting with #
+            tokens = line.split(' ')
+            my_len = int(tokens[0])
+            labels = tokens[1:my_len+1]
+            values = tokens[my_len+1:]
+            for value in values:
+                new_template = []
+                single_values = value.split('/')
+                for n in range(len(labels)):
+                    new_template.append((labels[n],int(single_values[n])))
+                templates.append(new_template)
+    fic.close()
+    return templates
+
+class Cconfig_manager:
+    def __init__(self):
+        self.config = ConfigParser.ConfigParser()
+        self.out_folder = None
+        self.this_folder = None
+        self.templates_expr = None
+        self.templates_holder = None
+        self.templates_target = None 
+        
+    def set_current_folder(self,t):
+        self.this_folder = t
+        
+    def get_flag_filename(self):
+        my_name = 'flag'
+        return os.path.join(self.get_output_folder(),my_name)
+    
+    def set_config(self,file_cfg):
+        self.config.read(file_cfg)
+        output_folder_cfg = self.config.get('general','output_folder')
+        out_folder = ''
+        if os.path.isabs(output_folder_cfg):
+            self.out_folder = output_folder_cfg
+        else:
+            self.out_folder = os.path.join(self.this_folder,output_folder_cfg)
+
+    def get_use_dependencies(self):
+        use_dependencies = True ##Default
+        if self.config.has_section('relation_features'):
+            if self.config.has_option('relation_features', 'use_dependencies'):
+                use_dependencies = self.config.getboolean('relation_features', 'use_dependencies')
+        return use_dependencies
+        
+        
+    def get_use_training_lexicons(self):
+        use_lexicons = True ##Default
+        if self.config.has_section('relation_features'):
+            if self.config.has_option('relation_features', 'use_training_lexicons'):
+                use_lexicons = self.config.getboolean('relation_features', 'use_training_lexicons')
+        return use_lexicons   
+     
+    def get_use_tokens_lemmas(self):
+        use_them = True
+        if self.config.has_section('relation_features'):
+            if self.config.has_option('relation_features', 'use_tokens_lemmas'):
+                use_them = self.config.getboolean('relation_features', 'use_tokens_lemmas')
+        return use_them
+    
+    def get_propagation_lexicon_name(self):
+        lexicon_name = None
+        if self.config.has_section('lexicons'):
+            if self.config.has_option('lexicons','propagation_lexicon'):
+                lexicon_name = self.config.get('lexicons','propagation_lexicon')
+        return lexicon_name
+                
+                
+    def set_out_folder(self,o):
+        self.out_folder = o
+        
+    def get_training_datasets_folder(self):
+        my_name='training_datasets'
+        outfolder=self.get_output_folder()
+        return os.path.join(outfolder,my_name)
+                                    
+    def get_training_dataset_exp(self):
+        my_name = 'training_set_exp.crf'
+        return os.path.join(self.get_training_datasets_folder(),my_name)
+  
+    def get_training_dataset_target(self):
+        my_name = 'training_set_target.crf'
+        return os.path.join(self.get_training_datasets_folder(),my_name)   
+    
+    
+    def get_training_dataset_holder(self):
+        my_name = 'training_set_holder.crf'
+        return os.path.join(self.get_training_datasets_folder(),my_name)  
+    
+    
+    ## FEATURE TEMPLATES
+    def get_feature_template_folder_name(self):
+        my_name = 'feature_templates'
+        return os.path.join(self.get_output_folder(),my_name)  
+    
+    def get_feature_template_exp_name(self):
+        my_name = 'feat_template_expr.txt'
+        return os.path.join(self.get_feature_template_folder_name(),my_name) 
+
+    def get_feature_template_tar_name(self):
+        my_name = 'feat_template_target.txt'
+        return os.path.join(self.get_feature_template_folder_name(),my_name) 
+
+    def get_feature_template_hol_name(self):
+        my_name = 'feat_template_holder.txt'
+        return os.path.join(self.get_feature_template_folder_name(),my_name)     
+    
+    def copy_feature_templates(self):
+        #Exp
+        temp_exp_orig = self.config.get('feature_templates','expression')
+        temp_exp_target = self.get_feature_template_exp_name()
+        if not os.path.isabs(temp_exp_orig):
+            temp_exp_orig = os.path.join(self.this_folder,temp_exp_orig)
+        shutil.copyfile(temp_exp_orig, temp_exp_target)
+
+        temp_tar_orig = self.config.get('feature_templates','target')
+        temp_tar_target = self.get_feature_template_tar_name()
+        if not os.path.isabs(temp_tar_orig):
+            temp_tar_orig = os.path.join(self.this_folder,temp_tar_orig)
+        shutil.copyfile(temp_tar_orig, temp_tar_target)
+
+        temp_hol_orig = self.config.get('feature_templates','holder')
+        temp_hol_target = self.get_feature_template_hol_name()
+        if not os.path.isabs(temp_hol_orig):
+            temp_hol_orig = os.path.join(self.this_folder,temp_hol_orig)
+        shutil.copyfile(temp_hol_orig, temp_hol_target)
+
+    def get_templates_expr(self):
+        if self.templates_expr is None:
+            filename_template = self.get_feature_template_exp_name()
+            self.templates_expr = load_templates_from_file(filename_template)
+        return self.templates_expr
+
+    def get_templates_holder(self):
+        if self.templates_holder is None:
+            filename_template = self.get_feature_template_hol_name()
+            self.templates_holder = load_templates_from_file(filename_template)
+        return self.templates_holder
+    
+    def get_templates_target(self):
+        if self.templates_target is None:
+            filename_template = self.get_feature_template_tar_name()
+            self.templates_target = load_templates_from_file(filename_template)
+        return self.templates_target    
+    
+    def get_lexicons_folder(self):
+        my_name = 'lexicons'
+        return os.path.join(self.get_output_folder(),my_name)
+    
+    ###############
+    def get_expression_lexicon_filename(self):
+        my_name = 'polarity_lexicon.csv'
+        return os.path.join(self.get_lexicons_folder(),my_name)
+
+    def get_use_this_expression_lexicon(self):
+        use_it = None
+        if self.config.has_section('relation_features'):
+            if self.config.has_option('relation_features', 'use_this_expression_lexicon'):
+                use_it = self.config.get('relation_features', 'use_this_expression_lexicon')
+        return use_it
+  
+    def get_use_this_target_lexicon(self):
+        use_it = None
+        if self.config.has_section('relation_features'):
+            if self.config.has_option('relation_features', 'use_this_target_lexicon'):
+                use_it = self.config.get('relation_features', 'use_this_target_lexicon')
+        return use_it  
+    
+    def get_target_lexicon_filename(self):
+        my_name = 'target_lexicon.csv'
+        return os.path.join(self.get_lexicons_folder(),my_name)    
+    
+    def get_feature_folder_name(self):
+        subfolder_feats = 'tab_feature_files'  
+        out_folder = self.get_output_folder()
+        return os.path.join(out_folder,subfolder_feats)
+        
+    def get_crf_expression_folder(self):
+        my_name='crf_feat_files_exp'
+        out_folder = self.get_output_folder()
+        return os.path.join(out_folder,my_name)
+    
+    def get_crf_target_folder(self):
+        my_name='crf_feat_files_target'
+        out_folder = self.get_output_folder()
+        return os.path.join(out_folder,my_name)
+    
+    def get_crf_holder_folder(self):
+        my_name='crf_feat_files_holder'
+        out_folder = self.get_output_folder()
+        return os.path.join(out_folder,my_name)        
+    
+    def get_output_folder(self):
+        return self.out_folder
+    
+    def get_feature_desc_filename(self):
+        file_feat_desc = 'feature_desc.txt'     #description of features
+        out_folder = self.get_output_folder()
+        return os.path.join(out_folder,file_feat_desc)
+    
+    def get_file_training_list(self):
+        return self.config.get('general','filename_training_list')
+    
+    def get_crfsuite_binary(self):
+        return self.config.get('crfsuite','path_to_binary')
+    
+    def get_crfsuite_params(self):
+        return self.config.get('crfsuite','parameters')
+    
+    def get_svm_learn_binary(self):
+        return self.config.get('svmlight','path_to_binary_learn')
+    
+    def get_svm_classify_binary(self):
+        return self.config.get('svmlight','path_to_binary_classify')
+    
+    def get_svm_params(self):
+        return self.config.get('svmlight','parameters')
+    
+    
+    def get_svm_threshold_exp_tar(self):
+        thr = -1
+        if self.config.has_option('relation_features', 'exp_tar_threshold'):
+            thr = self.config.getfloat('relation_features', 'exp_tar_threshold')
+        return thr
+  
+    def get_svm_threshold_exp_hol(self):
+        thr = -1
+        if self.config.has_option('relation_features', 'exp_hol_threshold'):
+            thr = self.config.getfloat('relation_features', 'exp_hol_threshold')
+        return thr  
+    
+    
+    # [valid_opinions]
+    # positive = sentiment-neg
+    # negative = sentiment-pos
+    def get_mapping_valid_opinions(self):
+        mapping = {}
+        for mapped_opinion, values_in_corpus in self.config.items('valid_opinions'):
+            values = [ v for v in values_in_corpus.split(';') if v != '']
+            for v in values:
+                mapping[v] = mapped_opinion
+        return mapping
+                
+    def get_possible_expression_values(self):
+        labels = [key for key,_ in self.config.items('valid_opinions')]
+        return labels
+    
+    def get_model_foldername(self):
+        my_name = 'models'
+        out_folder = self.get_output_folder()
+        return os.path.join(out_folder,my_name)
+    
+    def get_filename_model_expression(self):
+        my_name = 'model_opi_exp.crf'
+        return os.path.join(self.get_model_foldername(),my_name)
+    
+    def get_filename_model_target(self):
+        my_name = 'model_opi_target.crf'
+        return os.path.join(self.get_model_foldername(),my_name)  
+    
+    def get_filename_model_holder(self):
+        my_name = 'model_opi_holder.crf'
+        return os.path.join(self.get_model_foldername(),my_name)     
+     
+    def get_folder_relation_classifier(self):
+        my_name = 'relation_classifier'
+        return os.path.join(self.out_folder,my_name)
+    
+    def get_relation_exp_tar_training_filename(self):
+        my_name = 'training_exp_tar.feat'
+        return os.path.join(self.get_folder_relation_classifier(),my_name)
+
+    def get_relation_exp_hol_training_filename(self):
+        my_name = 'training_exp_hol.feat'
+        return os.path.join(self.get_folder_relation_classifier(),my_name)
+    
+    def get_rel_exp_tar_training_idx_filename(self):
+        my_name = 'training_exp_tar.idx'
+        return os.path.join(self.get_folder_relation_classifier(),my_name)
+
+    def get_rel_exp_hol_training_idx_filename(self):
+        my_name = 'training_exp_hol.idx'
+        return os.path.join(self.get_folder_relation_classifier(),my_name)
+    
+    def get_index_features_exp_tar_filename(self):
+        my_name = 'feat_index.exp_tar.bin'
+        return os.path.join(self.get_folder_relation_classifier(),my_name)
+    
+    def get_index_features_exp_hol_filename(self):
+        my_name = 'feat_index.exp_hol.bin'
+        return os.path.join(self.get_folder_relation_classifier(),my_name)
+
+    def get_filename_model_exp_tar(self):
+        my_name = 'model_relation_exp_tar.svmlight'
+        return os.path.join(self.get_folder_relation_classifier(),my_name)
+        
+    def get_filename_model_exp_hol(self):
+        my_name = 'model_relation_exp_hol.svmlight'
+        return os.path.join(self.get_folder_relation_classifier(),my_name)
+
+