BIDI_ML_INFO_EXTRACTION/BiddingKG/dl/product/product_model.py

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author  : bidikeji
# @Time    : 2021/1/13 0013 10:12
# from BiddingKG.dl.common.Utils import getVocabAndMatrix,getModel_word
from BiddingKG.dl.product.data_util import matrix,vocab,input_from_line,result_to_json,get_ner
import tensorflow as tf
import numpy as np
from tensorflow.contrib.crf import crf_log_likelihood
from tensorflow.contrib.crf import viterbi_decode
from tensorflow.contrib.layers.python.layers import initializers

# word_model = getModel_word()
class Product_Model(object):
    def __init__(self):
        self.char_dim = 60
        self.lstm_dim = 120#128 120
        # self.num_tags = 4
        self.num_tags = 7
        self.lr = 0.001
        self.clip = 5.0
        self.dropout_rate = 0.5
        # vocab, matrix = getVocabAndMatrix(word_model, Embedding_size=60)

        # self.matrix = matrix
        # # self.word2id = {k:v for v,k in enumerate(self.vocab)}
        # self.num_chars = len(vocab)+1
        # self.emb_matrix = np.random.random((self.num_chars, self.char_dim))
        # self.emb_matrix[:self.num_chars-1:,:] = self.matrix

        self.emb_matrix = matrix

        self.globel_step = tf.Variable(0, trainable=False)
        self.best_dev_f1 = tf.Variable(0.0, trainable=False)
        self.initializer = initializers.xavier_initializer()

        self.char_inputs = tf.placeholder(dtype=tf.int32, shape=[None, None],name='CharInputs')
        self.targets = tf.placeholder(dtype=tf.int32, shape=[None, None],name='Targets')
        self.dropout = tf.placeholder(dtype=tf.float32, name='Dropout')
        # self.lengths = tf.placeholder(dtype=tf.int32, shape=[None],name='lengths')

        used = tf.sign(tf.abs(self.char_inputs))
        length = tf.reduce_sum(used, reduction_indices=1)
        self.lengths = tf.cast(length, tf.int32)
        self.batch_size = tf.shape(self.char_inputs)[0]
        self.num_steps = tf.shape(self.char_inputs)[1]

        with tf.variable_scope("char_embedding"):
            self.char_lookup = tf.get_variable(
                name="char_embedding",
                # shape=[self.num_chars, self.char_dim],
                initializer=np.array(self.emb_matrix,dtype=np.float32)
            )
        embed = tf.nn.embedding_lookup(self.char_lookup, self.char_inputs)

        with tf.variable_scope("char_BiLSTM"):
            lstm_cell = {}
            for direction in ["forward", "backward"]:
                with tf.variable_scope(direction):
                    lstm_cell[direction] = tf.contrib.rnn.BasicLSTMCell(self.lstm_dim, state_is_tuple=True)
            outputs, final_states = tf.nn.bidirectional_dynamic_rnn(
                lstm_cell["forward"],
                lstm_cell["backward"],
                embed,
                dtype=tf.float32,
                sequence_length=self.lengths
            )
        outputs = tf.concat(outputs, axis=2)

        with tf.variable_scope("project"):
            with tf.variable_scope("hidden"):
                W = tf.get_variable("W", shape=[self.lstm_dim*2, self.lstm_dim],
                                    dtype=tf.float32,initializer=self.initializer)
                b = tf.get_variable("b", shape=[self.lstm_dim],
                                    dtype=tf.float32, initializer=self.initializer)
                output = tf.reshape(outputs, shape=[-1, 2*self.lstm_dim])
                hidden = tf.tanh(tf.nn.xw_plus_b(output, W, b))
                hidden = tf.nn.dropout(hidden, keep_prob=self.dropout) # 添加dropout

        with tf.variable_scope("logits"):
            W = tf.get_variable("W", shape=[self.lstm_dim, self.num_tags],
                                dtype=tf.float32, initializer=self.initializer)
            b = tf.get_variable("b", shape=[self.num_tags])
            pred = tf.nn.xw_plus_b(hidden, W, b)
            self.logits = tf.reshape(pred, [-1, self.num_steps, self.num_tags])

        with tf.variable_scope("crf_loss"):
            small = -1000.0
            start_logits = tf.concat(
                [small*tf.ones(shape=[self.batch_size,1,self.num_tags]), tf.zeros(shape=[self.batch_size,1,1])], axis=-1
            )
            pad_logits = tf.cast(small*tf.ones([self.batch_size, self.num_steps, 1]), tf.float32)
            logits = tf.concat([self.logits, pad_logits], axis=-1)
            logits = tf.concat([start_logits, logits], axis=1)
            targets = tf.concat([tf.cast(self.num_tags*tf.ones([self.batch_size,1]),tf.int32), self.targets], axis=-1)

            self.trans = tf.get_variable(
                name="transitions",
                shape=[self.num_tags+1, self.num_tags+1],
                initializer=self.initializer
            )
            log_likelihood, self.trans = crf_log_likelihood(
                inputs=logits,
                tag_indices=targets,
                transition_params=self.trans,
                sequence_lengths=self.lengths+1
            )
            self.loss = tf.reduce_mean(-log_likelihood)

        with tf.variable_scope("optimizer"):
            self.opt = tf.train.AdamOptimizer(learning_rate=self.lr)
            grads_vars = self.opt.compute_gradients(self.loss)
            capped_grads_vars = [[tf.clip_by_value(g, -self.clip, self.clip), v] for g,v in grads_vars]
            self.train_op = self.opt.apply_gradients(capped_grads_vars, self.globel_step)

        self.saver = tf.train.Saver(tf.global_variables(), max_to_keep=5)

    def create_feed_dict(self, run_type, batch): #is_train
        '''
        :param is_train: Flag, True for train batch
        :param batch: list train/evaluate data
        :return: structured data to feed
        '''
        _, chars, tags = batch
        feed_dict = {
            self.char_inputs:np.asarray(chars),
            self.dropout:1.0
        }
        assert run_type in ['train', 'dev', 'predict']
        if run_type=='train':
            feed_dict[self.targets] = np.asarray(tags)
            feed_dict[self.dropout] = self.dropout_rate
        elif run_type=='dev':
            feed_dict[self.targets] = np.asarray(tags)
        return feed_dict

    def run_step(self, sess, run_type, batch):
        assert run_type in ['train', 'dev', 'predict']
        feed_dict = self.create_feed_dict(run_type, batch)
        if run_type=='train':
            global_step, loss, _ = sess.run(
                [self.globel_step, self.loss, self.train_op],
                feed_dict=feed_dict
            )
            return global_step, loss
        elif run_type=='dev':
            lengths ,logits, loss = sess.run([self.lengths, self.logits, self.loss], feed_dict)
            return lengths, logits, loss
        else:
            lengths ,logits = sess.run([self.lengths, self.logits], feed_dict)
            return lengths, logits

    def run_step_backup(self, sess, is_train, batch):
        feed_dict = self.create_feed_dict(is_train, batch)
        if is_train:
            global_step, loss, _ = sess.run(
                [self.globel_step, self.loss, self.train_op],
                feed_dict=feed_dict
            )
            return global_step, loss
        else:
            lengths ,logits, loss = sess.run([self.lengths, self.logits, self.loss], feed_dict)
            return lengths, logits, loss

    def decode(self, logits, lengths, matrix):
        paths = []
        small = -1000.0
        start = np.asarray([[small]*self.num_tags+[0]])
        for score, length in zip(logits, lengths):
            score = score[:length]
            pad = small * np.ones([length, 1])
            logits = np.concatenate([score, pad], axis=1)
            logits = np.concatenate([start, logits], axis=0)
            path, _  = viterbi_decode(logits, matrix)
            paths.append(path[1:])
        return paths

    def evaluate(self, sess, data_manager, id_to_tag):
        results = []
        trans = self.trans.eval()
        Precision = []
        Recall = []
        F1 = []
        loss = []
        pred_num = 0
        gold_num = 0
        equal_num = 0
        for batch in data_manager.iter_batch():
            strings = batch[0]
            tags = batch[-1]
            # lengths, scores, batch_loss = self.run_step(sess, False, batch)
            lengths, scores, batch_loss = self.run_step(sess, 'dev', batch)
            loss.append(batch_loss)
            batch_paths = self.decode(scores, lengths, trans)
            for i in range(len(strings)):
                result = []
                string = strings[i][:lengths[i]]
                gold = [id_to_tag[int(x)] for x in tags[i][:lengths[i]]]
                pred = [id_to_tag[int(x)] for x in batch_paths[i][:lengths[i]]]
                gold_ner = get_ner("".join(gold))
                pred_ner = get_ner("".join(pred))
                # print('标签实体：',gold_ner)
                # print('预测实体：',pred_ner)
                pred_num += len(pred_ner)
                gold_num += len(gold_ner)
                equal_num += len(gold_ner&pred_ner)
                # precision_temp = len(gold_ner&pred_ner)/(len(pred_ner)+1e-10)
                # recall_temp = len(gold_ner&pred_ner)/(len(gold_ner)+1e-10)
                # f1_temp = 2*(precision_temp*recall_temp)/(precision_temp+recall_temp+1e-10)
                # Precision.append(precision_temp)
                # Recall.append(recall_temp)
                # F1.append(f1_temp)

                if gold_ner!=pred_ner:
                    for char, gold, pred in zip(string, gold, pred):
                            result.append(" ".join([char, gold, pred]))
                    # print(result)
                    results.append(result)
                with open('evaluate_result.txt','w', encoding='utf-8') as f:
                    for rs in results:
                        for line in rs:
                            f.write(line+'\n')
                        f.write('\n')

        # return sum(F1)/len(F1),sum(Precision)/len(Precision),sum(Recall)/len(Recall)
        precision = equal_num/(pred_num+1e-10)
        recall = equal_num/(gold_num+1e-10)
        f1 = 2*(precision*recall)/(precision+recall+1e-10)
        return f1, precision, recall, np.mean(loss)


    def evaluate_line(self, sess, line):
        trans = self.trans.eval(session=sess)
        # lengths, scores = self.run_step(sess, False, input_from_line(line))
        lengths, scores = self.run_step(sess, 'predict', input_from_line(line))
        batch_paths = self.decode(scores, lengths, trans)
        tags = batch_paths[0]  # batch_paths[0][:lengths] 错误
        return result_to_json(line, tags)