opener-opinion-detector-base 2.0.0

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

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import csv
+from subprocess import Popen,PIPE
+
+def create_lexicons(path_to_script, training_file,exp_filename, tar_filename):
+    cmd = ['python']
+    cmd.append(path_to_script)
+    cmd.append('-exp_csv')
+    cmd.append(exp_filename)
+    cmd.append('-tar_csv')
+    cmd.append(tar_filename)
+    cmd.append('-l')
+    cmd.append(training_file)
+    folder = os.path.dirname(exp_filename)
+    log_out = open(os.path.join(folder,'log.out'),'wb')
+    log_err = open(os.path.join(folder,'log.err'),'wb')
+    
+    lexicon_generator = Popen(' '.join(cmd),stdout=log_out, stderr=log_err, shell=True)
+    ret_code = lexicon_generator.wait()
+    log_out.close()
+    log_err.close()
+    
+    print>>sys.stderr,' Lexicons created, on',folder,' ret code:',ret_code
+    
+
+def load_lexicon(lexicon_filename):
+    ### LEXICON FROM THE DOMAIN
+    fd = open(lexicon_filename,'rb')
+    ##dialect = csv.Sniffer().sniff(fd.read(1024))
+    ##fd.seek(0)
+    #lex_reader = csv.reader(fd,dialect)
+    lex_reader = csv.reader(fd,delimiter=';')
+    my_lexicon = {}
+    for n,row in enumerate(lex_reader):
+        if n != 0:
+            text_type,ratio,rel_freq,over_freq,lemmas,postags,freqwords = row
+            this_pos = text_type.rfind('#')
+            text = text_type[:this_pos]
+            my_type =  text_type[this_pos+1:]
+            my_lexicon[text.decode('utf-8')] = my_type.decode('utf-8')
+    return my_lexicon

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

@@ -0,0 +1,77 @@
+#####
+import sys
+import logging
+from operator import itemgetter
+
+
+def get_min(l):
+  min = None
+  for ele in l:
+    digits = ''
+    for c in ele:
+      if c.isdigit(): digits+=c
+    value = int(digits)
+    if min==None or value<min:
+      min = value
+  return min
+
+#Returns the maximum position from a list of token ids
+def get_max(l):
+  max = -1
+  for ele in l:
+    digits = ''
+    for c in ele:
+      if c.isdigit(): digits+=c
+    value = int(digits)
+    if value>max:
+      max = value
+  return max
+
+
+## Gets the distance in number of tokens between two lisf of ids
+def get_distance(list1, list2):
+  min_1 = get_min(list1)
+  max_1 = get_max(list1)
+  min_2 = get_min(list2)
+  max_2 = get_max(list2)
+
+  if max_1 < min_2:
+    distance = min_2 - max_1
+  elif max_2 < min_1:
+    distance = min_1 - max_2
+  else:
+    distance = 0
+  return distance
+
+def link_entities_distance(expressions,targets,holders, sentence_for_token):
+    triples = []
+    weight_crossing_sentence = 200
+
+    for exp_ids, type_exp in expressions:
+        sentence_exp = int(sentence_for_token[exp_ids[0]])
+    
+        final_tar = []
+        list_tar_dist = []
+        for tar_ids, target_label in targets:
+            sentence_tar = int(sentence_for_token[tar_ids[0]])
+            dist_tar_exp = get_distance(exp_ids,tar_ids)
+            final_distance = dist_tar_exp + weight_crossing_sentence * abs(sentence_exp - sentence_tar)
+            list_tar_dist.append((tar_ids,final_distance))
+        if len(list_tar_dist) != 0:
+            list_tar_dist.sort(key=itemgetter(1))
+            final_tar = list_tar_dist[0][0]
+                                 
+        final_hol = []
+        list_hol_dist = []
+        for hol_ids, target_label in holders:
+            sentence_hol = int(sentence_for_token[hol_ids[0]])
+            dist_hol_exp = get_distance(exp_ids,hol_ids)
+            final_distance = dist_hol_exp + weight_crossing_sentence * abs(sentence_exp - sentence_hol)
+            list_hol_dist.append((hol_ids,final_distance))
+        if len(list_hol_dist) != 0:
+            list_hol_dist.sort(key=itemgetter(1))
+            final_hol = list_hol_dist[0][0]
+        
+        triples.append((type_exp,exp_ids,final_tar,final_hol))
+    return triples             
+ 

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

@@ -0,0 +1,250 @@
+#!/usr/bin/env python
+
+from extract_feats_relations import *
+from tempfile import NamedTemporaryFile
+from subprocess import Popen, PIPE
+from VUA_pylib.io import Cfeature_index
+import os
+
+config_manager = None
+
+    
+def link_exp_tar(expressions,targets, knaf_obj,use_dependencies=True,use_tokens=True, use_lemmas=True):
+    assigned_targets = []  #     (expression_type, exp_ids, 
+
+    if len(targets) == 0:
+        for exp_ids in expressions:
+            assigned_targets.append([])
+    elif len(targets) == 1:
+        for exp_ids in expressions:
+            assigned_targets.append(targets[0])
+    else:
+        feat_index_filename = config_manager.get_index_features_exp_tar_filename()
+        feat_index = Cfeature_index()
+        feat_index.load_from_file(feat_index_filename)
+        examples_file = NamedTemporaryFile(delete=False)
+        for exp_ids in expressions:
+            for tar_ids in targets:
+                feats = extract_feats_exp_tar(exp_ids,tar_ids,knaf_obj, use_dependencies=use_dependencies,use_tokens=use_tokens,use_lemmas=use_lemmas)
+                feat_index.encode_example_for_classification(feats, examples_file,my_class='0')
+        examples_file.close()
+        ## In examples_file.name we can find the examples file
+        
+        ## The format in the example file will be:
+        # exp1 --> tar1
+        # exp1 --> tar2
+        # exp1 --> tar3
+        # exp2 --> tar1
+        # exp2 --> tar2
+        # exp2 --> tar3        
+        
+        model_file = config_manager.get_filename_model_exp_tar()
+        results = run_svm_classify(examples_file.name, model_file)
+        
+        idx = 0         # This idx will iterate from 0 to num_exp X num_tar
+        selected = []   # will stor for each exp --> (best_tar_idx, best_svm_val)
+        for exp in expressions:
+            #Selecting the best for this exp
+            best_value = -100
+            best_idx = -100
+            #print>>sys.stderr,' Exp:', exp
+            for num_tar , tar in enumerate(targets):
+                
+                #This is the probably of exp to be related with the target num_tar
+                value = results[idx]
+                #print>>sys.stderr,'  Target:',tar
+                #print>>sys.stderr,'      Value:', value
+                #print>>sys.stderr, exp
+                #print>>sys.stderr, tar
+                #print>>sys.stderr, num_tar, value
+                #print
+                
+                #We select the best among the targets for the exp processed
+                if value > best_value:
+                    best_value = value
+                    best_idx = num_tar
+                idx += 1
+            selected.append((best_idx,best_value))
+            #print>>sys.stderr,'  Selected:', targets[best_idx]
+        #print selected
+        
+        for best_tar_idx, best_value in selected:
+            assigned_targets.append(targets[best_tar_idx])
+            #print>>sys.stderr,  'SELECTED',best_tar_idx,targets[best_tar_idx]
+        os.remove(examples_file.name)                
+    return assigned_targets
+
+def link_exp_tar_all(expressions,targets, knaf_obj,threshold, use_dependencies=True,use_tokens=True, use_lemmas=True):
+    pairs = []
+
+    if len(targets) == 0:
+        for exp_ids, exp_type in expressions:
+            pairs.append((exp_ids,exp_type,[]))
+    else:
+        feat_index_filename = config_manager.get_index_features_exp_tar_filename()
+        feat_index = Cfeature_index()
+        feat_index.load_from_file(feat_index_filename)
+        examples_file = NamedTemporaryFile(delete=False)
+        for exp_ids, exp_type in expressions:
+            for tar_ids in targets:
+                feats = extract_feats_exp_tar(exp_ids,tar_ids,knaf_obj, use_dependencies=use_dependencies,use_tokens=use_tokens,use_lemmas=use_lemmas)
+                feat_index.encode_example_for_classification(feats, examples_file,my_class='0')
+        examples_file.close()
+         
+        model_file = config_manager.get_filename_model_exp_tar()
+        results = run_svm_classify(examples_file.name, model_file)
+        
+        
+        threshold = -0.75
+        idx = 0
+        for exp,exp_type in expressions:
+            at_least_one = False
+            for num_tar, tar in enumerate(targets):
+                value = results[idx]
+                idx += 1
+                if value >= threshold:
+                    pairs.append((exp,exp_type,tar))
+                    at_least_one = True
+            
+            if not at_least_one:
+                pairs.append((exp,exp_type,[]))
+ 
+        os.remove(examples_file.name)                
+    return pairs
+
+def link_exp_hol(expressions,holders, knaf_obj,threshold_hol,use_dependencies=True,use_tokens=True,use_lemmas=True):
+    assigned_holders = []  #     (expression_type, exp_ids, 
+
+    if len(holders) == 0:
+        for exp_ids in expressions:
+            assigned_holders.append([])
+    else:
+        feat_index_filename = config_manager.get_index_features_exp_hol_filename()
+        feat_index = Cfeature_index()
+        feat_index.load_from_file(feat_index_filename)
+        examples_file = NamedTemporaryFile(delete=False)
+        for exp_ids in expressions:
+            for hol_ids in holders:
+                feats = extract_feats_exp_hol(exp_ids,hol_ids,knaf_obj, use_dependencies=use_dependencies,use_tokens=use_tokens,use_lemmas=use_lemmas)
+                feat_index.encode_example_for_classification(feats,examples_file,my_class='0')
+        examples_file.close()
+        ## In examples_file.name we can find the examples file
+        
+        ## The format in the example file will be:
+        # exp1 --> hol1
+        # exp1 --> hol2
+        # exp1 --> hol3
+        # exp2 --> hol1
+        # exp2 --> hol2
+        # exp2 --> hol3        
+        
+        model_file = config_manager.get_filename_model_exp_hol()
+        results = run_svm_classify(examples_file.name, model_file)
+        
+        idx = 0         # This idx will iterate from 0 to num_exp X num_tar
+        selected = []   # will stor for each exp --> (best_tar_idx, best_svm_val)
+        for exp in expressions:
+            #Selecting the best for this exp
+            best_value = -1
+            best_idx = -1
+            for num_hol , hol in enumerate(holders):
+                #This is the probably of exp to be related with the target num_tar
+                value = results[idx]
+                
+                #We select the best among the targets for the exp processed
+                if value > best_value:
+                    best_value = value
+                    best_idx = num_hol
+                idx += 1
+            selected.append((best_idx,best_value))
+        #print selected
+        
+        for best_hol_idx, best_value in selected:
+            if best_value >= threshold_hol:
+                assigned_holders.append(holders[best_hol_idx])
+            else:
+                assigned_holders.append([])
+        os.remove(examples_file.name)
+    return assigned_holders
+
+
+    
+def run_svm_classify(example_file,model_file):
+    #usage: svm_classify [options] example_file model_file output_file
+    svmlight = config_manager.get_svm_classify_binary()
+    if not os.path.exists(svmlight):
+        print>>sys.stderr,'SVMlight learn not found on',svmlight
+        print>>sys.stderr,'Check the config filename and make sure the path is correctly set'
+        print>>sys.stderr,'[svmlight]\npath_to_binary_learn = yourpathtolocalsvmlightlearn'
+        sys.exit(-1)
+                                                      
+    cmd = [svmlight]
+    cmd.append(example_file)
+    cmd.append(model_file)
+    tempout = NamedTemporaryFile(delete=False)
+    tempout.close()
+    
+    cmd.append(tempout.name)
+    svm_process = Popen(' '.join(cmd),stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True)
+    svm_process.wait()
+    str_err = svm_process.stderr.read()
+    if len(str_err) != 0:
+        print>>sys.stderr,'SVM light classify error '+str_err
+        sys.exit(-1)
+    #logging.debug('SVMlight classigfy log'+err_file)
+    results = []
+    fout = open(tempout.name,'r')
+    for line in fout:
+        results.append(float(line.strip()))
+    fout.close()
+    os.remove(tempout.name)
+    return results
+            
+
+
+def link_entities_svm(expressions, targets, holders, knaf_obj,this_config_manager):
+    all_types = []
+    all_exp_ids = []
+    all_tar_ids = []
+    all_hol_ids = []
+    global config_manager
+    config_manager = this_config_manager
+    
+    for exp_ids,exp_type in expressions:
+        all_types.append(exp_type)
+        exp_term_ids = knaf_obj.map_tokens_to_terms(exp_ids)
+        all_exp_ids.append((exp_term_ids, exp_type))
+    
+    for tar_ids, tar_type in targets:
+        tar_term_ids = knaf_obj.map_tokens_to_terms(tar_ids)
+        all_tar_ids.append(tar_term_ids)
+
+    for hol_ids, hol_type in holders:
+        hol_term_ids = knaf_obj.map_tokens_to_terms(hol_ids)
+        all_hol_ids.append(hol_term_ids)
+    
+    #assigned_targets = link_exp_tar(all_exp_ids, all_tar_ids,knaf_obj)
+    
+    svm_thres_exp_tar = config_manager.get_svm_threshold_exp_tar()
+    use_deps_now = config_manager.get_use_dependencies()
+    use_tokens_lemmas = config_manager.get_use_training_lexicons()
+    pairs_exp_tar = link_exp_tar_all(all_exp_ids, all_tar_ids, knaf_obj,svm_thres_exp_tar,use_dependencies=use_deps_now,use_tokens=use_tokens_lemmas,use_lemmas=use_tokens_lemmas)
+    
+    results = []
+    sets_exp_ids = []
+    for exp_ids, exp_type, tar_ids in pairs_exp_tar:
+        sets_exp_ids.append(exp_ids)
+
+
+    # The holders are calculated in the old fashion
+    svm_thres_exp_hol = config_manager.get_svm_threshold_exp_hol()
+    assigned_holders = link_exp_hol(sets_exp_ids, all_hol_ids,knaf_obj,svm_thres_exp_hol,use_dependencies=use_deps_now,use_tokens=use_tokens_lemmas,use_lemmas=use_tokens_lemmas)
+    
+    for index, (exp_ids, exp_type, tar_ids) in enumerate(pairs_exp_tar):
+        results.append((exp_type,exp_ids,tar_ids,assigned_holders[index]))
+
+    del config_manager
+    config_manager = None
+    return results
+
+ 

data/core/python-scripts/train.py

@@ -0,0 +1,566 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import logging
+import shutil
+import glob
+from subprocess import Popen, PIPE
+import cPickle
+import time
+import csv
+from collections import defaultdict
+
+
+from scripts import lexicons as lexicons_manager
+from scripts.config_manager import Cconfig_manager, internal_config_filename
+from scripts.extract_features import extract_features_from_kaf_naf_file
+from scripts.crfutils import extract_features_to_crf    
+from scripts.extract_feats_relations import create_rel_exp_tar_training, create_rel_exp_hol_training
+from VUA_pylib.io import Cfeature_file, Cfeature_index
+from KafNafParserPy import KafNafParser
+
+
+
+#Globa configuration
+my_config_manager = Cconfig_manager()
+
+__this_folder = os.path.dirname(os.path.realpath(__file__))
+
+
+def save_obj_to_file(obj,filename):
+    fic = open(filename,'wb')
+    cPickle.dump(obj,fic)
+    fic.close()
+
+def create_folders(config_filename):
+    global my_config_manager
+        
+    # Read configuration from the config file
+    my_config_manager.set_current_folder(__this_folder)
+    my_config_manager.set_config(config_filename)
+    
+    out_folder = my_config_manager.get_output_folder()
+
+   
+    logging.debug('Complete path to output folder: '+out_folder)
+    
+    # Remove the folder if it exists
+    if os.path.exists(out_folder):
+        shutil.rmtree(out_folder)
+        logging.debug('Output folder exists and was removed')
+    
+    os.mkdir(out_folder)
+    logging.debug('Created '+out_folder)
+
+    #Copy the config filename to out_folder/config.cfg
+    my_cfg = os.path.join(out_folder,internal_config_filename)
+    shutil.copyfile(config_filename,my_cfg)
+
+    feat_folder = my_config_manager.get_feature_folder_name()
+    logging.debug('Created '+feat_folder)
+    os.mkdir(feat_folder)
+
+    crf_exp = my_config_manager.get_crf_expression_folder()
+    os.mkdir(crf_exp)
+    logging.debug('Created '+crf_exp) 
+    
+    crf_target = my_config_manager.get_crf_target_folder()
+    os.mkdir(crf_target)
+    logging.debug('Created '+crf_target) 
+    
+    crf_holder = my_config_manager.get_crf_holder_folder()
+    os.mkdir(crf_holder)
+    logging.debug('Created '+crf_holder)
+    
+    datasets_folder = my_config_manager.get_training_datasets_folder()
+    os.mkdir(datasets_folder)
+    logging.debug('Created '+datasets_folder)
+    
+    models_folder = my_config_manager.get_model_foldername()
+    os.mkdir(models_folder)
+    logging.debug('Created '+models_folder)
+    
+    relation_folder = my_config_manager.get_folder_relation_classifier()
+    os.mkdir(relation_folder)
+    logging.debug('Created '+relation_folder)
+    
+    ##Templates folder
+    template_folder = my_config_manager.get_feature_template_folder_name()
+    os.mkdir(template_folder)
+    logging.debug('Created '+template_folder)
+        
+    ##Copy template files
+    my_config_manager.copy_feature_templates()
+
+    ##Folder for lexicons
+    lexicons_folder = my_config_manager.get_lexicons_folder()
+    os.mkdir(lexicons_folder)
+    logging.debug('Created '+lexicons_folder)
+
+def load_training_files():
+    file_training_files_cfg = my_config_manager.get_file_training_list()
+    train_files = []
+    path_to_file = ''
+    if os.path.isabs(file_training_files_cfg):
+        path_to_file = file_training_files_cfg
+    else:
+        path_to_file = os.path.join(__this_folder,file_training_files_cfg)
+    logging.debug('Reading training files from '+path_to_file)
+    try:
+        fic = open(path_to_file,'r')
+        for line in fic:
+            train_files.append(line.strip())
+        fic.close()
+    except Exception as e:
+        print>>sys.stderr,'Exception reading '+path_to_file,' -->'+str(e)
+        sys.exit(-1)
+    return train_files
+    
+
+             
+def extract_all_features():
+    train_files = load_training_files()
+    logging.debug('Loaded '+str(len(train_files))+' files')
+
+    feat_folder = my_config_manager.get_feature_folder_name()
+    label_feats = separator = None
+    my_stdout, my_stderr = sys.stdout,sys.stderr
+    
+    rel_exp_tar_filename = my_config_manager.get_relation_exp_tar_training_filename()
+    exp_tar_rel_fic = open(rel_exp_tar_filename,'w')
+   
+    rel_exp_hol_filename = my_config_manager.get_relation_exp_hol_training_filename()
+    exp_hol_rel_fic = open(rel_exp_hol_filename,'w') 
+    
+    ### LEXICON FROM THE DOMAIN
+    expressions_lexicon = None
+    targets_lexicon = None
+    if my_config_manager.get_use_training_lexicons():
+        # Create the lexicons
+        
+        ##GUESS THE LANG:
+        first_train_file = train_files[0]
+        obj = KafNafParser(first_train_file)
+        lang = obj.get_language()
+        
+        expression_lexicon_filename = my_config_manager.get_expression_lexicon_filename()
+        target_lexicon_filename = my_config_manager.get_target_lexicon_filename()
+        
+        
+        this_exp_lex = my_config_manager.get_use_this_expression_lexicon()            
+        this_tar_lex = my_config_manager.get_use_this_target_lexicon()
+
+        
+        if this_exp_lex is None or this_tar_lex is None:
+            path_to_lex_creator = '/home/izquierdo/opener_repos/opinion-domain-lexicon-acquisition/acquire_from_annotated_data.py'
+            training_filename = my_config_manager.get_file_training_list()
+            lexicons_manager.create_lexicons(path_to_lex_creator,training_filename,expression_lexicon_filename,target_lexicon_filename)
+        
+        ##Once created we have to copy the previous one in case:
+        if this_exp_lex is not None:
+            if "$LANG" in this_exp_lex:
+                this_exp_lex = this_exp_lex.replace('$LANG',lang)
+            shutil.copy(this_exp_lex, expression_lexicon_filename)
+            
+        if this_tar_lex is not None:
+            if "$LANG" in this_tar_lex:
+                this_tar_lex = this_tar_lex.replace('$LANG',lang)
+            shutil.copy(this_tar_lex,target_lexicon_filename)
+        
+        expressions_lexicon = lexicons_manager.load_lexicon(expression_lexicon_filename)
+        targets_lexicon =  lexicons_manager.load_lexicon(target_lexicon_filename)
+        
+        this_propagation_lexicon = my_config_manager.get_propagation_lexicon_name()
+        if this_propagation_lexicon is not None:
+            if "$LANG" in this_propagation_lexicon:
+                this_propagation_lexicon = this_propagation_lexicon.replace('$LANG',lang)
+                
+        print>>sys.stderr,'Propagated lexicon',this_propagation_lexicon
+        
+        
+        
+
+    ## Configuration for the relational alcasifier
+    use_deps_now = my_config_manager.get_use_dependencies()
+    use_toks_lems_now = my_config_manager.get_use_tokens_lemmas()
+      
+    accepted_opinions = my_config_manager.get_mapping_valid_opinions()
+    use_dependencies_now = my_config_manager.get_use_dependencies()
+    polarities_found_and_skipped = []
+    for num_file, train_file in enumerate(train_files):
+        logging.debug('Extracting features '+os.path.basename(train_file))
+        base_name = os.path.basename(train_file)
+        out_file = os.path.join(feat_folder,'file#'+str(num_file)+'#'+base_name+".feat")
+        err_file = out_file+'.log'
+        
+        #Creates the output file
+        # Returns the labels for the features and the separator used
+        if True:
+            kaf_naf_obj = KafNafParser(train_file)
+            
+            label_feats, separator, pols_skipped_this = extract_features_from_kaf_naf_file(kaf_naf_obj,out_file,err_file, 
+                                                                                           accepted_opinions=accepted_opinions, 
+                                                                                           exp_lex=expressions_lexicon, 
+                                                                                           tar_lex=targets_lexicon,
+                                                                                           propagation_lex_filename=this_propagation_lexicon)
+            polarities_found_and_skipped.extend(pols_skipped_this)
+            print>>exp_tar_rel_fic,'#'+train_file
+            print>>exp_hol_rel_fic,'#'+train_file
+            # SET valid_opinions to None to use all the possible opinions in the KAF file for extracitng relations 
+            create_rel_exp_tar_training(kaf_naf_obj, output=exp_tar_rel_fic, valid_opinions=accepted_opinions,use_dependencies=use_dependencies_now,use_tokens=use_toks_lems_now,use_lemmas=use_toks_lems_now)
+            create_rel_exp_hol_training(kaf_naf_obj ,output=exp_hol_rel_fic, valid_opinions=accepted_opinions,use_dependencies=use_dependencies_now,use_tokens=use_toks_lems_now,use_lemmas=use_toks_lems_now)
+        if False:
+        #except Exception as e:
+            sys.stdout, sys.stderr = my_stdout, my_stderr
+            print>>sys.stderr,str(e),dir(e)
+            pass
+        
+    ##Show just for information how many instances have been skipped becase the polarity of opinion expression was not allowed
+    count = defaultdict(int)
+    for exp_label in polarities_found_and_skipped:
+        count[exp_label] += 1
+    info = '\nOpinions skipped because the polarity label is not included in the configuration\n'
+    info += 'Accepted opinions: '+' '.join(accepted_opinions.keys())+'\n'
+    info += 'Number of complete opinions skipped\n'
+    for label, c in count.items():
+        info+=' '+label+' :'+str(c)+'\n'
+    info+='\n'
+    logging.debug(info)
+    ###################################################
+    
+    
+        
+    #Re-set the stdout and stderr
+    exp_tar_rel_fic.close()
+    exp_hol_rel_fic.close()
+    
+    sys.stdout,sys.stderr = my_stdout, my_stderr
+    #Sabe labelfeats and separator in a file
+    filename = my_config_manager.get_feature_desc_filename()
+    fic = open(filename,'w')
+    fic.write(' '.join(label_feats)+'\n')
+    fic.close()
+    logging.debug('Description of features --> '+filename)
+    
+    
+    
+def train_expression_classifier():
+    # 1) Create the training file from all the features
+    # Load the feature description
+    path_feat_desc = my_config_manager.get_feature_desc_filename()
+    fic = open(path_feat_desc)
+    fields = fic.read().strip()
+    fic.close()
+    separator = '\t'
+    feat_folder = my_config_manager.get_feature_folder_name()
+    crf_folder = my_config_manager.get_crf_expression_folder()
+    # Create all the CRF files calling to the crfutils.extract_features_to_crf 
+       
+    crf_out_files = []
+    
+    templates_exp = my_config_manager.get_templates_expr() 
+    possible_classes = my_config_manager.get_possible_expression_values()
+      
+    # Only set the target class for the tokens of possible_classes
+    # For others, it's set to O (out sequence)
+    for feat_file in glob.glob(feat_folder+'/*.feat'):
+        base_name = os.path.basename(feat_file)
+        base_name = base_name[:-5]
+        out_crf = os.path.join(crf_folder,base_name)
+        logging.debug('Creating crf file in --> '+out_crf)
+        
+        try:
+            extract_features_to_crf(feat_file,out_crf,fields,separator,templates_exp,possible_classes)
+            crf_out_files.append(out_crf)
+        except:
+            print>>sys.stderr,'Failed conversion to tab-expression -> CRF: ',feat_file
+    ###########################################################################################
+   
+    # Concatenate all the crf files just created 
+    out_f = open(my_config_manager.get_training_dataset_exp(),'w')
+    for crf_file in crf_out_files:
+        f = open(crf_file)
+        out_f.write(f.read())
+        f.close()
+    out_f.close()
+    logging.debug('Created training data for crf, op.exp '+my_config_manager.get_training_dataset_exp())
+    #############################################
+    
+    #Train the model
+    crf_params = my_config_manager.get_crfsuite_params()
+    input_file = my_config_manager.get_training_dataset_exp()
+    model_file = my_config_manager.get_filename_model_expression()
+    logging.debug('Training the classifier for opinion expressions (could take a while)')
+    run_crfsuite(crf_params,input_file,model_file)
+    
+    
+    
+def train_target_classifier():
+    
+    # 1) Create the training file from all the features
+    # Load the feature description
+    path_feat_desc = my_config_manager.get_feature_desc_filename()
+    fic = open(path_feat_desc)
+    fields = fic.read().strip()
+    fic.close()
+    separator = '\t'
+    feat_folder = my_config_manager.get_feature_folder_name()
+    crf_folder = my_config_manager.get_crf_target_folder()
+    # Create all the CRF files calling to the crfutils.extract_features_to_crf    
+    crf_out_files = []
+    templates_target = my_config_manager.get_templates_target()
+    possible_classes = ['target']
+    for feat_file in glob.glob(feat_folder+'/*.feat'):
+        base_name = os.path.basename(feat_file)
+        base_name = base_name[:-5]
+        out_crf = os.path.join(crf_folder,base_name)
+        logging.debug('Creating crf file in --> '+out_crf)
+        
+        try:
+            extract_features_to_crf(feat_file,out_crf,fields,separator,templates_target,possible_classes)
+            crf_out_files.append(out_crf)
+        except:
+            print>>sys.stderr,'Failed conversion to tab-target-> CRF: ',feat_file
+    ###########################################################################################
+   
+    # Concatenate all the crf files just created 
+    out_f = open(my_config_manager.get_training_dataset_target(),'w')
+    for crf_file in crf_out_files:
+        f = open(crf_file)
+        out_f.write(f.read())
+        f.close()
+    out_f.close()
+    logging.debug('Created training data for crf, op.exp '+my_config_manager.get_training_dataset_target())
+    #############################################
+    
+    #Train the model
+    crf_params = my_config_manager.get_crfsuite_params()
+    input_file = my_config_manager.get_training_dataset_target()
+    model_file = my_config_manager.get_filename_model_target()
+    logging.debug('Training the classifier for opinion target (could take a while)')
+    run_crfsuite(crf_params,input_file,model_file)
+    
+    
+    
+
+def train_holder_classifier():
+    
+    # 1) Create the training file from all the features
+    # Load the feature description
+    path_feat_desc = my_config_manager.get_feature_desc_filename()
+    fic = open(path_feat_desc)
+    fields = fic.read().strip()
+    fic.close()
+    separator = '\t'
+    feat_folder = my_config_manager.get_feature_folder_name()
+    crf_folder = my_config_manager.get_crf_holder_folder()
+    # Create all the CRF files calling to the crfutils.extract_features_to_crf    
+    crf_out_files = []
+    templates_holder = my_config_manager.get_templates_holder()
+    possible_classes = ['holder']
+    for feat_file in glob.glob(feat_folder+'/*.feat'):
+        base_name = os.path.basename(feat_file)
+        base_name = base_name[:-5]
+        out_crf = os.path.join(crf_folder,base_name)
+        logging.debug('Creating crf file in --> '+out_crf)
+    
+        try:
+            extract_features_to_crf(feat_file,out_crf,fields,separator,templates_holder,possible_classes)
+            crf_out_files.append(out_crf)
+        except:
+            print>>sys.stderr,'Failed conversion to tab-holder -> CRF: ',feat_file
+    ###########################################################################################
+   
+    # Concatenate all the crf files just created 
+    out_f = open(my_config_manager.get_training_dataset_holder(),'w')
+    for crf_file in crf_out_files:
+        f = open(crf_file)
+        out_f.write(f.read())
+        f.close()
+    out_f.close()
+    logging.debug('Created training data for crf, op.exp '+my_config_manager.get_training_dataset_holder())
+    #############################################
+    
+    #Train the model
+    crf_params = my_config_manager.get_crfsuite_params()
+    input_file = my_config_manager.get_training_dataset_holder()
+    model_file = my_config_manager.get_filename_model_holder()
+    logging.debug('Training the classifier for opinion holder (could take a while)')
+    run_crfsuite(crf_params,input_file,model_file)
+    
+
+def run_crfsuite(crf_params,input_file,model_file):
+    
+    crfsuite = my_config_manager.get_crfsuite_binary()
+    if not os.path.exists(crfsuite):
+        print>>sys.stderr,'CRFsuite not found on',crfsuite
+        print>>sys.stderr,'Check the config filename and make sure the path is correctly set'
+        print>>sys.stderr,'[crfsuite]\npath_to_binary = yourpathtolocalcrfsuite'
+        sys.exit(-1)
+        
+    cmd = [crfsuite]
+    cmd.append('learn')
+    cmd.append(crf_params)
+    cmd.append('-m '+model_file)
+    cmd.append(input_file)
+    err_file = model_file+'.log'
+    err_fic = open(err_file,'w')
+    crf_process = Popen(' '.join(cmd), stdin=PIPE, stdout=err_fic, stderr=PIPE, shell=True)
+    crf_process.wait()
+    str_err = crf_process.stderr.read()
+    if len(str_err) != 0:
+        print>>sys.stderr,'CRF error!!: '+str_err
+        sys.exit(-1)
+    err_fic.close()
+    logging.debug('Crfsuite log '+err_file) 
+    
+    
+    
+    
+############################################
+################ RELATION TRAINING #########
+###########################################
+
+def train_classifier_relation_exp_tar():
+    #Load the human readable training file    
+    train_filename = my_config_manager.get_relation_exp_tar_training_filename()
+    feature_file_obj = Cfeature_file(train_filename)
+    ###########################################
+
+    
+    # Convert it into index based feature file, for svm-light
+    feature_index = Cfeature_index()
+    feat_bin_filename = my_config_manager.get_rel_exp_tar_training_idx_filename()
+    fic_out = open(feat_bin_filename,'w')
+    feature_index.encode_feature_file_to_svm(feature_file_obj,fic_out)
+    fic_out.close()
+    ###########################################
+
+    
+    ## Save the feature index
+    feat_index_filename = my_config_manager.get_index_features_exp_tar_filename()
+    feature_index.save_to_file(feat_index_filename)
+    #########################
+    
+    # Train the model
+    example_file = my_config_manager.get_rel_exp_tar_training_idx_filename()
+    model = my_config_manager.get_filename_model_exp_tar()
+    svm_opts = my_config_manager.get_svm_params()
+    logging.debug('Training SVMlight classifier for RELATION(expression,target) in '+model+ '(could take a while)')
+    run_svmlight_learn(example_file,model,svm_opts)
+    ###########################################
+
+
+
+
+def train_classifier_relation_exp_hol():
+    #Load the human readable training file    
+    train_filename = my_config_manager.get_relation_exp_hol_training_filename()
+    feature_file_obj = Cfeature_file(train_filename)
+    ###########################################
+
+    
+    # Convert it into index based feature file, for svm-light
+    feature_index = Cfeature_index()
+    feat_bin_filename = my_config_manager.get_rel_exp_hol_training_idx_filename()
+    fic_out = open(feat_bin_filename,'w')
+    feature_index.encode_feature_file_to_svm(feature_file_obj,fic_out)
+    fic_out.close()
+    ###########################################
+
+    
+    ## Save the feature index
+    feat_index_filename = my_config_manager.get_index_features_exp_hol_filename()
+    feature_index.save_to_file(feat_index_filename)
+    #########################
+    
+    # Train the model
+    example_file = my_config_manager.get_rel_exp_hol_training_idx_filename()
+    model = my_config_manager.get_filename_model_exp_hol()
+    svm_opts = my_config_manager.get_svm_params()
+    logging.debug('Training SVMlight classifier for RELATION(expression,holder) in '+model+ '(could take a while)')
+    run_svmlight_learn(example_file,model,svm_opts)
+    ###########################################
+    
+    
+def run_svmlight_learn(example_file,model_file,params):
+    svmlight = my_config_manager.get_svm_learn_binary()
+    
+    if not os.path.exists(svmlight):
+        print>>sys.stderr,'SVMlight learn not found on',svmlight
+        print>>sys.stderr,'Check the config filename and make sure the path is correctly set'
+        print>>sys.stderr,'[svmlight]\npath_to_binary_learn = yourpathtolocalsvmlightlearn'
+        sys.exit(-1)
+        
+    cmd = [svmlight]
+    cmd.append(params)
+    cmd.append(example_file)
+    cmd.append(model_file)
+    err_file = model_file+'.log'
+    err_fic = open(err_file,'w')
+    svm_process = Popen(' '.join(cmd),stdin=PIPE, stdout=err_fic, stderr=PIPE, shell=True)
+    svm_process.wait()
+    str_err = svm_process.stderr.read()
+    if len(str_err) != 0:
+        print>>sys.stderr,'SVM light error '+str_err
+        sys.exit(-1)
+    err_fic.close()
+    logging.debug('SVMlight learn log'+err_file)
+    
+def write_to_flag(msg,openas='a'):
+    flag = open(my_config_manager.get_flag_filename(),openas)
+    my_time = time.strftime('%Y-%m-%dT%H:%M:%S%Z')
+    flag.write(msg+' --> '+my_time+'\n')
+    flag.close() 
+    
+def train_all(file_config):
+  
+
+      
+    
+    # Check if the output folder exists or create it
+    create_folders(file_config)
+    write_to_flag('Beginning\n','w')
+       
+    #Will create the subfolder out_folder/subfolder_feats with files *feat
+    write_to_flag('START extract features')
+    extract_all_features()
+    write_to_flag('DONE extract features\n')
+    
+    # training the expression classifier
+    write_to_flag('START training expression classifier')
+    train_expression_classifier()
+    write_to_flag('DONE training expression classifier\n')
+
+    
+    # Training the target classifier
+    write_to_flag('START training target classifier')
+    train_target_classifier()
+    write_to_flag('DONE training target classifier\n')
+    
+    # training the holder classifier
+    write_to_flag('START training expression classifier')
+    train_holder_classifier()
+    write_to_flag('DONE training holder classifier\n')
+
+    
+    write_to_flag('START training relation expression - target classifier')
+    train_classifier_relation_exp_tar()
+    write_to_flag('DONE training relation expression - target classifier\n')
+    
+    write_to_flag('START training relation expression - holder classifier')
+    train_classifier_relation_exp_hol()
+    write_to_flag('DONE training relation expression - holder classifier\n')
+    
+    
+    logging.debug('ALL TRAINING DONE')
+    write_to_flag('FINISHED ')
+    
+    
+if __name__ == '__main__':
+    logging.basicConfig(stream=sys.stderr,format='%(asctime)s - %(levelname)s\n %(message)s', level=logging.DEBUG)
+    file_config = sys.argv[1]
+    train_all(file_config)
+           
+    sys.exit(0)