TensorFlow建立深度神经网络解决二分类问题（注释非常详细，通过实例学框架）

（作者：陈玓玏）
分享一个朋友的人工智能教程。零基础！通俗易懂！风趣幽默！还带黄段子！大家可以看看是否对自己有帮助http://www.captainbed.net/luanpeng

一、 实现功能

从CSV文件中读取数据，然后构建深度神经网络，各层神经元个数分别为3/5/2/4/1，因为是二分类问题，所以输出层只需要一个神经元。前四层，包括输入层的激活函数都是Relu，还定义了Elu函数，是Relu函数的改进版，输出层使用的是sigmoid激活函数。损失函数定义为交叉熵损失函数，优化方法采用的梯度下降法。最后对结果进行评估，虽然神经网络中通常是使用准确度来评估，但是我还是比较喜欢用KS，因为风控中用得多的是KS，所以我在最后把最后一轮求得的所有参数都写入CSV文件了，通过CSV文件再把参数读出来，重新计算预测值，求得KS。

这一系列的过程其实就是在定义数据和计算图，因为TensorFlow会将所有的步骤事先生成计算图graph，可以理解为流水线，然后在session中根据定义好的流水线逐步进行计算。特征x和样本真实值y通过占位符事先定义，能够更灵活地接收各维度数据的输入，所有的权重和偏置等需要求解的参数通过TensorFlow的variable定义，全部变量和网络定义好之后，通过session启动训练，并输出结果。

基本上要说的都在注释里，直接看注释就可以了，边跑代码边看效果最好~

二、 完整代码（方法一）

-*- coding: utf-8 -*-
"""   
Created on Fri Dec 21 09:10:26 2018

@author: chendile
"""
import numpy as np
import pandas as pd
from sklearn import metrics
import risk_model_function as md
import matplotlib.pyplot as plt
# 定义数据
# 定义计算图与变量
# 定义会话
# 进行计算

#===========================定义激活函数===================================
#定义relu激活函数
def relu(x):
    if x>0:
        y = x
    else:
        y = 0
    return y

#定义sigmoid激活函数
def sigmoid(x):
    return 1/(1+np.exp(-x))

#定义elu激活函数，这是relu函数的改进版，不会出现dropout，因为神经元少的时候使用relu可能会造成整层神经网络都是死神经元的情况
def elu(x):
    if x>=0:
        y = x
    else:
        y = np.exp(x)-1
    return y
#===========================tensorflow读取csv文件====================================
def read_csv_dnn_notcontrib():
    import tensorflow as tf
    import pandas as pd
#    import tensorflow as tf

    #这里两句是加载手写体案例minist的数据集，dnn也可以用来识别手写体，只需要把图像数据展开入模即可
    from tensorflow.examples.tutorials.mnist import input_data
    mnist = input_data.read_data_sets("D:/Users/chendile/AppData/Local/Temp/pip-uninstall-ktrcfkmd/users/chendile/appdata/local/continuum/anaconda3/lib/site-packages/tensorflow/examples/tutorials/mnist/MNIST_data/",one_hot=True)
    #print(pd.DataFrame(mnist))
    #这里是通过TensorFlow的string_input_producer读取CSV文件
    filename_queue = tf.train.string_input_producer(["D:/CDL_code/sample_y60all_data_sf_xs_app_20180816_filter_drophead.csv"],num_epochs=10)
    reader = tf.TextLineReader()
    key, value = reader.read(filename_queue)
    #print(value)
    
    # Default values, in case of empty columns. Also specifies the type of the
    # decoded result.
    col = []
    #定义数据的默认值，如果数据为空，则会填充为这个默认值，默认值写为整数则会认为这一列类型为整数，定义为float则默认这一列为float，所以要格外注意小数点
    record_defaults = [[1.00]]*2187
    
    #解码csv文件的值为适合TensorFlow处理的格式，并将空值填充为默认值
    col = tf.decode_csv(value, record_defaults = record_defaults)
    #print(col)
    
    #csv中x和y是在一起的，但是在放入模型前需要分别取出它们，我这里的最后一列是y，所以定义如下
    features = tf.stack(col[0:-1])
    label = tf.stack(col[-1])
    '''
    这一段没有用到
    init_op = tf.global_variables_initializer()
    local_init_op = tf.local_variables_initializer()  # local variables like epoch_num, batch_size 可以不初始化local
    
    with tf.Session() as sess:
        sess.run(init_op)
        sess.run(local_init_op)
    
        # Start populating the filename queue.
        coord = tf.train.Coordinator()
        threads = tf.train.start_queue_runners(coord=coord)
    
        for i in range(5):
            # Retrieve a single instance:
            example, label = sess.run([features, label])
            print(example)
            print(label)
    
        coord.request_stop()
        coord.join(threads)
    '''
    #初始化所有的变量，包括全局变量和局部变量，使用这个每次TensorFlow都会提示被弃用了，所以也可以考虑别的方法来初始化变量，但是必须初始化，以下展示了两种初始化方法
    init_op = tf.global_variables_initializer()
    local_init_op = tf.local_variables_initializer()  # local variables like epoch_num, batch_size 可以不初始化local
    #tf.local_variables_initializer().run()
    init_op = tf.group(tf.global_variables_initializer(),tf.local_variables_initializer())
    #深度学习通常都是采用mini-batch方法来训练，也就是一次训练不会用到全部样本，而是随机抽取一定数量的样本，这里我定义的是一次用256个样本
    example_batch, label_batch = tf.train.shuffle_batch([features,label], batch_size=256, capacity=200, min_after_dequeue=100, num_threads=3)  
    
    
    #============================开始定义神经网络的结构=======================
    # 1.定义数据。在神经网络里我们需要定义的数据就是输入训练/测试数据，而变量用来存储网络模型里的各种参数。
    #定义的是输入输出层，输入层有2186个节点，输出层有1个节点，因为现在是二分类问题，如果是手写体识别数字那输出层就应该要10个节点
    #placeholder是一个占位符，这里的x希望输入任意数量的2186维的向量，暂时没有具体的数据
    x = tf.placeholder( tf.float32, [None, 2186] )
    y_ = tf.placeholder( tf.float32, [None, 1] )
    
    # 2.定义TensorFlow的计算图和变量。对于神经网络来说，主要是三个步骤：定义网络模型，定义损失函数、定义优化方法。
    #求得的权重矩阵和偏置向量会存储在这两个Variable中，变量在计算过程中会产生实际的值，可以在session中获取实际的值。
    #初始化方法有很多种，神经网络是不适合用全0初始化的，常用的有这么几种：截尾正态分布：truncated_normal，正态分布：random_normal，均匀分布：random_uniform，吴恩达老师还建议过根据上一层的神经元个数来初始化这一层的权重
    #各种参数初始化的方法可以参见这篇文章：https://blog.csdn.net/dcrmg/article/details/80034075
    W_1 = tf.Variable( tf.random_normal([2186,3], mean=0.01,stddev=0.3) )  #w为2186*3的矩阵，输入层为2186个特征
    b_1 = tf.Variable( tf.random_normal([3], mean=0.01,stddev=0.3) )   #定义并初始化偏置项，第一层3个神经元，因此有3个偏置项
    # 激活函数定义，建立模型，这里的深度神经网络和卷积神经网络都来自tf.nn，当前使用的激活函数是elu，tf.matmul是x*W，即求得两个矩阵相乘的结果，如果是tf.multiply即点乘
    y_1 = tf.nn.elu( tf.matmul(x,W_1) + b_1)
    #placeholder定义一个dropout的概率
    #keep_prob = tf.placeholder("float")
    #y_1 = tf.nn.dropout(y_1, keep_prob)
    print("完成输入层定义")
#    '''
   #定义第二层神经元的计算图
    W_2 = tf.Variable( tf.random_normal([3,5], mean=0.01,stddev=0.3) )  #w为3*5的矩阵，因为上一层有3个神经元，这一层有5个
    b_2 = tf.Variable( tf.random_normal([5], mean=0.01,stddev=0.3) )   
    y_2 = tf.nn.elu( tf.matmul(y_1,W_2) + b_2 )
    #placeholder定义一个dropout的概率
    #keep_prob = tf.placeholder("float")
    #y_2 = tf.nn.dropout(y_2, keep_prob)
    print("完成第2层定义")
#    '''
   #定义第三层神经元的计算图
    W_3 = tf.Variable( tf.random_normal([5,2], mean=0.01,stddev=0.3) )  #w为5*2的矩阵
    b_3 = tf.Variable( tf.random_normal([2], mean=0.01,stddev=0.3) )   
    y_3 = tf.nn.elu( tf.matmul(y_2,W_3) + b_3 )
    #placeholder定义一个dropout的概率
    #keep_prob = tf.placeholder("float")
    #y_3 = tf.nn.dropout(y_3, keep_prob)
    print("完成第3层定义")
    #定义第四层神经元的计算图
    W_4 = tf.Variable( tf.random_normal([2,4], mean=0.01,stddev=0.3) )  #w为2*4的矩阵
    b_4 = tf.Variable( tf.random_normal([4], mean=0.01,stddev=0.3) )   
    y_4 = tf.nn.elu( tf.matmul(y_3,W_4) + b_4 )
    #placeholder定义一个dropout的概率
    #keep_prob = tf.placeholder("float")
    #y_4 = tf.nn.dropout(y_4, keep_prob)
    print("完成第4层定义")
    #定义第5层神经元的计算图
    W_5 = tf.Variable( tf.random_normal([4,1],mean=0.01,stddev=0.3) )  #w为4*1的矩阵
    b_5 = tf.Variable( tf.random_normal([1], mean=0.01,stddev=0.3) )   
    y = tf.nn.sigmoid( tf.matmul(y_4,W_5) + b_5 )
    print("完成输出层定义")
    
    # 损失函数定义（交叉熵代价函数），这里是对所有样本的交叉熵的平均
    #各种损失函数定义：https://blog.csdn.net/yanshuai_tek/article/details/78649632
    #为什么使用交叉熵损失函数的理由：https://blog.csdn.net/weixin_39750084/article/details/86029543
    cross_entropy = tf.reduce_mean( -tf.reduce_sum(y_*tf.log(y+pow(10,-9))+(1-y_)*(1-tf.log(1-y+pow(10,-9))), reduction_indices=[1] ) )  # reduce_sum内第一个参数为交叉熵公式
    
    # 训练/优化方法定义。神经网络常采用SGD(Stochastic Gradient Descent)进行网络的优化训练。tensorflow会自动根据前面定义的计算图先进行前向传播得到预测值，再根据预测值与真实值的求得的损失函数及计算图进行后向传播，依据梯度下降法更新参数。
    # tf.subtract计算两个张量相减，当然两个张量必须形状一样。 即 yhat - target。
#    yerror = tf.subtract(y, y_)
    # 计算L2损失，也就是方差。
#    cross_entropy = tf.nn.l2_loss(yerror)
    #这里的几个列表是为了存储损失函数和参数，方便观察神经网络损失函数的下降情况及权重变化情况，后面会做可视化操作
    loss_arr = []
    w1_arr = []
    w2_arr = []
    w3_arr = []
    #这里0.1是学习率，有多种优化方法可以选择，如Adam、Adadelta等
    train_step = tf.train.GradientDescentOptimizer(0.1).minimize(cross_entropy)
#    train_step = tf.train.AdamOptimizer(0.02).minimize(cross_entropy)
#    train_step = tf.train.AdadeltaOptimizer(1).minimize(cross_entropy)

    #===============================开始实际的神经网络训练过程======================
    # 3.定义会话，并通过global_variables_initializer初始化所有变量
    #启动会话，并通过sess.ruan(init_op)等方法初始化全局变量和局部变量，前面虽然定义了init_op，但没有实际执行初始化操作，一切操作都是在session才会真实执行的
    sess = tf.InteractiveSession()
    sess.run(init_op)
    sess.run(local_init_op)
    tf.global_variables_initializer().run()
    
    # 运行Graph，开始计算过程
    coord = tf.train.Coordinator()  #创建一个协调器，管理线程  
    threads = tf.train.start_queue_runners(coord=coord)  
    #打印一个batch的x和y看看，这里只会打印shape，因为tensor是TensorFlow中的数据结构，它print时只打印shape信息
    print(example_batch, label_batch)
    #训练200次
    for i in range(200):
#         print(example_batch, label_batch)
         e_val,l_val = sess.run([example_batch, label_batch])
         
         #只有sess.run这种方法能够打印输出variable，这在TensorFlow中叫feed，也就是在会话中给模型喂真实数据，模型才能输出数据
#         print('---',sess.run(W_1))
#         print('++++',sess.run(W_4))
#         print('---',sess.run(W_5))
#         print('---',sess.run(cross_entropy))
         #train_step.run需要的是特征和label都必须是一个样本一行，而这里的l_val是所有样本的label都在一个向量中，所以会有维度问题，需要转换一下，转换后的结果为y_true
         y_true = []
         for l in l_val:
             y_true.append([l])
#         print(y_true)
         train_step.run( {x:e_val, y_:y_true} )
         #记录本轮的损失函数值，这里的feed_dict就是你喂给模型的数据
         loss_arr.append(sess.run(cross_entropy,feed_dict={x:e_val, y_:y_true}))
         #记录权重，观察权重变量，其实用tensorboard更方便，之后会再写一篇这个的使用
         w1_arr.append(sess.run(W_1)[0,0])
         w2_arr.append(sess.run(W_2)[0,0])
         w3_arr.append(sess.run(W_3)[0,0])
         print('---------',i)
         print('w1',sess.run(W_1))
         print('w2',sess.run(W_2))
         print('w3',sess.run(W_3))
         print('本一轮训练的y预测值：',sess.run(y,feed_dict={x:e_val}))
         #自己写的一个early stopping，不是很好用，而且模型偏差大时更不建议使用
         if abs(sess.run(cross_entropy,feed_dict={x:e_val, y_:y_true}))<1:
             break
    print('最后一轮训练的样本特征：',e_val)
    print('最后一轮训练的y预测值：',sess.run(y,feed_dict={x:e_val}))
    print('最后一轮训练的y真实值：',l_val)
    #画出损失函数及权重的变化图
    plt.plot(range(len(loss_arr)),loss_arr)
    plt.plot(range(len(w1_arr)),w1_arr,'o-')
    plt.plot(range(len(w2_arr)),w2_arr,'*-')
    plt.plot(range(len(w3_arr)),w3_arr,'--')
    

#         train_step.run( {x:example_batch, y_:label_batch} )
#        print (e_val,l_val)  
    #训练结束后停止线程调度
    coord.request_stop()  
    coord.join(threads)
#    print(e_val,l_val) 
    
    
        
    
    #===================================评估模型，给出准确度和ks====================
    #correct_prediction会给出真实值和样本值经过阈值处理后相等的个数，比如阈值为0.5，那么大于0.5的就会被认为是1，小于0.5的就会是原值，真实值也做同样的处理，然后判断有多少值是相等的，其比例即为准确率
    correct_prediction = tf.equal( tf.argmax(y_true,1), tf.argmax(y_,1) )
    print(correct_prediction)
        #tf.equal( tf.argmax(y,1), tf.argmax(y_,1) )判断预测值和真实值是否相等，返回的是布尔型向量
        #布尔型数据构成的向量通过cast转换为浮点型，并求平均，以得到准确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32) )
    #    print(accuracy)
    print(accuracy.eval({x:e_val, y_:y_true} ))
    
    #把最后一轮训练的参数保存下来，方便计算模型ks
    pd.DataFrame(sess.run(W_1)).to_csv('D:/CDL_code/模型探索/dnn/w1.csv',index=False)
    pd.DataFrame(sess.run(W_2)).to_csv('D:/CDL_code/模型探索/dnn/w2.csv',index=False)
    pd.DataFrame(sess.run(W_3)).to_csv('D:/CDL_code/模型探索/dnn/w3.csv',index=False)
    pd.DataFrame(sess.run(W_4)).to_csv('D:/CDL_code/模型探索/dnn/w4.csv',index=False)
    pd.DataFrame(sess.run(W_5)).to_csv('D:/CDL_code/模型探索/dnn/w5.csv',index=False)
    pd.DataFrame(sess.run(b_1)).to_csv('D:/CDL_code/模型探索/dnn/b1.csv',index=False)
    pd.DataFrame(sess.run(b_2)).to_csv('D:/CDL_code/模型探索/dnn/b2.csv',index=False)
    pd.DataFrame(sess.run(b_3)).to_csv('D:/CDL_code/模型探索/dnn/b3.csv',index=False)
    pd.DataFrame(sess.run(b_4)).to_csv('D:/CDL_code/模型探索/dnn/b4.csv',index=False)
    pd.DataFrame(sess.run(b_5)).to_csv('D:/CDL_code/模型探索/dnn/b5.csv',index=False)
    
    return e_val,y_true

''' 
本来想用这一段来用已输出的参数跑模型的，但现在看来是不行了，所以只能尝试把参数保存下来，然后再跑新的全量数据   
#    print('---',sess.run(W_1))
#    print('++++',sess.run(W_4))
#    print('---',sess.run(W_5))
    sess = tf.InteractiveSession()
    sess.run(init_op)
    sess.run(local_init_op)
    tf.global_variables_initializer().run()
    example_batch, label_batch = tf.train.shuffle_batch([features,label], batch_size=100, capacity=200, min_after_dequeue=100, num_threads=3)
    print(example_batch, label_batch)
    for i in range(1):
        print(i)
        e_val,l_val = sess.run([example_batch, label_batch])
        print(e_val,l_val)
#        y_1 = tf.nn.relu( tf.matmul(e_val,W_1) + b_1 )
#        y_4 = tf.nn.relu( tf.matmul(y_1,W_4) + b_4 )
#        y = tf.nn.sigmoid( tf.matmul(y_4,W_5) + b_5 )
#    sess.run(y)
#    print(sess.run(y))
'''

#计算模型的ks，这里的ks计算方法是自己不是用的TensorFlow封装的方法，所以需要先把权重读出来，然后把前向传播的过程写出来，再计算ks
def read_para_ks(e_val,y_true):
    w1 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/w1.csv')))
    w2 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/w2.csv')))
    w3 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/w3.csv')))
    w4 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/w4.csv')))
    w5 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/w5.csv')))
    b1 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/b1.csv')))
#    print(len(w1[0]),len(b1))
    b2 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/b2.csv')))
    b3 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/b3.csv')))
    b4 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/b4.csv')))
    b5 = np.mat(pd.read_csv(open('D:/CDL_code/模型探索/dnn/b5.csv')))
    
    #不需要看ks和roc结果的时候，可以不用下面的代码了
    #如果是要检查前向传播过程写得是否正确，我们需要使用最后一个batch的数据来验证，因此这里需要先判断是否有读取最后一个batch的数据，如果不需要检查正确性了，直接跑全量数据，那就直接读取csv文件中的数据即可
    if len(e_val)>0:
        x = e_val
    else:
        df = pd.read_csv('D:/CDL_code/sample_y60all_data_sf_xs_app_20180816_filter_drophead.csv')
        x = np.mat(df.iloc[:,0:-1])
        
    if len(y_true)>0:
        y_ = y_true
    else:
        y_ = np.mat(df.iloc[:,-1]).tolist()[0]
#    print(np.mat(df.iloc[:,-1]))
#    '''
   #开始前向传播过程，我写得有些繁琐
   #第一层
    y1 = x*w1
#    print(y1.shape[0]-1,y1.shape[1])
    for i in range(y1.shape[0]):
#        print(i,b1[i,0])
        for j in range(y1.shape[1]):
#            pass
            y1[i,j] = elu(y1[i,j]+b1[j,0])
    print('y1:',y1)
    #第2层
    y2 = y1*w2
#    print(y1.shape[0]-1,y1.shape[1])
    for i in range(y2.shape[0]):
#        print(i,b1[i,0])
        for j in range(y2.shape[1]):
#            pass
            y2[i,j] = elu(y2[i,j]+b2[j,0])
    print('y2:',y2)
    #第3层
    y3 = y2*w3
#    print(y1.shape[0]-1,y1.shape[1])
    for i in range(y3.shape[0]):
#        print(i,b1[i,0])
        for j in range(y3.shape[1]):
#            pass
            y3[i,j] = elu(y3[i,j]+b3[j,0])
    print('y3:',y3)
    #第四层
    y4 = y3*w4
#    print(y1.shape[0]-1,y1.shape[1])
    for i in range(y4.shape[0]):
#        print(i,b1[i,0])
        for j in range(y4.shape[1]):
#            pass
            y4[i,j] = elu(y4[i,j]+b4[j,0])
    print('y4:',y4)
    #输出层
    y5 = y4*w5
#    print(y1.shape[0]-1,y1.shape[1])
    for i in range(y5.shape[0]):
#        print(i,b1[i,0])
        for j in range(y5.shape[1]):
#            pass
            y5[i,j] = sigmoid(y5[i,j]+b5[j,0])
#            y5[i,j] = leaky_relu(0.2,y5[i,j]+b5[j,0])
   
#    print(np.mat(df.iloc[:,-1]).T.tolist())
#    print(len(np.mat(df.iloc[:,-1]).T.tolist()[0]),len(y3.T.tolist()[0]))
    print('最后一轮训练的y我计算的预测值：',y5)
    print('最后一轮训练的y我计算的真实值：',y_[0:3])
    pd.DataFrame(y5,columns=['y_pred']).join(pd.DataFrame(y_,columns=['y_true'])).to_csv('D:/CDL_code/模型探索/dnn/y_pred.csv')
    #调用sklearn中的接口查看roc值，这里的ks值是调用的自己写的接口画的，ks实现很简单，这里就不放出代码了，但记得自己要把自己写的ks计算函数引入进来，否则当然是要报错的
#    t_fpr, t_tpr, _ = metrics.roc_curve(np.mat(df.iloc[:,-1]).tolist()[0], y4.T.tolist()[0])
#    md.roc_curve([(np.mat(df.iloc[:,-1]).tolist()[0], y4.T.tolist()[0],'train'),])
    t_fpr, t_tpr, _ = metrics.roc_curve(y_, y5.T.tolist()[0])
    md.roc_curve([(y_, y5.T.tolist()[0],'train'),])
    md.ks_plot('train',t_tpr,t_fpr)
#    '''
#    print(np.mat(df.iloc[:,-1]).tolist()[0])
                    
    
 #这里算主函数？哈哈
def dnn():
    e_val,y_true = read_csv_dnn_notcontrib()
    e_val,y_true = [],[]
    read_para_ks(e_val,y_true)
    
#执行函数
dnn()

三、读取csv并建立深度神经网络方法二

最开始看到这个用tf.contrib方法实现读取csv文件并训练神经网络的方法时，真的是很激动了，马上用自己的数据实现了一下，但是觉得有几个缺点吧：
1） 这个方法必须先手动把训练集和测试集分开，没有方法一方便；
2） tf.contrib官网上的说法是后续可能就不维护了，所以还是熟练一下tf.nn模块比较好；
3） 使用这种方法的网络定义过程要简单很多，也没有占位符、变量这些不是那么好理解的数据结构概念，但是也缺失了灵活性，比如不能每层定义不同的激活函数，使用方法一就不会有这个问题了。

总之呢，刚开始学或者只是想简单跑一下神经网络，用方法二即可，但要是想深入学习一下，还是方法一更靠谱些。

#========================================读取csv文件并建模=================================
def read_csv_dnn():
    import tensorflow as tf
    import numpy as np
    import pandas as pd
    from sklearn import metrics
    import risk_model_function as md
    
    # 数据集名称，数据集要放在你的工作目录下，训练集和测试集分开读取
    IRIS_TRAINING = 'D:/CDL_code/sample_y60_irt_data_sf_xs_app_20180816_train.csv'
    IRIS_TEST = 'D:/CDL_code/sample_y60_irt_data_sf_xs_app_20180816_test.csv'
#    print(pd.read_csv(IRIS_TRAINING))
    
    # 数据集读取，训练集和测试集
    training_set = tf.contrib.learn.datasets.base.load_csv_without_header(
        filename=IRIS_TRAINING,
        target_dtype=np.int,
        features_dtype=np.float32)
    
    test_set = tf.contrib.learn.datasets.base.load_csv_without_header(
        filename=IRIS_TEST,
        target_dtype=np.int,
        features_dtype=np.float32)
    
    # 特征
    feature_columns = [tf.contrib.layers.real_valued_column("", dimension=714)]
    
    # 构建DNN网络，3层，每层分别为10,20,10个节点
    classifier = tf.contrib.learn.DNNRegressor(feature_columns=feature_columns,
                                                hidden_units=[200, 500, 300],
#                                                n_classes=2,
#                                                activation_fn=[tf.nn.relu,tf.nn.relu,tf.nn.sigmoid])
                                                activation_fn=tf.nn.sigmoid)
                                                #model_dir="/tmp/iris_model")
    
    # 拟合模型，迭代200步
    classifier.fit(x=training_set.data,
                   y=training_set.target,
                   steps=200)
    
    #DNNRegressor没有精度，只有DNNClassifier才有
    # 计算精度
#    accuracy_score = classifier.evaluate(x=test_set.data,y=test_set.target)["accuracy"]
    accuracy_score = classifier.evaluate(x=test_set.data,y=test_set.target)
    print(accuracy_score)
#    print('Accuracy: {0:f}'.format(accuracy_score))
    
    # 预测新样本的类别
#    new_samples = np.array([[6.4, 3.2, 4.5, 1.5], [5.8, 3.1, 5.0, 1.7]], dtype=float)
    new_samples = training_set.data
    y = list(classifier.predict(new_samples, as_iterable=True))
    
    #计算二分类训练集的roc和ks，
    t_fpr, t_tpr, _ = metrics.roc_curve(training_set.target, y)
    md.roc_curve([(training_set.target, y,'train'),])
    md.ks_plot('train',t_tpr,t_fpr)
    #计算测试集的roc和ks
    new_samples = test_set.data
    y = list(classifier.predict(new_samples, as_iterable=True))
    t_fpr, t_tpr, _ = metrics.roc_curve(test_set.target, y)
    md.roc_curve([(test_set.target, y,'train'),])
    md.ks_plot('train',t_tpr,t_fpr)
#    print(len(test_set.target))
#    print(len(y))
#    print('Predictions: {}'.format(str(y)))

read_csv_dnn()

四、参考资料

1、 https://blog.csdn.net/xxzhangx/article/details/54667234 ；
2、 https://blog.csdn.net/xxzhangx/article/details/54667234
3、 https://blog.csdn.net/zhangchao19890805/article/details/81332240
4、 https://www.jianshu.com/p/c4158fb99959