get data as array :param X_mask_lm_train: :param y_mask_lm_train: :param p_mask_lm_train: :return:

use transformer encoder to encode the input, output a sequence. input: [batch_size,sequence_length,d_embedding] :return: output:[bat

assign pretrained word embedding :param sess: :param vocabulary_index2word: :param vocab_size: :param model: :param word2vec_

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:

create or load vocabulary and label using training data. process as: load from cache if exist; load data, count and get vocabularies and labe

do evaluation using validation set, and report loss, and f1 score. :param sess: :param model: :param valid: :param num_classes:

do evaluation using validation set, and report loss, and f1 score. :param sess: :param model: :param valid: :param num_classes:

get input strings and labels by passing a line of raw input. :param line: :return:

read file, and return lines :param file_path: path of ifle :return: lines, a list

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_arra

compute score for death or life imprisonment :param target: a list :param predict: an array :return: score: a scalar

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 lab

compute f1 of micro and macro :param label_dict: :return: f1_micro,f1_macro: scalar, scalar

main computation graph here: 1.embedding-->2.CONV-RELU-MAX_POOLING-->3.linear classifier

generate label with input :param input_x: shape of [batch_size, sequence_length] :return: y:[batch_size]

generate label with input :param input_x: shape of [batch_size, sequence_length] :return: y:[batch_size]

generate label with input :param input_x: shape of [batch_size, sequence_length] :return: y:[batch_size]

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)}

x should be:[batch_size,sequence_length,d_model] :return:

convert data as indexes using word2index dicts. 1) use cache file if exist; 2) read source files; 3)transform to train/valid data to standard

multi head attention :param Q: query. shape:[batch,sequence_length,d_model] :param K_s: keys. shape:[batch,sequence_length,d

positional wise fully connected feed forward implement as two layers of cnn x: [batch,sequence_length,d_model] :return:

layer norm & residual connection :param input: [batch_size,equence_length,d_model] :param output:[batch_size,sequence_length,

multi head attention as sub layer :param layer_index: index of layer number :param Q: shape should be: [batch_size,sequence_l

position-wise feed forward. you can implement it as feed forward network, or two layers of CNN. :param x: shape should be:[batch_size

transform data to index using vocab and label dict. :param lines: :param vocab_word2index: :param accusation_label2index: :param

Truncates a sequence pair in place to the maximum length.

split list into sub lists:分块 :param lines: total thing :param chunk_num: num of chunks :return: return chunks but the last chunk may

split list into sub lists:分块 :param lines: total thing :param chunk_num: num of chunks :return: return chunks but the last chunk may

compute micro FP,FP,FN :param label_dict_accusation: a dict. {label:(TP, FP, FN)} :return:TP_micro,FP_micro,FN_micro

compute true postive(TP), false postive(FP), false negative(FN) given target lable and predict label :param y_targetlabel_list: a list. lengt

compute f1_macro :param label_dict: {label:(TP,FP,FN)} :return: f1_macro

compute f1_micro :param label_dict: {label:(TP,FP,FN)} :return: f1_micro: a scalar

compute imprisonment score :param target_value: a scalar :param predict_value:a scalar :return: score: a scalar

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_cla

Converts a single `InputExample` into a single `InputFeatures`.

Creates a classification model.

do evaluation using validation set, and report loss, and f1 score. :param sess: :param model: :param valid: :param num_classes:

dump cache to h5 :param cache_file: :param train: a tuple :param valid: a tuple :param test: a tuple :return: return nothing

singel layer for encoder.each layers has two sub-layers: the first is multi-head self-attention mechanism; the second is position-wis

Gets the list of labels for this data set.

get dict of lable to index. :param lines: lines from input file :param tokenize_style: :return:

get target label. :param y_mulitihot: [0,0,1,0,1,0,...] :return: taget_list.e.g. [3,5,100]

this is for fine-tuning. main inference logic here: invoke transformer model to do inference,input is a sequence, output is also a se

main inference logic here: invoke transformer model to do inference. input is a sequence, output is also a sequence. input representa

this is for fine-tuning. main inference logic here: invoke transformer model to do inference,input is a sequence, output is also a se

this is for pre-trained language model. main inference logic here: invoke transformer model to do inference,input is a sequence, outp

this is for pre-trained language model. main inference logic here: invoke transformer model to do inference,input is a sequence, outp

define all weights here

define all weights here

define all weights here

load cache from h5 :param cache_file: :return: train,valid, test

load pretrained word2vec in txt format :param word2vec_model_path: :return: word2vec_dict. word2vec_dict[word]=vector

generate data for perform mask language model. :parameter source_file: source file where raw data come from :parameter target_file: save

restore only those variable that exists in the model :param session: :param save_file: :return:

pad and truncate input to maxlen based on trucating and padding strategy :param x_list:e.g. [1,10,3,5,...] :return:result_list:a new list

do online prediction. each time make prediction for one instance. you can change to a batch if you want. :param line: a list. element is

project the representation, then to do classification. :param h: [batch_size,sequence_length,d_model] :return: logits: [batch

scaled dot product attention :param Q: query. shape:[batch,sequence_length,d_model] :param K_s: keys. shape:[batch,sequenc

based on the loss, use SGD to update parameter

based on the loss, use SGD to update parameter

based on the loss, use SGD to update parameter

based on the loss, use SGD to update parameter

based on the loss, use SGD to update parameter

convert to multi-hot style :param label_list: e.g.[0,1,4], here 4 means in the 4th position it is true value(as indicate by'1') :param la

Constructs a InputExample. Args: guid: Unique id for the example. text_a: string. The untokenized text of the first sequence. For sin

init all hyperparameter with config class, define placeholder, computation graph

:param d_model: :param d_k: :param d_v: :param sequence_length: :param h: :param batch_size:

init all hyperparameter with config class, define placeholder, computation graph

:param d_model: :param d_k: :param d_v: :param sequence_length: :param h: :param batch_size:

init all hyperparameter with config class, define placeholder, computation graph

:param x: shape should be:[batch,sequence_length,d_model] :param layer_index: index of layer :return: shape:[sequence_length

Reads a tab separated value file.

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 ar

Gets a collection of `InputExample`s for the dev set.

See base class.

Gets a collection of `InputExample`s for prediction.

Gets a collection of `InputExample`s for the train set.