DNN网络（三）python下用Tensorflow实现DNN网络以及Adagrad优化器

一、DNN 简介

DNN一共可以分为三层。

• 输入层（input layer）
• 隐藏层（hidden layer）
• 输出层（output layer）

DNN的前向传播即由输入经过一些列激活函数得到最终的输出

在对DNN参数求解的时候，通过反向传播，以及链式法则求得。

二、Tensorflow下的DNN实现

1、实现功能简介：

本文摘自Kaggle的一篇房价预测题目，找了一篇比较全的，当作自己的Tensorflow入门。链接：

https://www.kaggle.com/zoupet/neural-network-model-for-house-prices-tensorflow

数据和题目可以在文章开头的地址找的。

主要是给定了一个区域的房子价格以及房子特征，要预测一下房价。

2、挑选数据

 # 为了使得代码在 python2 或者3下都运行，加的 __future__包。如果是python3，下面的包可以不加。

 from __future__ import absolute_import

 from __future__ import division

 from __future__ import print_function

 import itertools

 import pandas as pd

 import numpy as np

 import matplotlib.pyplot as plt

 from pylab import rcParams

 import matplotlib

 from sklearn.model_selection import train_test_split

 # scaler, put the value range from min to max

 from sklearn.preprocessing import MinMaxScaler

 import tensorflow as tf

 # 定义多少条记录会被当作log。

 tf.logging.set_verbosity(tf.logging.INFO)

 # InteractiveSession 与 Session的区别是不用每一次执行命令时，前面都加一个session。可以自己查一下

 sess = tf.InteractiveSession()

 # 文件目录

 path_train = '/Users/adrian.wu/Desktop/learn/kaggle/price/data/all/train.csv'

 '''

 首先只用数字特征进行预测，去除掉其它特征，比如类别等

 '''

 train = pd.read_csv(path_train)

 print('所有特征下，矩阵纬度:', train.shape)

 # 挑选出只是数字类型的特征

 train = train.select_dtypes(exclude=['object'])

 print('数字类型特征矩阵的纬度:', train.shape)

 # 去掉没用的特征Id

 train.drop('Id', axis=1, inplace=True)

 # 处理缺失值，简单的填充0

 train.fillna(0, inplace=True)

 print("\n特征:", list(train.columns))

 '''

 用Isolation Forest去掉异常值

 '''

 from sklearn.ensemble import IsolationForest

 clf = IsolationForest(max_samples=100, random_state=42)

 clf.fit(train)

 y_noano = clf.predict(train)

 print(y_noano)

 y_noano = pd.DataFrame(y_noano, columns=['Top'])

 # y_noano[y_noano['Top'] == 1].index.values, 等于1的不是异常值，-1为异常值

 train = train.iloc[y_noano[y_noano['Top'] == 1].index.values]

 train.reset_index(drop=True, inplace=True)

 print("异常值数量:", y_noano[y_noano['Top'] == -1].shape[0])

 print("正常数据数量:", train.shape[0])

3、特征预处理

 '''

 特征预处理

 '''

 import warnings

 warnings.filterwarnings('ignore')

 # 得到特征名字，并存为list类型

 col_train = list(train.columns)

 col_train_bis = list(train.columns)

 # 去除要预测的值，SalePrice

 col_train_bis.remove('SalePrice')

 # 用numpy转为可操作的矩阵

 mat_train = np.mat(train)

 mat_y = np.array(train.SalePrice).reshape((1314, 1))

 # 归一化方法，把所有特征归一化到0～1之间

 prepro_y = MinMaxScaler()

 prepro_y.fit(mat_y)

 prepro = MinMaxScaler()

 prepro.fit(mat_train)

 # 将处理过后的数据转为DataFrame

 train = pd.DataFrame(prepro.transform(mat_train), columns=col_train)

4、train test数据集合处理

 '''

 train test集合数据处理

 '''

 # 把列都列出来

 COLUMNS = col_train

 FEATURES = col_train_bis

 LABEL = "SalePrice"

 # 暂且理解将DataFrame的数据转为对应的输入值，因此要指定一列列的值。

 feature_cols = [tf.contrib.layers.real_valued_column(k) for k in FEATURES]

 # 得到Feature 和 预测值

 training_set = train[COLUMNS]

 prediction_set = train.SalePrice

 # 将Train test 分为2:1分

 x_train, x_test, y_train, y_test = train_test_split(training_set[FEATURES], prediction_set, test_size=0.33,

                                                     random_state=42)

 # 整合特征和预测值，对train集

 y_train = pd.DataFrame(y_train, columns=[LABEL])

 training_set = pd.DataFrame(x_train, columns=FEATURES).merge(y_train, left_index=True, right_index=True)

 # 整合特征和预测值，对test集

 y_test = pd.DataFrame(y_test, columns=[LABEL])

 testing_set = pd.DataFrame(x_test, columns=FEATURES).merge(y_test, left_index=True, right_index=True)

 # 打log的，可以忽略

 tf.logging.set_verbosity(tf.logging.ERROR)

5、DNN网络

 '''

  快速创建一个DNN网络,

  optimizer = tf.train.GradientDescentOptimizer( learning_rate= 0.1 )) 可以自己选优化方式

  激活函数为relu

  都有哪些feature

  隐藏层的神经元个数，递减，200，100，50，25，12个

 '''

 regressor = tf.contrib.learn.DNNRegressor(feature_columns=feature_cols,

                                           activation_fn=tf.nn.relu,

                                           hidden_units=[200, 100, 50, 25, 12])

 training_set.reset_index(drop=True, inplace=True)

 # 定义一个函数用来train网络

 def input_fn(data_set, pred=False):

     if pred == False:

         feature_cols = {k: tf.constant(data_set[k].values) for k in FEATURES}

         labels = tf.constant(data_set[LABEL].values)

         return feature_cols, labels

     if pred == True:

         feature_cols = {k: tf.constant(data_set[k].values) for k in FEATURES}

         return feature_cols

 # trainDNN网络

 regressor.fit(input_fn=lambda: input_fn(training_set), steps=2000)

 # 估计测试集

 ev = regressor.evaluate(input_fn=lambda: input_fn(testing_set), steps=1)

 loss_score = ev["loss"]

 print("test集的损失为: {0:f}".format(loss_score))

6、Adagrad优化器

看了下代码。这里的优化器用的是Adagrad。形式大致和SGD差不多，在其基础通过对梯度的迭代相加，对学习率进行了更新，从而控制学习率。

学习率随着梯度的和会逐渐变小。

1、迭代公式

eta也就是分子项是初始学习率。G为梯度迭代和，G旁边长的很像E的那一项是一个小常数，防止分母为0。

由上式可得到，G越大，学习率越小。

三、Tensorflow一步一步搭建一个简单DNN

1、创建网络

 import tensorflow as tf

 from numpy.random import RandomState

 from sklearn.model_selection import train_test_split

 batch_size = 8

 # 定义网络

 w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))

 b1 = tf.Variable(tf.zeros([1, 3], name="bias1"))

 b2 = tf.Variable(tf.zeros([1], name="bias2"))

 w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))

 x = tf.placeholder(tf.float32, shape=(None, 2), name='x-input')

 y_ = tf.placeholder(tf.float32, shape=(None, 1), name='y-input')

 a = tf.matmul(x, w1) + b1

 # 这里一定不要写成 tf.sigmoid

 y_last = tf.nn.sigmoid(tf.matmul(a, w2) + b2)

2、定义损失函数

 # 损失与准确率

 loss = tf.losses.sigmoid_cross_entropy(y_, y_last)

 train_step = tf.train.AdamOptimizer(0.07).minimize(loss)

 correct_prediction = tf.equal(tf.round(y_last), y_)

 acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

3、造数据

# 造数据，X为二维数据例如：[[0.1, 0.8]]， 当X的第一项和第二项相加 < 1 时 Y为1， 当X的第一项和第二项相加 >= 1时为 0

rdm = RandomState(1)

data_set_size = 128000

X = rdm.rand(data_set_size, 2)

Y = [[int(x1 + x2 < 1)] for (x1, x2) in X]

X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.3)

4、训练与测试

with tf.Session() as sess:

    init_op = tf.global_variables_initializer()

    sess.run(init_op)

    STEPS = 7000

    for i in range(0, 8900 - batch_size, batch_size):

        start = i

        sess.run(train_step, feed_dict={x: X_train[start: start + batch_size], y_: y_train[start: start + batch_size]})

        if i % 800 == 0:

            # 计算所有数据的交叉熵

            total_cross_entropy = sess.run(loss, feed_dict={x: X, y_: Y})

            # 输出交叉熵之和

            # print("After %d training step(s),cross entropy on all data is %g" % (i, total_cross_entropy))

    acc_ = sess.run(acc, feed_dict={x: X_test, y_: y_test})

    print("accuracy on test data is ", acc_)

    test = sess.run(y_last, feed_dict={x: X_test, y_: y_test})

5、结果

accuracy on test data is  0.96091145