DNN/1. DNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regression\n",
    "\n",
    "## 数据读取与处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_boston\n",
    "\n",
    "data = load_boston()\n",
    "X = data.data\n",
    "Y = data.target.reshape((-1,1))\n",
    "\n",
    "scaler=StandardScaler()\n",
    "X_sca=scaler.fit_transform(X)\n",
    "\n",
    "X_train,X_val,Y_train,Y_val=train_test_split(X_sca,Y,test_size=0.15)\n",
    "\n",
    "print(X_train.shape, Y_train.shape,X_val.shape,Y_val.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网络结构设计"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 神经网络编程有一点与SKlearn不一样，就是需要提前设计好网络的结构，每一层的参数都跟其输入有关\n",
    "# 输入层单元数为13(数据特征)，设计隐藏层单元数为5，输出单元数为1(回归任务)\n",
    "\n",
    "unit_I = X_train.shape[1]    # 输入层的单元数，与特征数相等\n",
    "unit_h1 = 5    # 第一层隐藏层的单元数\n",
    "unit_h2 = 3\n",
    "unit_O = 1    # 输出层单元数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 搭建网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 为了便于添加层数，将其封装起来\n",
    "\n",
    "\n",
    "def add_layer(inputs, units_I, units_O, act_func=None, layer_name=None):\n",
    "    '''\n",
    "    inputs: 当前层的输入\n",
    "    units_I: 当前层的单元数，即输入数据的列数\n",
    "    units_O: 后一层的单元数，即输出数据的列数\n",
    "    '''\n",
    "    w = tf.Variable(tf.random_normal(shape=[units_I, units_O]))\n",
    "    b = tf.Variable(tf.random_normal(shape=[units_O]))\n",
    "    z=tf.add(tf.matmul(inputs, w), b)\n",
    "\n",
    "    if act_func:\n",
    "        out = act_func(z)    # 激活\n",
    "    else:\n",
    "        out = z\n",
    "\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 输入必须是可由用户指定的，所以设为placeholder\n",
    "X = tf.placeholder(tf.float32, shape=[None, unit_I])    # 数据的样本数不指定，只指定特征数\n",
    "Y = tf.placeholder(tf.float32, shape=[None, 1])    # 目标值为列向量\n",
    "\n",
    "# 网络结构子图\n",
    "with tf.name_scope('DNN'):\n",
    "    a1 = add_layer(X, unit_I, unit_h1, act_func=tf.nn.relu)\n",
    "    a2 = add_layer(a1, unit_h1, unit_h2, act_func=tf.nn.relu)\n",
    "    Y_pred = add_layer(a2, unit_h2, unit_O)\n",
    "\n",
    "# 损失函数子图\n",
    "with tf.name_scope('Loss'):\n",
    "    MSE = tf.losses.mean_squared_error(Y, Y_pred)\n",
    "\n",
    "# optimization子图\n",
    "lr = 0.01    # 学习率\n",
    "with tf.name_scope('Train'):\n",
    "    opt = tf.train.AdamOptimizer(lr).minimize(MSE)    # Adam优化器\n",
    "\n",
    "init = tf.global_variables_initializer()    # 所有变量初始化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算图已经构建好，开启一个tf会话，需要计算哪个值就run哪个变量即可\n",
    "with tf.Session() as sess:\n",
    "    sess.run(init)\n",
    "    train_iter = 1000\n",
    "\n",
    "    for i in range(train_iter):\n",
    "        sess.run(opt, feed_dict={X: X_train, Y: Y_train})\n",
    "        if i % 100 == 0:\n",
    "            mse_train = sess.run(MSE, feed_dict={X: X_train, Y: Y_train})\n",
    "            print('train_iter: {}\\tMSE:{}'.format(i, mse_train))\n",
    "\n",
    "    mse_val = sess.run(MSE, feed_dict={X: X_val, Y: Y_val})\n",
    "\n",
    "# 另一种计算mse_val方式，因为tf计算出来的pred是一个二维数组，需要squeeze一下\n",
    "#     pred = np.squeeze(sess.run(Y_pred, feed_dict={X: X_val}))\n",
    "#     mse_val=np.sum(np.square(np.squeeze(pred)-Y_val))/len(Y_val)\n",
    "\n",
    "    print('test_MSE: {}'.format(mse_val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binary classification\n",
    "## 数据读取与处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_breast_cancer\n",
    "\n",
    "data = load_breast_cancer()\n",
    "X = data.data\n",
    "Y = data.target.reshape((-1,1))\n",
    "\n",
    "scaler=StandardScaler()\n",
    "X_sca=scaler.fit_transform(X)\n",
    "\n",
    "X_train,X_val,Y_train,Y_val=train_test_split(X_sca,Y,test_size=0.15)\n",
    "\n",
    "print(X_train.shape, Y_train.shape,X_val.shape,Y_val.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网络结构设计"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 输入层单元数为30数据特征)，设计隐藏层单元数为5，输出单元数为1(二分类任务)\n",
    "\n",
    "unit_I = X_train.shape[1]    # 输入层的单元数，与特征数相等\n",
    "unit_h1 = 5    # 第一层隐藏层的单元数\n",
    "unit_h2 = 3\n",
    "unit_O = 1    # 输出层单元数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 搭建网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 输入必须是可由用户指定的，所以设为placeholder\n",
    "X = tf.placeholder(tf.float32, shape=[None, unit_I])    # 数据的样本数不指定，只指定特征数\n",
    "Y = tf.placeholder(tf.float32, shape=[None, 1])    # 目标值为列向量\n",
    "\n",
    "# 网络结构子图\n",
    "with tf.name_scope('DNN'):\n",
    "    a1 = add_layer(X, unit_I, unit_h1, act_func=tf.nn.relu)\n",
    "    a2 = add_layer(a1, unit_h1, unit_h2, act_func=tf.nn.relu)\n",
    "    Y_pred = add_layer(a2, unit_h2, unit_O, act_func=tf.nn.sigmoid)\n",
    "\n",
    "# 损失函数子图\n",
    "with tf.name_scope('Loss'):\n",
    "    log_loss = tf.losses.log_loss(Y, Y_pred)\n",
    "\n",
    "# optimization子图\n",
    "lr = 0.01    # 学习率\n",
    "with tf.name_scope('Train'):\n",
    "    opt = tf.train.AdamOptimizer(lr).minimize(log_loss)    # Adam优化器\n",
    "\n",
    "init = tf.global_variables_initializer()    # 所有变量初始化\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True    # 按需使用显存"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算图已经构建好，开启一个tf会话，需要计算哪个值就run哪个变量即可\n",
    "with tf.Session(config=config) as sess:\n",
    "    sess.run(init)\n",
    "    train_iter = 1000\n",
    "\n",
    "    for i in range(train_iter):\n",
    "        sess.run(opt, feed_dict={X: X_train, Y: Y_train})\n",
    "        if i % 100 == 0:\n",
    "            loss_train = sess.run(log_loss, feed_dict={X: X_train, Y: Y_train})\n",
    "            print('train_iter: {}\\tlog_loss:{}'.format(i, loss_train))\n",
    "\n",
    "    loss_val = sess.run(log_loss, feed_dict={X: X_val, Y: Y_val})\n",
    "    pred=np.squeeze(sess.run(Y_pred, feed_dict={X: X_val}))\n",
    "    pred=np.where(pred>=0.5,1,0)\n",
    "    \n",
    "    print('test_log_loss: {}\\tacc:{}'.format(loss_val,np.sum(pred==np.squeeze(Y_val))/len(Y_val)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi classification\n",
    "\n",
    "## 数据读取与处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1527, 64) (1527, 1) (270, 64) (270, 1)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_digits\n",
    "\n",
    "data = load_digits()\n",
    "X = data.data\n",
    "Y = data.target.reshape((-1,1))\n",
    "\n",
    "scaler=StandardScaler()\n",
    "X_sca=scaler.fit_transform(X)\n",
    "\n",
    "X_train,X_val,Y_train,Y_val=train_test_split(X_sca,Y,test_size=0.15)\n",
    "\n",
    "print(X_train.shape, Y_train.shape,X_val.shape,Y_val.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网络结构设计"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 输入层单元数为64(数据特征)，设计隐藏层单元数为5，输出单元数为10(多分类任务)\n",
    "\n",
    "unit_I = X_train.shape[1]    # 输入层的单元数，与特征数相等\n",
    "unit_h1 = 5    # 第一层隐藏层的单元数\n",
    "unit_h2 = 3\n",
    "unit_O = 10    # 输出层单元数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 搭建网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 输入必须是可由用户指定的，所以设为placeholder\n",
    "X = tf.placeholder(tf.float32, shape=[None, unit_I])    # 数据的样本数不指定，只指定特征数\n",
    "Y = tf.placeholder(tf.int32, shape=[None, 1])    # 目标值为列向量\n",
    "\n",
    "# 网络结构子图\n",
    "with tf.name_scope('DNN'):\n",
    "    a1 = add_layer(X, unit_I, unit_h1, act_func=tf.nn.relu)\n",
    "    a2 = add_layer(a1, unit_h1, unit_h2, act_func=tf.nn.relu)\n",
    "    Y_pred = add_layer(a2, unit_h2, unit_O, act_func=tf.nn.softmax)\n",
    "\n",
    "# 损失函数子图\n",
    "with tf.name_scope('Loss'):\n",
    "    # 计算一维向量与onehot向量之间的损失\n",
    "    cross_entropy = tf.losses.sparse_softmax_cross_entropy(labels=Y, logits=Y_pred)\n",
    "\n",
    "# optimization子图\n",
    "lr = 0.01    # 学习率\n",
    "with tf.name_scope('Train'):\n",
    "    opt = tf.train.AdamOptimizer(lr).minimize(cross_entropy)    # Adam优化器\n",
    "\n",
    "init = tf.global_variables_initializer()    # 所有变量初始化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_iter: 0\tlog_loss:2.3281965255737305\n",
      "train_iter: 100\tlog_loss:1.9704219102859497\n",
      "train_iter: 200\tlog_loss:1.7735627889633179\n",
      "train_iter: 300\tlog_loss:1.7169830799102783\n",
      "train_iter: 400\tlog_loss:1.6748764514923096\n",
      "train_iter: 500\tlog_loss:1.663661003112793\n",
      "train_iter: 600\tlog_loss:1.656128168106079\n",
      "train_iter: 700\tlog_loss:1.6525875329971313\n",
      "train_iter: 800\tlog_loss:1.635619044303894\n",
      "train_iter: 900\tlog_loss:1.6313313245773315\n",
      "test_log_loss: 1.6515076160430908\tacc:0.8148148148148148\n"
     ]
    }
   ],
   "source": [
    "# 计算图已经构建好，开启一个tf会话，需要计算哪个值就run哪个变量即可\n",
    "with tf.Session() as sess:\n",
    "    sess.run(init)\n",
    "    train_iter = 1000\n",
    "\n",
    "    for i in range(train_iter):\n",
    "        sess.run(opt, feed_dict={X: X_train, Y: Y_train})\n",
    "        if i % 100 == 0:\n",
    "            loss_train = sess.run(cross_entropy, feed_dict={\n",
    "                                  X: X_train, Y: Y_train})\n",
    "            print('train_iter: {}\\tlog_loss:{}'.format(i, loss_train))\n",
    "\n",
    "    pred = sess.run(Y_pred, feed_dict={X: X_val, Y: Y_val})\n",
    "    loss_val = sess.run(cross_entropy, feed_dict={X: X_val, Y: Y_val})\n",
    "    acc = np.sum(np.squeeze(Y_val) == np.argmax(pred, axis=1))/len(Y_val)\n",
    "\n",
    "    print('test_log_loss: {}\\tacc:{}'.format(loss_val, acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}