def run_pipeline_probabilistic()

in main.py [0:0]

• 88 lines of code
• 22 McCabe index (conditional complexity)

def run_pipeline_probabilistic(entity_linking_method, entity_linking_threshold = None, softmaxtemp = 0.1):
    conversations = dict()
    dialog_states = dict()
    dialog_states_slots = dict()
    dialog_states_probs = dict()
    latest_intents = dict()
    for ids, output in zip(test_ids, nlu_result):
        if not is_BIO:
            conver_id, turn_id, sentence_id = ids[0], ids[1], ids[2]
        else:
            conver_id, turn_id = ids[0], ids[1]

        if conver_id not in conversations:
            conversations[conver_id] = []
            dialog_states[conver_id] = {None:{}}
            dialog_states_slots[conver_id] = {None:{}}
            dialog_states_probs[conver_id] = {None:{}}
            latest_intents[conver_id] = [None]

        predicted_intents, texts = output.split('->')
        intents = predicted_intents[1:-2].split('<div>')
        tokens = texts.strip().split(' ')
        word_list = []
        label_list = []
        for t in tokens:
            if t.startswith('[') and t.endswith(']') and ':' in t:
                colon_idx = t.rindex(':')
                word_list.append(t[1:colon_idx])
                the_label = t[colon_idx+1:-1]
#                 assert the_label in bot_definition['slots']
                label_list.append(the_label)
            else:
                word_list.append(t)
                label_list.append('O')
    
        if is_BIO:
            slot_values = get_slot_values_BIO(word_list, label_list)
        else:
            slot_values = get_slot_values(word_list, label_list)
        entity_values = entity_linking_list(slot_values, distinct_slot_values, method = entity_linking_method, threshold = entity_linking_threshold)
        entity_probs = entity_linking_list_probs(slot_values, distinct_slot_values, softmaxtemp, method = entity_linking_method, threshold = entity_linking_threshold)
        main_intents = [intent for intent in intents if intent in bot_definition['main_intents']]

        # Update dialog states
        if main_intents != []:
            for intent in main_intents:
                if intent not in dialog_states[conver_id]:
                    dialog_states[conver_id][intent] = dict()
                    dialog_states_slots[conver_id][intent] = dict()
                    dialog_states_probs[conver_id][intent] = dict()
                dialog_states[conver_id][intent].update(entity_values)
                dialog_states_slots[conver_id][intent].update(slot_values)
                dialog_states_probs[conver_id][intent].update(entity_probs)
            latest_intents[conver_id] = main_intents

        else:
            for intent in latest_intents[conver_id]:
                dialog_states[conver_id][intent].update(entity_values)
                dialog_states_slots[conver_id][intent].update(slot_values)
                dialog_states_probs[conver_id][intent].update(entity_probs)

        sentence_object = {
            'conversationId': conver_id,
            'turnNumber': turn_id,
            'utterance': ' '.join(word_list),
            'intents': predicted_intents[1:-2],
            'main_intents': main_intents,
            'slot_values': slot_values,
            'entity_values': entity_values,
            'entity_probs': entity_probs,
            'dialog_states': copy.deepcopy(dialog_states[conver_id]),
            'dialog_states_slots': copy.deepcopy(dialog_states_slots[conver_id]),
            'dialog_states_probs': copy.deepcopy(dialog_states_probs[conver_id])
        }
        
        if not is_BIO:
            sentence_object['sentenceNumber'] = sentence_id
            sentence_object['utteranceId'] = f'<CONV>{conver_id}<TURN>{turn_id}<SENT>{sentence_id}'
        else:
            sentence_object['utteranceId'] = f'<CONV>{conver_id}<TURN>{turn_id}'

        # Violation detection
        violations_all = set()
        violation_details = [] 
        for intent, state in sentence_object['dialog_states_probs'].items():
            if intent is None:
                continue
            related_constraints = constraints_for_intent[intent]
            for constraint in related_constraints:
                is_applicable, violations = find_violations_probs(constraint, state, distinct_slot_values)
                if is_applicable and any(v >= 0.5 for v in violations): # No violations
                    violations_all.add((intent,constraint['name']))
                    violation_details.append({'intent': intent, 'constraint': constraint['name'], 'violations': violations})
        sentence_object['violations'] = list(violations_all)
        sentence_object['violation_details'] = violation_details

        conversations[conver_id].append(sentence_object)
    
    pipeline_results = evaluation(test_data, conversations)
    pipeline_results_no_intent = evaluation_no_intent(test_data, conversations)
    return conversations, None, pipeline_results, pipeline_results_no_intent