第15章 多层感知机与DNN算法.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TensorFlow是谷歌研发的第二代人工智能学习系统，其命名来源于本身的运行原理。Tensor也叫张量，即所谓的N维数组；Flow也叫流，即所谓基于数据流图的计算；TensorFlow为张量从流图的一端流动到另一端的计算过程。TensorFlow将复杂的数据结构传输至人工智能神经网中进行分析和处理。\n",
    "\n",
    "把算法表示成一个个操作的叠加，可以非常清晰地看到数据之间的关系，而且这样的基本操作也具有普遍性。在TensorFlow中，当数据流过操作节点的时候就可以对数据进行操作。一个操作可以有零个或多个输入，产生零个或多个输出。一个操作可能是一次数学计算，一个变量或常量，一个数据流走向控制，一次文件IO或者是一次网络通信。其中，一个常量可以看成没有输入、只有一个固定输出的操作。\n",
    "\n",
    "在计算图中，每个边就代表数据从一个操作流到另一个操作。这些数据被表示为张量，一个张量可以看成多维的数组或者高维的矩阵。关于TensorFlow中的张量，需要注意的是张量本身并没有保存任何值，张量仅仅提供了访问数值的一个接口，可以看成数值的一种引用。在TensorFlow实际使用中我们也可以发现，在run之前的张量并没有分配空间，此时的张量仅仅表示了一种数值的抽象，用来连接不同的节点，表示数据在不同操作之间的流动。(相当于只是先分配了一个名额，等实际用到时，才会给你实际赋值)\n",
    "\n",
    "变量是计算图中可以改变的节点。比如当计算权重的时候，随着迭代的进行，每次权重的值会发生相应的变化，这样的值就可以当作变量。在实际处理时，一般把需要训练的值指定为变量。在使用变量的时候，需要指定变量的初始值，变量的大小和数据类型就是根据初始值来推断的。\n",
    "\n",
    "在TensorFlow中，所有操作都必须在会话（session）中执行，会话负责分配和管理各种资源。在会话中提供了一个run方法，可以用它来执行计算图整体或者其中的一部分节点。在执行run方法时，还需要用feed_dict把相关数据输入到计算图。当run被调用时，TensorFlow将会从指定的输出节点开始，向前查找所有的依赖节点，所有依赖节点都将被执行。这些操作随后将被分配到物理执行单元上（比如CPU或GPU），这种分配规则由TensorFlow中的分配算法决定。（实际是为每个会话分配了独立的内存空间）\n",
    "\n",
    "TensorFlow与Scikit-Learn的区别除了支撑的算法不一样，还有一个重要的区别——TensorFlow天生支持分布式和异构计算环境，从单机到集群，从CPU到GPU都支持良好。\n",
    "\n",
    "TensorFlow也支持分布式架构，从MAC本到CPU服务器、GPU服务器、GPU集群甚至是神秘的TPU集群都支持。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:02.150548Z",
     "start_time": "2018-11-11T11:42:56.368876Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.datasets import mnist\n",
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:02.165448Z",
     "start_time": "2018-11-11T11:43:02.158060Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_onehot(y, size=10):\n",
    "    y_hot = []\n",
    "    y_ = []\n",
    "    for i in y:\n",
    "        y_ = [0] * size\n",
    "        y_[i-1] = 1\n",
    "        y_hot.append(y_)\n",
    "        y_ = []\n",
    "    return np.array(y_hot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:03.517225Z",
     "start_time": "2018-11-11T11:43:02.169061Z"
    }
   },
   "outputs": [],
   "source": [
    "mnist_train, mnist_test = mnist.load_data()\n",
    "X_train = mnist_train[0].reshape(mnist_train[0].shape[0], mnist_train[0].shape[1] * mnist_train[0].shape[2]) / 255.0\n",
    "y_train = get_onehot(mnist_train[1])\n",
    "X_test = mnist_test[0].reshape(mnist_test[0].shape[0], mnist_test[0].shape[1] * mnist_test[0].shape[2]) / 255.0\n",
    "y_test = get_onehot(mnist_test[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:03.554999Z",
     "start_time": "2018-11-11T11:43:03.520245Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义输入和输出，使用函数placeholder占位\n",
    "\n",
    "X = tf.placeholder(\"float\", [None, 784])\n",
    "y_ = tf.placeholder(\"float\", [None, 10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:03.579647Z",
     "start_time": "2018-11-11T11:43:03.557709Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义初始化权重矩阵和截距\n",
    "\n",
    "W = tf.Variable(tf.ones([784, 10]))\n",
    "b = tf.Variable(tf.ones([10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:03.591852Z",
     "start_time": "2018-11-11T11:43:03.582476Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义预测函数，y是预测值，y_是真实值\n",
    "\n",
    "y = tf.nn.softmax(tf.matmul(X, W) + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:03.654273Z",
     "start_time": "2018-11-11T11:43:03.595633Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义损失函数和优化算法\n",
    "\n",
    "cross_entropy = -tf.reduce_sum(y_ * tf.log(y))\n",
    "train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:03.702210Z",
     "start_time": "2018-11-11T11:43:03.664870Z"
    }
   },
   "outputs": [],
   "source": [
    "# 初始化变量并定义会话，每个会话都独立\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "sess = tf.Session()\n",
    "sess.run(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:03.716521Z",
     "start_time": "2018-11-11T11:43:03.712195Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义batchsize，使用小批量随机梯度进行优化迭代，理想情况，应使用所有全量数据一次性计算梯度，但数据量超大情况下，计算量显而易见\n",
    "\n",
    "batchsize = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:05.434403Z",
     "start_time": "2018-11-11T11:43:03.720396Z"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(0, len(X_train), batchsize):\n",
    "    batch_xs = X_train[i:(i+batchsize)]\n",
    "    batch_ys = y_train[i:(i+batchsize)]\n",
    "    # 迭代计算损失\n",
    "    sess.run(train_step, feed_dict={X:batch_xs, y_:batch_ys})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:05.621162Z",
     "start_time": "2018-11-11T11:43:05.446921Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.897\n"
     ]
    }
   ],
   "source": [
    "# 验证正确率\n",
    "\n",
    "correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # 转换数据类型\n",
    "# 计算准确率\n",
    "print(sess.run(accuracy, feed_dict={X: X_test, y_: y_test}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:05.633333Z",
     "start_time": "2018-11-11T11:43:05.624425Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义输入，输出和dropout\n",
    "\n",
    "X = tf.placeholder(\"float\", [None, 784])\n",
    "y_ = tf.placeholder(\"float\", [None, 10])\n",
    "keep_prob = tf.placeholder(tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:05.670652Z",
     "start_time": "2018-11-11T11:43:05.636057Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义权重，截距和隐层\n",
    "\n",
    "in_units = 784\n",
    "h1_units = 300\n",
    "\n",
    "W1 = tf.Variable(tf.truncated_normal([in_units, h1_units], stddev=0.1))\n",
    "b1 = tf.Variable(tf.zeros([h1_units]))\n",
    "W2 = tf.Variable(tf.zeros([h1_units, 10]))\n",
    "b2 = tf.Variable(tf.zeros([10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:05.693757Z",
     "start_time": "2018-11-11T11:43:05.674473Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义激活函数、dropout和预测函数\n",
    "\n",
    "hidden1 = tf.nn.relu(tf.matmul(X, W1) + b1)\n",
    "hidden1_drop = tf.nn.dropout(hidden1, keep_prob)\n",
    "y = tf.nn.softmax(tf.matmul(hidden1_drop, W2) + b2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:05.845553Z",
     "start_time": "2018-11-11T11:43:05.696280Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义损失函数，和优化函数\n",
    "\n",
    "cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), axis=1))\n",
    "train_step = tf.train.AdagradOptimizer(0.3).minimize(cross_entropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:05.947161Z",
     "start_time": "2018-11-11T11:43:05.848612Z"
    }
   },
   "outputs": [],
   "source": [
    "# 初始化变量并定义会话\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "sess = tf.Session()\n",
    "sess.run(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:13.498675Z",
     "start_time": "2018-11-11T11:43:05.949481Z"
    }
   },
   "outputs": [],
   "source": [
    "# 定义小批量梯度下降\n",
    "\n",
    "batchsize = 100\n",
    "\n",
    "for i in range(0, len(X_train), batchsize):\n",
    "    batch_xs = X_train[i:i+batchsize]\n",
    "    batch_ys = y_train[i:i+batchsize]\n",
    "    sess.run(train_step, feed_dict={X:batch_xs, y_:batch_ys, keep_prob:0.8})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:13.877212Z",
     "start_time": "2018-11-11T11:43:13.501420Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9538\n"
     ]
    }
   ],
   "source": [
    "# 验证\n",
    "\n",
    "correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "print(sess.run(accuracy, feed_dict={X: X_test, y_: y_test, keep_prob: 1.0}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:13.891105Z",
     "start_time": "2018-11-11T11:43:13.880245Z"
    }
   },
   "outputs": [],
   "source": [
    "X = tf.placeholder(\"float\", [None, 784])\n",
    "y_ = tf.placeholder(\"float\", [None, 10])\n",
    "keep_prob = tf.placeholder(\"float\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:13.948173Z",
     "start_time": "2018-11-11T11:43:13.894586Z"
    }
   },
   "outputs": [],
   "source": [
    "in_units = 784\n",
    "h1_units = 300\n",
    "h2_units = 200\n",
    "h3_units = 100\n",
    "\n",
    "W1 = tf.Variable(tf.truncated_normal([in_units, h1_units], stddev=0.1))\n",
    "b1 = tf.Variable(tf.zeros([h1_units]))\n",
    "W2 = tf.Variable(tf.zeros([h1_units, h2_units]))\n",
    "b2 = tf.Variable(tf.zeros([h2_units]))\n",
    "W3 = tf.Variable(tf.zeros([h2_units, h3_units]))\n",
    "b3 = tf.Variable(tf.zeros([h3_units]))\n",
    "W4 = tf.Variable(tf.zeros([h3_units, 10]))\n",
    "b4 = tf.Variable(tf.zeros([10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:13.974851Z",
     "start_time": "2018-11-11T11:43:13.950486Z"
    }
   },
   "outputs": [],
   "source": [
    "hidden1 = tf.nn.relu(tf.matmul(X, W1) + b1)\n",
    "hidden2 = tf.nn.relu(tf.matmul(hidden1, W2) + b2)\n",
    "hidden3 = tf.nn.relu(tf.matmul(hidden2, W3) + b3)\n",
    "hidden_drop = tf.nn.dropout(hidden3, keep_prob)\n",
    "y = tf.nn.softmax(tf.matmul(hidden_drop, W4) + b4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:14.159542Z",
     "start_time": "2018-11-11T11:43:13.977895Z"
    }
   },
   "outputs": [],
   "source": [
    "cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), axis=1))\n",
    "train_step = tf.train.AdagradOptimizer(0.3).minimize(cross_entropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:14.353755Z",
     "start_time": "2018-11-11T11:43:14.162494Z"
    }
   },
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()\n",
    "sess = tf.Session()\n",
    "sess.run(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:23.620699Z",
     "start_time": "2018-11-11T11:43:14.358396Z"
    }
   },
   "outputs": [],
   "source": [
    "batchsize = 100\n",
    "\n",
    "for i in range(0,len(X_train), batchsize):\n",
    "    batch_xs = X_train[i:i+batchsize]\n",
    "    batch_ys = y_train[i:i+batchsize]\n",
    "    sess.run(train_step, feed_dict={X: batch_xs, y_: batch_ys, keep_prob: 0.5})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:23.986887Z",
     "start_time": "2018-11-11T11:43:23.622977Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1028\n"
     ]
    }
   ],
   "source": [
    "correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "print(sess.run(accuracy, feed_dict={X: X_test, y_: y_test, keep_prob: 1.0}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当数据量不大时，SVM的效果很有可能优于深度学习。"
   ]
  },
  {
   "attachments": {
    "spambase.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T04:44:21.738041Z",
     "start_time": "2018-11-11T04:44:21.730183Z"
    }
   },
   "source": [
    "垃圾邮件的危害：\n",
    "\n",
    "* 占用网络带宽，造成邮件服务器拥塞，进而降低整个网络的运行效率。\n",
    "* 侵犯收件人的隐私权，侵占收件人信箱空间，耗费收件人的时间、精力和金钱。\n",
    "* 被黑客利用成为助纣为虐的工具。\n",
    "* 严重影响ISP的服务形。\n",
    "* 妖言惑众、骗人钱财、传播色情等内容的垃圾邮件，已经对现实社会造成了危害。\n",
    "\n",
    "我们使用SpamBase这个入门级的垃圾邮件分类训练集来测试。SpamBase的数据不是原始的邮件内容而是已经特征化的数据，对应的特征是统计的关键字以及特殊符号的词频，一共58个属性，其中最后一个是垃圾邮件的标记位。\n",
    "\n",
    "![spambase.png](attachment:spambase.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:24.772536Z",
     "start_time": "2018-11-11T11:43:23.990349Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:24.923667Z",
     "start_time": "2018-11-11T11:43:24.774996Z"
    }
   },
   "outputs": [],
   "source": [
    "filename1 = './数据集/spambase/spambase.names'\n",
    "f1 = open(filename1)\n",
    "spambase_names = []\n",
    "for line in f1.readlines()[33:]:\n",
    "    spambase_names.append(line.split(':')[0])\n",
    "\n",
    "spambase_names.append('label')\n",
    "\n",
    "filename2 = './数据集/spambase/spambase.data'\n",
    "spambase_features = pd.read_csv(filename2, names=spambase_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:24.971934Z",
     "start_time": "2018-11-11T11:43:24.935355Z"
    }
   },
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(spambase_features[spambase_features.columns[:-1]], spambase_features['label'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:25.004776Z",
     "start_time": "2018-11-11T11:43:24.975870Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnb = MultinomialNB()\n",
    "mnb.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:25.020119Z",
     "start_time": "2018-11-11T11:43:25.010084Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7932232841007819"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnb.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:25.040649Z",
     "start_time": "2018-11-11T11:43:25.025802Z"
    }
   },
   "outputs": [],
   "source": [
    "y_train1 = get_onehot(y_train, size=2)\n",
    "y_test1 = get_onehot(y_test, size=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:25.059746Z",
     "start_time": "2018-11-11T11:43:25.047919Z"
    }
   },
   "outputs": [],
   "source": [
    "X = tf.placeholder(\"float\", [None, 57])\n",
    "y_ = tf.placeholder(\"float\", [None, 2])\n",
    "keep_prob = tf.placeholder(\"float\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:25.119901Z",
     "start_time": "2018-11-11T11:43:25.065875Z"
    }
   },
   "outputs": [],
   "source": [
    "in_units = 57\n",
    "h1_units = 30\n",
    "h2_units = 15\n",
    "ou_units = 2\n",
    "\n",
    "W1 = tf.Variable(tf.truncated_normal([in_units, h1_units], stddev=0.1))\n",
    "b1 = tf.Variable(tf.zeros([h1_units]))\n",
    "W2 = tf.Variable(tf.zeros([h1_units, h2_units]))\n",
    "b2 = tf.Variable(tf.zeros([h2_units]))\n",
    "W3 = tf.Variable(tf.zeros([h2_units, ou_units]))\n",
    "b3 = tf.Variable(tf.zeros([ou_units]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:25.154380Z",
     "start_time": "2018-11-11T11:43:25.121997Z"
    }
   },
   "outputs": [],
   "source": [
    "hidden1 = tf.nn.relu(tf.matmul(X, W1) + b1)\n",
    "hidden2 = tf.nn.relu(tf.matmul(hidden1, W2) + b2)\n",
    "hidden_drop = tf.nn.dropout(hidden2, keep_prob)\n",
    "y = tf.nn.softmax(tf.matmul(hidden_drop, W3) + b3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:25.787370Z",
     "start_time": "2018-11-11T11:43:25.159023Z"
    }
   },
   "outputs": [],
   "source": [
    "cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y) , axis=1))\n",
    "train_step = tf.train.AdamOptimizer(0.1).minimize(cross_entropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:26.349247Z",
     "start_time": "2018-11-11T11:43:25.789827Z"
    }
   },
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()\n",
    "sess = tf.Session()\n",
    "sess.run(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:27.081911Z",
     "start_time": "2018-11-11T11:43:26.355201Z"
    }
   },
   "outputs": [],
   "source": [
    "sess.run(train_step, feed_dict={X: X_train, y_: y_train1, keep_prob: 0.5})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:27.282328Z",
     "start_time": "2018-11-11T11:43:27.084895Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.58992183"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "sess.run(accuracy, feed_dict={X: X_test, y_: y_test1, keep_prob: 1.0})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:38.382696Z",
     "start_time": "2018-11-11T11:43:27.285537Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-39-a801d63733fa>:1: infer_real_valued_columns_from_input (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please specify feature columns explicitly.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:143: setup_train_data_feeder (from tensorflow.contrib.learn.python.learn.learn_io.data_feeder) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tensorflow/transform or tf.data.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py:96: extract_dask_data (from tensorflow.contrib.learn.python.learn.learn_io.dask_io) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please feed input to tf.data to support dask.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py:100: extract_pandas_data (from tensorflow.contrib.learn.python.learn.learn_io.pandas_io) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please access pandas data directly.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py:159: DataFeeder.__init__ (from tensorflow.contrib.learn.python.learn.learn_io.data_feeder) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tensorflow/transform or tf.data.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py:340: check_array (from tensorflow.contrib.learn.python.learn.learn_io.data_feeder) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please convert numpy dtypes explicitly.\n",
      "WARNING:tensorflow:float64 is not supported by many models, consider casting to float32.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:183: infer_real_valued_columns_from_input_fn (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please specify feature columns explicitly.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/dnn.py:378: multi_class_head (from tensorflow.contrib.learn.python.learn.estimators.head) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please switch to tf.contrib.estimator.*_head.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:1180: BaseEstimator.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please replace uses of any Estimator from tf.contrib.learn with an Estimator from tf.estimator.*\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:428: RunConfig.__init__ (from tensorflow.contrib.learn.python.learn.estimators.run_config) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "When switching to tf.estimator.Estimator, use tf.estimator.RunConfig instead.\n",
      "INFO:tensorflow:Using default config.\n",
      "WARNING:tensorflow:Using temporary folder as model directory: /var/folders/dq/s5dx7lqd1nl0kf3829swj_3w0000gn/T/tmporxp_ngr\n",
      "INFO:tensorflow:Using config: {'_task_type': None, '_task_id': 0, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0xb5b82b7f0>, '_master': '', '_num_ps_replicas': 0, '_num_worker_replicas': 0, '_environment': 'local', '_is_chief': True, '_evaluation_master': '', '_train_distribute': None, '_eval_distribute': None, '_device_fn': None, '_tf_config': gpu_options {\n",
      "  per_process_gpu_memory_fraction: 1.0\n",
      "}\n",
      ", '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_secs': 600, '_log_step_count_steps': 100, '_protocol': None, '_session_config': None, '_save_checkpoints_steps': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_model_dir': '/var/folders/dq/s5dx7lqd1nl0kf3829swj_3w0000gn/T/tmporxp_ngr'}\n"
     ]
    }
   ],
   "source": [
    "feature_columns = tf.contrib.learn.infer_real_valued_columns_from_input(X_train)\n",
    "classifier = tf.contrib.learn.DNNClassifier((60, 20), feature_columns=feature_columns, n_classes=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:45.675226Z",
     "start_time": "2018-11-11T11:43:38.385650Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-40-e3acd2cdb363>:1: calling BaseEstimator.fit (from tensorflow.contrib.learn.python.learn.estimators.estimator) with x is deprecated and will be removed after 2016-12-01.\n",
      "Instructions for updating:\n",
      "Estimator is decoupled from Scikit Learn interface by moving into\n",
      "separate class SKCompat. Arguments x, y and batch_size are only\n",
      "available in the SKCompat class, Estimator will only accept input_fn.\n",
      "Example conversion:\n",
      "  est = Estimator(...) -> est = SKCompat(Estimator(...))\n",
      "WARNING:tensorflow:From <ipython-input-40-e3acd2cdb363>:1: calling BaseEstimator.fit (from tensorflow.contrib.learn.python.learn.estimators.estimator) with y is deprecated and will be removed after 2016-12-01.\n",
      "Instructions for updating:\n",
      "Estimator is decoupled from Scikit Learn interface by moving into\n",
      "separate class SKCompat. Arguments x, y and batch_size are only\n",
      "available in the SKCompat class, Estimator will only accept input_fn.\n",
      "Example conversion:\n",
      "  est = Estimator(...) -> est = SKCompat(Estimator(...))\n",
      "WARNING:tensorflow:From <ipython-input-40-e3acd2cdb363>:1: calling BaseEstimator.fit (from tensorflow.contrib.learn.python.learn.estimators.estimator) with batch_size is deprecated and will be removed after 2016-12-01.\n",
      "Instructions for updating:\n",
      "Estimator is decoupled from Scikit Learn interface by moving into\n",
      "separate class SKCompat. Arguments x, y and batch_size are only\n",
      "available in the SKCompat class, Estimator will only accept input_fn.\n",
      "Example conversion:\n",
      "  est = Estimator(...) -> est = SKCompat(Estimator(...))\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:509: SKCompat.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please switch to the Estimator interface.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py:98: extract_dask_labels (from tensorflow.contrib.learn.python.learn.learn_io.dask_io) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please feed input to tf.data to support dask.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/learn_io/data_feeder.py:102: extract_pandas_labels (from tensorflow.contrib.learn.python.learn.learn_io.pandas_io) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please access pandas data directly.\n",
      "WARNING:tensorflow:float64 is not supported by many models, consider casting to float32.\n",
      "WARNING:tensorflow:Casting <dtype: 'int64'> labels to bool.\n",
      "WARNING:tensorflow:Casting <dtype: 'int64'> labels to bool.\n",
      "WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to \"careful_interpolation\" instead.\n",
      "WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to \"careful_interpolation\" instead.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/head.py:678: ModelFnOps.__new__ (from tensorflow.contrib.learn.python.learn.estimators.model_fn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "When switching to tf.estimator.Estimator, use tf.estimator.EstimatorSpec. You can use the `estimator_spec` method to create an equivalent one.\n",
      "INFO:tensorflow:Create CheckpointSaverHook.\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n",
      "INFO:tensorflow:Saving checkpoints for 0 into /var/folders/dq/s5dx7lqd1nl0kf3829swj_3w0000gn/T/tmporxp_ngr/model.ckpt.\n",
      "INFO:tensorflow:loss = 1.1173947, step = 1\n",
      "INFO:tensorflow:global_step/sec: 99.1228\n",
      "INFO:tensorflow:loss = 2.101709, step = 101 (1.013 sec)\n",
      "INFO:tensorflow:global_step/sec: 359.359\n",
      "INFO:tensorflow:loss = 0.7276, step = 201 (0.276 sec)\n",
      "INFO:tensorflow:global_step/sec: 375.631\n",
      "INFO:tensorflow:loss = 0.4892984, step = 301 (0.267 sec)\n",
      "INFO:tensorflow:global_step/sec: 404.942\n",
      "INFO:tensorflow:loss = 0.39098227, step = 401 (0.247 sec)\n",
      "INFO:tensorflow:global_step/sec: 419.029\n",
      "INFO:tensorflow:loss = 0.26305395, step = 501 (0.238 sec)\n",
      "INFO:tensorflow:global_step/sec: 412.718\n",
      "INFO:tensorflow:loss = 0.3635394, step = 601 (0.243 sec)\n",
      "INFO:tensorflow:global_step/sec: 423.055\n",
      "INFO:tensorflow:loss = 0.64067376, step = 701 (0.236 sec)\n",
      "INFO:tensorflow:global_step/sec: 411.553\n",
      "INFO:tensorflow:loss = 0.41022438, step = 801 (0.242 sec)\n",
      "INFO:tensorflow:global_step/sec: 436.209\n",
      "INFO:tensorflow:loss = 0.2981265, step = 901 (0.229 sec)\n",
      "INFO:tensorflow:Saving checkpoints for 1000 into /var/folders/dq/s5dx7lqd1nl0kf3829swj_3w0000gn/T/tmporxp_ngr/model.ckpt.\n",
      "INFO:tensorflow:Loss for final step: 0.099421486.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "DNNClassifier(params={'head': <tensorflow.contrib.learn.python.learn.estimators.head._BinaryLogisticHead object at 0x1a71566358>, 'hidden_units': (60, 20), 'feature_columns': (_RealValuedColumn(column_name='', dimension=57, default_value=None, dtype=tf.float64, normalizer=None),), 'optimizer': None, 'activation_fn': <function relu at 0x138cf6ea0>, 'dropout': None, 'gradient_clip_norm': None, 'embedding_lr_multipliers': None, 'input_layer_min_slice_size': None})"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier.fit(X_train, y_train, steps=1000, batch_size=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:46.348496Z",
     "start_time": "2018-11-11T11:43:45.679291Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/python/util/deprecation.py:553: calling DNNClassifier.predict (from tensorflow.contrib.learn.python.learn.estimators.dnn) with outputs=None is deprecated and will be removed after 2017-03-01.\n",
      "Instructions for updating:\n",
      "Please switch to predict_classes, or set `outputs` argument.\n",
      "WARNING:tensorflow:From /Users/johnnie/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/dnn.py:463: calling BaseEstimator.predict (from tensorflow.contrib.learn.python.learn.estimators.estimator) with x is deprecated and will be removed after 2016-12-01.\n",
      "Instructions for updating:\n",
      "Estimator is decoupled from Scikit Learn interface by moving into\n",
      "separate class SKCompat. Arguments x, y and batch_size are only\n",
      "available in the SKCompat class, Estimator will only accept input_fn.\n",
      "Example conversion:\n",
      "  est = Estimator(...) -> est = SKCompat(Estimator(...))\n",
      "WARNING:tensorflow:float64 is not supported by many models, consider casting to float32.\n",
      "INFO:tensorflow:Graph was finalized.\n",
      "INFO:tensorflow:Restoring parameters from /var/folders/dq/s5dx7lqd1nl0kf3829swj_3w0000gn/T/tmporxp_ngr/model.ckpt-1000\n",
      "INFO:tensorflow:Running local_init_op.\n",
      "INFO:tensorflow:Done running local_init_op.\n"
     ]
    }
   ],
   "source": [
    "y_predict = np.array(list(classifier.predict(X_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:46.357127Z",
     "start_time": "2018-11-11T11:43:46.351807Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-11T11:43:46.372220Z",
     "start_time": "2018-11-11T11:43:46.361828Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8801042571676803"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, y_predict)"
   ]
  }
 ],
 "metadata": {
  "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}