update

Author: brightmart

__init__.py

@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+import random
+import codecs
+"""
+compute single evaulation matrix for task1,task2 and task3:
+compute f1 score(micro,macro) for accusation & relevant article, and score for pentaly
+"""
+
+small_value=0.00001
+random_number=500
+def compute_confuse_matrix_batch(y_targetlabel_list,y_logits_array,label_dict,name='default'):
+    """
+    compute confuse matrix for a batch
+    :param y_targetlabel_list: a list; each element is a mulit-hot,e.g. [1,0,0,1,...]
+    :param y_logits_array: a 2-d array. [batch_size,num_class]
+    :param label_dict:{label:(TP, FP, FN)}
+    :param name: a string for debug purpose
+    :return:label_dict:{label:(TP, FP, FN)}
+    """
+    for i,y_targetlabel_list_single in enumerate(y_targetlabel_list):
+        label_dict=compute_confuse_matrix(y_targetlabel_list_single,y_logits_array[i],label_dict,name=name)
+    return label_dict
+
+def compute_confuse_matrix(y_targetlabel_list_single,y_logit_array_single,label_dict,name='default'):
+    """
+    compute true postive(TP), false postive(FP), false negative(FN) given target lable and predict label
+    :param y_targetlabel_list: a list. length is batch_size(e.g.1). each element is a multi-hot,like '[0,0,1,0,1,...]'
+    :param y_logit_array: an numpy array. shape is:[batch_size,num_classes]
+    :param label_dict {label:(TP,FP,FN)}
+    :return: macro_f1(a scalar),micro_f1(a scalar)
+    """
+    #1.get target label and predict label
+    y_target_labels=get_target_label_short(y_targetlabel_list_single) #e.g. y_targetlabel_list[0]=[2,12,88]
+    #y_logit=y_logit_array_single #y_logit_array[0] #[202]
+    y_predict_labels=[i for i in range(len(y_logit_array_single)) if y_logit_array_single[i]>=0.50] #TODO 0.5PW e.g.[2,12,13,10]
+    if len(y_predict_labels) < 1: y_predict_labels = [np.argmax(y_logit_array_single)]
+
+    #if len(y_predict_labels)<1:    y_predict_labels=[np.argmax(y_logit_array_single)] #TODO ADD 2018.05.29
+    if random.choice([x for x in range(random_number)]) ==1:print(name+".y_target_labels:",y_target_labels,";y_predict_labels:",y_predict_labels) #debug purpose
+
+    #2.count number of TP,FP,FN for each class
+    y_labels_unique=[]
+    y_labels_unique.extend(y_target_labels)
+    y_labels_unique.extend(y_predict_labels)
+    y_labels_unique=list(set(y_labels_unique))
+    for i,label in enumerate(y_labels_unique): #e.g. label=2
+        TP, FP, FN = label_dict[label]
+        if label in y_predict_labels and label in y_target_labels:#predict=1,truth=1 (TP)
+            TP=TP+1
+        elif label in y_predict_labels and label not in y_target_labels:#predict=1,truth=0(FP)
+            FP=FP+1
+        elif label not in y_predict_labels and label in y_target_labels:#predict=0,truth=1(FN)
+            FN=FN+1
+        label_dict[label] = (TP, FP, FN)
+    return label_dict
+
+
+def compute_penalty_score_batch(target_deaths, predict_deaths,target_lifeimprisons, predict_lifeimprisons,target_imprsions, predict_imprisons):
+    """
+    compute penalty score(task 3) for a batch.
+    :param target_deaths: a list. each element is a mulit-hot list
+    :param predict_deaths: a 2-d array. [batch_size,num_class]
+    :param target_lifeimprisons: a list. each element is a mulit-hot list
+    :param predict_lifeimprisons: a 2-d array. [batch_size,num_class]
+    :param target_imprsions: a list. each element is a mulit-hot list
+    :param predict_imprisons: a 2-d array. [batch_size,num_class]
+    :return: score_batch: a scalar, average score for that batch
+    """
+    length=len(target_deaths)
+    score_total=0.0
+    for i in range(length):
+        score=compute_penalty_score(target_deaths[i], predict_deaths[i], target_lifeimprisons[i],predict_lifeimprisons[i],target_imprsions[i], predict_imprisons[i])
+        score_total=score_total+score
+    score_batch=score_total/float(length)
+    return score_batch
+
+def compute_penalty_score(target_death, predict_death,target_lifeimprison, predict_lifeimprison,target_imprsion, predict_imprison):
+    """
+    compute penalty score(task 3) for a single data
+    :param target_death:  a mulit-hot list. e.g. [1,0,0,1,...]
+    :param predict_death: [num_class]
+    :param target_lifeimprison: a mulit-hot list. e.g. [1,0,0,1,...]
+    :param predict_lifeimprison: [num_class]
+    :param target_imprsion: a mulit-hot list. e.g. [1,0,0,1,...]
+    :param predict_imprison:[num_class]
+    :return: score: a scalar,score for this data
+    """
+    score_death=compute_death_lifeimprisonment_score(target_death, predict_death)
+    score_lifeimprisonment=compute_death_lifeimprisonment_score(target_lifeimprison, predict_lifeimprison)
+    score_imprisonment=compute_imprisonment_score(target_imprsion, predict_imprison)
+    score=((score_death+score_lifeimprisonment+score_imprisonment)/3.0)*(100.0)
+    return score
+
+def compute_death_lifeimprisonment_score(target,predict):
+    """
+    compute score for death or life imprisonment
+    :param target: a list
+    :param predict: an array
+    :return: score: a scalar
+    """
+
+    score=0.0
+    target=np.argmax(target)
+    predict=np.argmax(predict)
+    if random.choice([x for x in range(random_number)]) == 1:print("death_lifeimprisonment_score.target:", target, ";predict:", predict)
+    if target==predict:
+        score=1.0
+    if random.choice([x for x in range(random_number)]) == 1:print("death_lifeimprisonment_score:",score)
+    return score
+
+def compute_imprisonment_score(target_value,predict_value):
+    """
+    compute imprisonment score
+    :param target_value: a scalar
+    :param predict_value:a scalar
+    :return: score: a scalar
+    """
+    if random.choice([x for x in range(random_number)]) ==1:print("x.imprisonment_score.target_value:",target_value,";predict_value:",predict_value)
+    score=0.0
+    v=np.abs(np.log(predict_value+1.0)-np.log(target_value+1.0))
+    if v<=0.2:
+        score=1.0
+    elif v<=0.4:
+        score=0.8
+    elif v<=0.6:
+        score=0.6
+    elif v<=0.8:
+        score=0.4
+    elif v<=1.0:
+        score=0.2
+    else:
+        score=0.0
+    if random.choice([x for x in range(random_number)]) ==1:print("imprisonment_score:",score)
+    return score
+
+def compute_micro_macro(label_dict):
+    """
+    compute f1 of micro and macro
+    :param label_dict:
+    :return: f1_micro,f1_macro: scalar, scalar
+    """
+    f1_micro = compute_f1_micro_use_TFFPFN(label_dict)
+    f1_macro= compute_f1_macro_use_TFFPFN(label_dict)
+    return f1_micro,f1_macro
+
+def compute_f1_micro_use_TFFPFN(label_dict):
+    """
+    compute f1_micro
+    :param label_dict: {label:(TP,FP,FN)}
+    :return: f1_micro: a scalar
+    """
+    TF_micro_accusation, FP_micro_accusation, FN_micro_accusation =compute_TF_FP_FN_micro(label_dict)
+    f1_micro_accusation = compute_f1(TF_micro_accusation, FP_micro_accusation, FN_micro_accusation,'micro')
+    return f1_micro_accusation
+
+def compute_f1_macro_use_TFFPFN(label_dict):
+    """
+    compute f1_macro
+    :param label_dict: {label:(TP,FP,FN)}
+    :return: f1_macro
+    """
+    f1_dict= {}
+    num_classes=len(label_dict)
+    for label, tuplee in label_dict.items():
+        TP,FP,FN=tuplee
+        f1_score_onelabel=compute_f1(TP,FP,FN,'macro')
+        f1_dict[label]=f1_score_onelabel
+    f1_score_sum=0.0
+    for label,f1_score in f1_dict.items():
+        f1_score_sum=f1_score_sum+f1_score
+    f1_score=f1_score_sum/float(num_classes)
+    return f1_score
+
+#[this function is for debug purpose only]
+def compute_f1_score_write_for_debug(label_dict,label2index):
+    """
+    compute f1 score. basicly you can also use other function to get result
+    :param label_dict: {label:(TP,FP,FN)}
+    :return: a dict. key is label name, value is f1 score.
+    """
+    f1score_dict={}
+    # 1. compute f1 score for each accusation.
+    for label, tuplee in label_dict.items():
+        TP, FP, FN = tuplee
+        f1_score_single = compute_f1(TP, FP, FN, 'normal_f1_score')
+        accusation_index2label = {kv[1]: kv[0] for kv in label2index.items()}
+        label_name=accusation_index2label[label]
+        f1score_dict[label_name]=f1_score_single
+
+    # 2. each to file system for debug purpose.
+    f1score_file='debug_accuracy.txt'
+    write_object = codecs.open(f1score_file, mode='a', encoding='utf-8')
+    write_object.write("\n\n")
+
+    #tuple_list = sorted(f1score_dict.items(), lambda x, y: cmp(x[1], y[1]), reverse=False)
+    tuple_list = sorted(f1score_dict.items(), key=lambda x: x[1], reverse=False)
+
+    for tuplee in tuple_list:
+        label_name,f1_score=tuplee
+        write_object.write(label_name+":"+str(f1_score)+"\n")
+    write_object.close()
+    return f1score_dict
+
+def compute_f1(TP,FP,FN,compute_type):
+    """
+    compute f1
+    :param TP_micro: number.e.g. 200
+    :param FP_micro: number.e.g. 200
+    :param FN_micro: number.e.g. 200
+    :return: f1_score: a scalar
+    """
+    precison=TP/(TP+FP+small_value)
+    recall=TP/(TP+FN+small_value)
+    f1_score=(2*precison*recall)/(precison+recall+small_value)
+
+    if random.choice([x for x in range(500)]) == 1:print(compute_type,"precison:",str(precison),";recall:",str(recall),";f1_score:",f1_score)
+
+    return f1_score
+
+def compute_TF_FP_FN_micro(label_dict):
+    """
+    compute micro FP,FP,FN
+    :param label_dict_accusation: a dict. {label:(TP, FP, FN)}
+    :return:TP_micro,FP_micro,FN_micro
+    """
+    TP_micro,FP_micro,FN_micro=0.0,0.0,0.0
+    for label,tuplee in label_dict.items():
+        TP,FP,FN=tuplee
+        TP_micro=TP_micro+TP
+        FP_micro=FP_micro+FP
+        FN_micro=FN_micro+FN
+    return TP_micro,FP_micro,FN_micro
+
+def init_label_dict(num_classes):
+    """
+    init label dict. this dict will be used to save TP,FP,FN
+    :param num_classes:
+    :return: label_dict: a dict. {label_index:(0,0,0)}
+    """
+    label_dict={}
+    for i in range(num_classes):
+        label_dict[i]=(0,0,0)
+    return label_dict
+
+def get_target_label_short(y_mulitihot):
+    """
+    get target label.
+    :param y_mulitihot: [0,0,1,0,1,0,...]
+    :return: taget_list.e.g. [3,5,100]
+    """
+    taget_list = [];
+    for i, element in enumerate(y_mulitihot):
+        if element == 1:
+            taget_list.append(i)
+    return taget_list

data/lm_dict.pik

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+import tensorflow as tf
+from  model.multi_head_attention import MultiHeadAttention
+from model.poistion_wise_feed_forward import PositionWiseFeedFoward
+from model.layer_norm_residual_conn import LayerNormResidualConnection
+class BaseClass(object):
+    """
+    base class has some common fields and functions.
+    """
+    def __init__(self,d_model,d_k,d_v,sequence_length,h,batch_size,num_layer=6,decoder_sent_length=None):
+        """
+        :param d_model:
+        :param d_k:
+        :param d_v:
+        :param sequence_length:
+        :param h:
+        :param batch_size:
+        :param embedded_words: shape:[batch_size,sequence_length,embed_size]
+        """
+        self.d_model=d_model
+        self.d_k=d_k
+        self.d_v=d_v
+        self.sequence_length=sequence_length
+        self.h=h
+        self.num_layer=num_layer
+        self.batch_size=batch_size
+        self.decoder_sent_length=decoder_sent_length
+
+    def sub_layer_postion_wise_feed_forward(self, x, layer_index)  :# COMMON FUNCTION
+        """
+        position-wise feed forward. you can implement it as feed forward network, or two layers of CNN.
+        :param x: shape should be:[batch_size,sequence_length,d_model]
+        :param layer_index: index of layer number
+        :return: [batch_size,sequence_length,d_model]
+        """
+        # use variable scope here with input of layer index, to make sure each layer has different parameters.
+        with tf.variable_scope("sub_layer_postion_wise_feed_forward"  + str(layer_index)):
+            postion_wise_feed_forward = PositionWiseFeedFoward(x, layer_index,d_model=self.d_model,d_ff=self.d_model*4)
+            postion_wise_feed_forward_output = postion_wise_feed_forward.position_wise_feed_forward_fn()
+        return postion_wise_feed_forward_output
+
+    def sub_layer_multi_head_attention(self ,layer_index ,Q ,K_s,V_s,mask=None,is_training=None,dropout_keep_prob=0.9)  :# COMMON FUNCTION
+        """
+        multi head attention as sub layer
+        :param layer_index: index of layer number
+        :param Q: shape should be: [batch_size,sequence_length,embed_size]
+        :param k_s: shape should be: [batch_size,sequence_length,embed_size]
+        :param mask: when use mask,illegal connection will be mask as huge big negative value.so it's possiblitity will become zero.
+        :return: output of multi head attention.shape:[batch_size,sequence_length,d_model]
+        """
+        #print("sub_layer_multi_head_attention.",";layer_index:",layer_index)
+        with tf.variable_scope("base_mode_sub_layer_multi_head_attention_" +str(layer_index)):
+            #2. call function of multi head attention to get result
+            multi_head_attention_class = MultiHeadAttention(Q, K_s, V_s, self.d_model, self.d_k, self.d_v, self.sequence_length,self.h,
+                                                            is_training=is_training,mask=mask,dropout_rate=(1.0-dropout_keep_prob))
+            sub_layer_multi_head_attention_output = multi_head_attention_class.multi_head_attention_fn()  # [batch_size*sequence_length,d_model]
+        return sub_layer_multi_head_attention_output  # [batch_size,sequence_length,d_model]
+
+    def sub_layer_layer_norm_residual_connection(self,layer_input ,layer_output,layer_index,dropout_keep_prob=0.9,use_residual_conn=True,sub_layer_name='layer1'): # COMMON FUNCTION
+        """
+        layer norm & residual connection
+        :param input: [batch_size,equence_length,d_model]
+        :param output:[batch_size,sequence_length,d_model]
+        :return:
+        """
+        #print("sub_layer_layer_norm_residual_connection.layer_input:",layer_input,";layer_output:",layer_output,";dropout_keep_prob:",dropout_keep_prob)
+        #assert layer_input.get_shape().as_list()==layer_output.get_shape().as_list()
+        #layer_output_new= layer_input+ layer_output
+        variable_scope="sub_layer_layer_norm_residual_connection_" +str(layer_index)+'_'+sub_layer_name
+        #print("######sub_layer_layer_norm_residual_connection.variable_scope:",variable_scope)
+        with tf.variable_scope(variable_scope):
+            layer_norm_residual_conn=LayerNormResidualConnection(layer_input,layer_output,layer_index,residual_dropout=(1-dropout_keep_prob),use_residual_conn=use_residual_conn)
+            output = layer_norm_residual_conn.layer_norm_residual_connection()
+        return output  # [batch_size,sequence_length,d_model]