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("
特征:", 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