summary_tensorflow_xingongsuo.py

summary_tensorflow_xingongsuo

#coding:utf-8

import tensorflow as tf
import numpy as np

from tensorflow.contrib import rnn
from tensorflow.python.layers import core as layers_core

import time
import traceback
import sys
import os

# 获得 每个人 天数 列表
def get_num(filename):
    day_list = []
    # judge_str
    s = ''
    t = ''

    i = 0
    for line in open(filename):
        # time_list
        l = []

        # judge
        line = line.replace('\n','')
        if line == '':
            continue  

        # split
        little = line.split(',')

        # in
        if s == '':
            s = little[0]
        if t == '':
            t = little[1][:10]
        
        if s != little[0]:
            s = little[0]
            t = little[1][:10]

            day_list.append(i)
            i = 0
        elif t != little[1][:10]:
            t = little[1][:10]
            i += 1


    return day_list

STEPS = 0
BATCH_SIZE = 1  # 训练数据batch的大小

# 参数
HIDDEN_SIZE = 128  # 隐藏层规模
NUM_LAYERS = 5  # LSTM结构的层数

LEARNING_RATE = 0.001  # 学习率
KEEP_PROB = 0.5  # 节点不被dropout的概率，防止过拟合


ONEHOT_SIZE = 604 # onehot维度
EMBEDDING_SIZE = 128 # 嵌入向量

REVERSE = 2
ID_SIZE = REVERSE + ONEHOT_SIZE 


# 输入: tf.placeholder
def model_inputs():
    """
    tf输入：输入文本、目标文本、学习率、keep_prob
    :return: 输入、目标、学习率、keep_prob
    """
    with tf.name_scope("input"):
        text_int_input = tf.placeholder(tf.int32, shape=[BATCH_SIZE,None], name="input")
        text_int_target = tf.placeholder(tf.int32, shape=[BATCH_SIZE,None], name="output")
    learning_rate = tf.placeholder(tf.float32, shape=None)
    keep_prob = tf.placeholder(tf.float32, shape=None, name="keep_prob")
    source_sequence_length = tf.placeholder(tf.int32, [None], name="source_sequence_length")
    target_sequence_length = tf.placeholder(tf.int32, [None], name="target_sequence_length")
    max_target_sequence_length = tf.reduce_max(target_sequence_length)
    return text_int_input, text_int_target, learning_rate, keep_prob, source_sequence_length, \
                        target_sequence_length, max_target_sequence_length

# 处理targets、加入<GO>
def process_decoder_input(data):
    '''123.206.60.140:5000
    补充<GO>，并移除最后一个字符
    '''
    # cut掉最后一个字符
    ending = tf.strided_slice(data, [0, 0], [BATCH_SIZE, -1], [1, 1])
    decoder_input = tf.concat([tf.fill([BATCH_SIZE, 1], 0), ending], 1)

    return decoder_input


# 编码
def encoding_layer(inputs, source_sequence_length, keep_prob):
    enc_cell = []
    for i in range(NUM_LAYERS):
        lstm_cell = rnn.BasicLSTMCell(HIDDEN_SIZE)
        lstm_cell = tf.contrib.rnn.DropoutWrapper(lstm_cell, output_keep_prob=keep_prob)
        enc_cell.append(lstm_cell)
    
    enc_cell = tf.nn.rnn_cell.MultiRNNCell(cells=enc_cell, state_is_tuple=True)

    enc_outputs, enc_state = tf.nn.dynamic_rnn(enc_cell, inputs, \
                sequence_length=source_sequence_length, dtype=tf.float32)
    return enc_outputs, enc_state


# 训练解码层
def decoding_layer_train(enc_state, dec_cell, dec_embed_input, target_sequence_length,
                         output_layer, keep_prob, max_target_sequence_length, decoding_scope):
    """
    训练的解码层
    :param enc_state: 编码神经网络状态
    :param dec_cell: 解码神经元
    :param dec_embed_input: 解码层嵌入输入
    :param sequence_length: 序列长度
    :param decoding_scope: tensorflow解码命名空间
    :param output_fn: 输出层的函数
    :param keep_prob: keep_prob
    :return: 训练回归数
    """
    # train_decoder_fn = tf.contrib.seq2seq.simple_decoder_fn_train(enc_state)

    #try:
    
    helper = tf.contrib.seq2seq.TrainingHelper(dec_embed_input, target_sequence_length)

    decoder = tf.contrib.seq2seq.BasicDecoder(dec_cell, helper, enc_state, output_layer=output_layer)
    

    train_logits, _, _ = tf.contrib.seq2seq.dynamic_decode(decoder, impute_finished=True,\
         maximum_iterations=max_target_sequence_length, scope=decoding_scope)

    #train_logits = tf.nn.dropout(train_logits, keep_prob)
    return train_logits


def decoding_layer_infer(enc_state, dec_cell, dec_embeddings, start_of_sequence_id, end_of_sequence_id,
                       output_layer, keep_prob, max_target_sequence_length, decoding_scope):
    """
    推断的解码层
    :param enc_state: 编码神经网络状态
    :param dec_cell: 解码神经元
    :param dec_embeddings: 解码层嵌入
    :param start_of_sequence_id: GO的id
    :param end_of_sequence_id: EOS的id
    :param maximum_length: 解码的最大timestep
    :param vocab_size: 词汇数量
    :param decoding_scope: tensorflow解码命名空间
    :param output_fn: 输出层的函数
    :param keep_prob: keep_prob
    :return: 推断回归数
    """
    # infer_decoder_fn = tf.contrib.seq2seq.simple_decoder_fn_inference(
    #    output_fn, enc_state, dec_embeddings, start_of_sequence_id, end_of_sequence_id, 
    #    maximum_length, vocab_size)

    start_tokens = tf.tile(tf.constant([start_of_sequence_id], dtype=tf.int32), [BATCH_SIZE], name='start_tokens')

    helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(dec_embeddings, start_tokens, end_of_sequence_id)

    decoder = tf.contrib.seq2seq.BasicDecoder(dec_cell, helper, enc_state, \
                output_layer=output_layer)

    #inference_logits, _, _ = tf.contrib.seq2seq.dynamic_rnn_decoder(dec_cell, infer_decoder_fn, scope=decoding_scope)
    #inference_logits = tf.nn.dropout(inference_logits, keep_prob)

    inference_logits, _, _ = tf.contrib.seq2seq.dynamic_decode(decoder, impute_finished=True,
                                scope=decoding_scope, maximum_iterations=max_target_sequence_length)

    #inference_logits = tf.nn.dropout(inference_logits, keep_prob)

    return inference_logits


def decoding_layer(dec_embed_input, dec_embeddings, enc_state, target_sequence_length,
                   keep_prob, max_target_sequence_length, enc_outputs):
    """
    解码层
    :param dec_embed_input: 解码层嵌入输入
    :param dec_embeddings: 解码层嵌入
    :param enc_state: 编码神经网络状态
    :param vocab_size: 词汇数量
    :param sequence_length: 序列长度
    :param target_vocab_to_int: 从词汇到id的字典
    :param keep_prob: keep_prob
    :return: 训练回归数、推断回归数
    """

    attention_mechanism = tf.contrib.seq2seq.LuongAttention(HIDDEN_SIZE, enc_outputs)

    
    dec_cell = []
    for i in range(NUM_LAYERS):
        lstm_cell = rnn.BasicLSTMCell(HIDDEN_SIZE)

        # 注意力
        lstm_cell = tf.contrib.seq2seq.AttentionWrapper(lstm_cell, attention_mechanism)

        lstm_cell = tf.contrib.rnn.DropoutWrapper(lstm_cell, output_keep_prob = keep_prob)        
        dec_cell.append(lstm_cell)
    #dec_cell = tf.contrib.rnn.DropoutWrapper(dec_cell, output_keep_prob=keep_prob)
    dec_cell = tf.nn.rnn_cell.MultiRNNCell(cells=dec_cell, state_is_tuple=True)

    
    # 注意力机制状态
    state = dec_cell.zero_state(BATCH_SIZE, tf.float32)
    state_list = []
    for i in range(len(state)):
        state_list.append(state[i].clone(cell_state=enc_state[i]))
    init_state = tuple(state_list)



    with tf.variable_scope("decoding") as decoding_scope:
        # Output Layer
        # vocab_size： the output unit of the layer
        #output_fn = lambda x: tf.contrib.layers.fully_connected(x, ONEHOT_SIZE, None, scope=decoding_scope)
        
        output_layer = layers_core.Dense(ID_SIZE,
                                    kernel_initializer = tf.truncated_normal_initializer(mean = 0.0, stddev=0.1))

        train_logits = decoding_layer_train(init_state, dec_cell, dec_embed_input, target_sequence_length, 
            output_layer, keep_prob,  max_target_sequence_length, decoding_scope)   

    with tf.variable_scope("decoding", reuse=True) as decoding_scope:   

        infer_logits = decoding_layer_infer(init_state, dec_cell, dec_embeddings, 0, 1,
                    output_layer, keep_prob, max_target_sequence_length, decoding_scope)

    return train_logits, infer_logits


def seq2seq_model(inputs, targets, keep_prob, source_sequence_length,
                  target_sequence_length, max_target_sequence_length):
    """
    创建神经网络中的序列到序列模型
    :param inputs: 输入placeholder
    :param target_data: 目标placeholder
    :param keep_prob: keep_prob placeholder
    :param batch_size: 批次大小
    :param sequence_length: 序列长度
    # onehot 编码、向量数量
    :param source_vocab_size: 输入词汇大小
    :param target_vocab_size: 目标词汇大小
    # 神经网络 神经单元数
    :param enc_EMBEDDING_SIZE: 编码嵌入大小
    :param dec_EMBEDDING_SIZE: 解码嵌入大小
    :param target_vocab_to_int: 从目标词语到id的字典
    :return: 训练回归数、推断回归数
    """
    # TODO: Implement Function
    #onehot编码 input_data: 数据(batch_size*source_vocab_size) | source_vocab_size: 输入维度 | enc_EMBEDDING_SIZE: 输出维度
    
    dec_embeddings = tf.Variable(tf.random_uniform([ID_SIZE, EMBEDDING_SIZE]))
    targets = process_decoder_input(targets)
    target_embed = tf.nn.embedding_lookup(dec_embeddings, targets)

    #enc_embed_input = tf.contrib.layers.embed_sequence(inputs, ID_SIZE, EMBEDDING_SIZE)
    enc_embed_input = tf.nn.embedding_lookup(dec_embeddings, inputs)

    enc_outputs, enc_state = encoding_layer(target_embed, source_sequence_length, keep_prob)

    # process_decoding_input 去掉最后id、加入开头id
    #target_data = process_decoding_input(target_data, target_vocab_to_int, batch_size)
    #target_embed = tf.contrib.layers.embed_sequence(target_data, target_vocab_size, dec_EMBEDDING_SIZE) 
    # dec_embeddings target_vocab_size*dec_EMBEDDING_SIZE   
    
    # 返回dec_embeddings中的第几行
    
    


    return decoding_layer(target_embed, dec_embeddings, enc_state, target_sequence_length, \
                  keep_prob, max_target_sequence_length, enc_outputs)



train_graph = tf.Graph()
with train_graph.as_default():
    inputs, targets, lr, keep_prob, source_sequence_length, target_sequence_length, \
            max_target_sequence_length = model_inputs()

    
    train_logits, inference_logits = seq2seq_model(
        # 反向翻转过来
        inputs, 
        # 目标文本
        targets, 
        keep_prob, 
        source_sequence_length,
        target_sequence_length,
        max_target_sequence_length
        )

    training_logits = tf.identity(train_logits.rnn_output, name='logits')

    inference = tf.identity(inference_logits.rnn_output, name='infer')


    inference_logits = tf.identity(inference_logits.sample_id, name='predictions')

    masks = tf.sequence_mask(target_sequence_length, max_target_sequence_length, dtype=tf.float32, name='masks')
    

    with tf.name_scope("cost"):

        lossee = tf.contrib.seq2seq.sequence_loss(inference, targets, masks)
        # Loss function
        cost = tf.contrib.seq2seq.sequence_loss(
            #train_logits,
            training_logits,
            targets, 
            #tf.ones([input_shape[0], sequence_length]))
            masks)


        tf.summary.scalar('infer_loss', lossee)
        tf.summary.scalar('train_loss', cost)


    #tf.identity(inference_logits, 'logits')

    with tf.name_scope("optimization"):
        

        # Optimizer
        optimizer = tf.train.AdamOptimizer(lr)

        # Gradient Clipping
        gradients = optimizer.compute_gradients(cost)
        capped_gradients = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in gradients if grad is not None]
        train_op = optimizer.apply_gradients(capped_gradients)


# 正确率
def get_accuracy(target, logits, flag=False):
    """
    Calculate accuracy
    """

    max_seq = max(target.shape[1], logits.shape[1])
    if max_seq - target.shape[1]:
        target = np.pad(
            target,
            [(0,0),(0,max_seq - target.shape[1])],
            'constant')
    if max_seq - logits.shape[1]:
        logits = np.pad(
            logits,
            [(0,0),(0,max_seq - logits.shape[1]), (0,0)],
            'constant')

    #return np.mean(np.equal(target, np.argmax(logits, 2)))
    if flag is True:
        return np.mean(np.equal(target, np.argmax(logits, 2)))
    else:
        return np.mean(np.equal(target, logits))

# 读取数据
def read_data_sets(file_name, batch_size):
    # data
    data_list = []
    name_list = []


    # batch_list
    lll = []
    # every_list
    lists = []
    # judge_str
    s = ''
    t = ''
    for line in open(file_name):
        # time_list
        l = []

        # judge
        line = line.replace('\n','')
        if line == '':
            continue  

        # split
        little = line.split(',')

        # in
        if s == '':
            s = little[0]
        if t == '':
            t = little[1][:10]
        
        # get
        lists.append(int(little[2]) + 2)

        if s != little[0] or t != little[1][:10]:
            s = little[0]
            t = little[1][:10]

            lll.append(lists)
            data_list.append(little[1][:10])
            name_list.append(little[0])
            lists = []

            if len(lll) == batch_size:
                yield lll, data_list, name_list
                lll = []
                data_list = []
                name_list = []

# 取向量对应id
def get_id(seq):
    id = None
    for i in range(len(seq)):
        if seq[i] == 1:
            id = i + REVERSE
    if id is None:
        print(seq)
    return id

# 取一天中向量对应id
def get_line_id(day_list):
    l = []
    for seq in day_list:
        id = get_id(seq)
        if id is None:
            return None
        l.append(id)
    l.append(1)
    return l


def deal_with_data(batch_list):
    lists = []
    for day in batch_list:
        d = get_line_id(day)
        if d is None:
            return None
        lists.append(d)
    return lists
    
def get_len(lists):
    l = []
    for seq in lists:
        l.append(len(seq))
    return l

def get_shape(lists):
    l = [lists]
    return np.array(l)


with tf.Session(graph=train_graph) as sess:

    merged = tf.summary.merge_all()
    sess.run(tf.global_variables_initializer())

    # 目录
    dir_name = "./log"

    dir_day = "%s/day" % dir_name
    dir_act = "%s/act" % dir_name
    writer = tf.summary.FileWriter(dir_name, sess.graph)
    #filename = 'result.csv'


    time_begin = time.time()
    print("Reading begins @ %f" % time_begin)

    step = 1
    #f = open(filename, 'a+')
    day_list = get_num('id.csv')
    #print(len(day_list))
    


    # train
    for (x,data_list,name_list) in read_data_sets('id.csv', BATCH_SIZE):
        one_name = str(name_list).replace('[','').replace(']','').replace('\'','')
        one_data = str(data_list).replace('[','').replace(']','').replace('\'','')
        
        

       # if step > 300:
       #     break

        if step == 1:
            # 初始化
            # 人数
            one_step = 0
            # 步数
            one_i = 1
            one_day_i = 1

            # 现在的编号
            s_name = one_name

            # 训练数字
            one_step = day_list[one_step] // 2

            # 目录
            dirname_day = dir_day + s_name
            dirname_act = dir_act + s_name
            os.mkdir(dirname_day)
            os.mksir(dir_act)

            # writter
            one_writer = tf.summary.FileWriter(dirname_day, sess.graph, filename_suffix=s_name)
            one_day_writer = tf.summary.FileWriter(dirname_act, sess.graph, filename_suffix=s_name)

            one_file = "./results/%s.csv" % s_name
            f = open(one_file, 'a+')
        
        if s_name != one_name:

            one_step += 1
            one_i = 1
            one_day_i = 1

            f.close()

            one_step = day_list[one_step] // 2

            s_name = one_name

	        one_writer.close()
	        one_day_writer.close()

            # 目录
            dirname_day = dir_day + s_name
            dirname_act = dir_act + s_name
            os.mkdir(dirname_day)
            os.mksir(dir_act)

            # writter
            one_writer = tf.summary.FileWriter(dirname_day, sess.graph, filename_suffix=s_name)
            one_day_writer = tf.summary.FileWriter(dirname_act, sess.graph, filename_suffix=s_name)

            one_file = "./results/%s.csv" % s_name
            f = open(one_file, 'a+')


        l = get_len(x)
        
        x = np.array(x)
           

        if one_i < one_step:
            _, loss, infer_logits, logits, summary = sess.run([train_op, cost, inference_logits, training_logits, merged], {inputs: x, targets: x, lr: LEARNING_RATE, 
                source_sequence_length: l, target_sequence_length: l, keep_prob: KEEP_PROB})

            loss_list = []
            for i in range(x.shape[1]):
                one_day_i += 1
                xx = get_shape(np.array([x[0][i]]))
                loss_on, one_summary = sess.run([cost, merged], {inputs: xx,targets: xx, \
                    source_sequence_length: [1], target_sequence_length: [1], keep_prob:1.0})
                one_day_writer.add_summary(one_summary, one_day_i)
                loss_list.append(loss_on)
            
            one_writer.add_summary(summary, one_i)
            
            train_acc = get_accuracy(x, logits, True)

            if step % 200 == 1:
                print("Train Iter " + str(step * BATCH_SIZE) + ", Date" + str(data_list) + ", Name" + str(name_list) + \
                    ", Minibatch accuracy= " + "{:.6f}".format(train_acc) + ", Minibatch Loss= " + "{:.6f}".format(loss))

            
	        f.write("Date: " + one_data + ",Accuracy: " + "{:.6f}".format(train_acc) + ",Loss: " + \
                "{:.6f}".format(loss) + '\n')

            one_inputs = str(x.tolist()).replace('[','').replace(']','')
            one_logits = str(infer_logits.tolist()).replace('[','').replace(']','')
            f.write(one_inputs + '\n')
            f.write(one_logits + '\n')
            f.write(str(loss_list).replace('[','').replace(']','') + '\n')

        else:
            loss, summary = sess.run([lossee, merged], {inputs: x, targets: x, 
                    source_sequence_length: l, target_sequence_length: l, keep_prob: 1.0})            
            logits = sess.run(inference_logits, {inputs: x, source_sequence_length: l,
                            target_sequence_length: l, keep_prob: 1.0})
                
            loss_list = []
            for i in range(x.shape[1]):
                xx = get_shape(np.array([x[0][i]]))
                loss_on, one_summary = sess.run([cost, merged], {inputs: xx,targets: xx, \
                    source_sequence_length: [1], target_sequence_length: [1], keep_prob:1.0})
                one_day_writer.add_summary(one_summary, one_day_i)
                loss_list.append(loss_on)
            
            one_writer.add_summary(summary, one_i)

            train_acc = get_accuracy(x, logits)

            if step % 200 == 1:
                print("Train Iter " + str(step * BATCH_SIZE) + ", Date" + str(data_list) + ", Name" + str(name_list) + \
                    ", Minibatch accuracy= " + "{:.6f}".format(train_acc) + ", Minibatch Loss= " + "{:.6f}".format(loss))
		
            f.write("Date: " + one_data + ",Accuracy: " + "{:.6f}".format(train_acc) + ",Loss: " + \
                "{:.6f}".format(loss) + '\n')

            one_inputs = str(x.tolist()).replace('[','').replace(']','')
            one_logits = str(logits.tolist()).replace('[','').replace(']','')
            f.write(one_inputs + '\n')
            f.write(one_logits + '\n')
            f.write(str(loss_list).replace('[','').replace(']','') + '\n')
		
            
        
        i += 1
        one_day_i += 1
        step += 1

    print(step)
    


    time_end = time.time()
    print("Reading ends @ %f" % time_end)
    training_time = time_end - time_begin
    print("Reading elapsed time: %f s" % training_time)
    print("Optimization Finished!")

    # Save Model
    #saver = tf.train.Saver()
    #saver.save(sess, save_path)
    #print('Model Saved')