tensorflow基础.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# tensorflow 线性回归 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creat data\n",
    "x_data = np.random.rand(100).astype(np.float32)\n",
    "y_data = x_data * 0.1 + 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "### creat tensorflow structure start ###\n",
    "Weights = tf.Variable(tf.random_uniform([1],-1.0,1.0))  #生成一维变量(-1,1)\n",
    "biases = tf.Variable(tf.zeros([1]))\n",
    "\n",
    "y = Weights * x_data + biases\n",
    "\n",
    "loss = tf.reduce_mean(tf.square(y - y_data))\n",
    "optimizer = tf.train.GradientDescentOptimizer(0.5)   #建立优化器(学习率)\n",
    "train = optimizer.minimize(loss)\n",
    "\n",
    "init = tf.global_variables_initializer()    #变量初始化\n",
    "#init = tf.initialize_all_variables()    \n",
    "### creat tensorflow structure end ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 [-0.12793511] [0.5822742]\n",
      "20 [0.01123885] [0.34734496]\n",
      "40 [0.07326261] [0.31426167]\n",
      "60 [0.09194595] [0.30429602]\n",
      "80 [0.09757389] [0.3012941]\n",
      "100 [0.09926917] [0.30038983]\n",
      "120 [0.09977985] [0.30011743]\n",
      "140 [0.0999337] [0.3000354]\n",
      "160 [0.09998003] [0.30001065]\n",
      "180 [0.099994] [0.30000323]\n",
      "200 [0.09999821] [0.30000097]\n"
     ]
    }
   ],
   "source": [
    "sess = tf.Session()\n",
    "sess.run(init)   #激活init\n",
    "\n",
    "for step in range(201):\n",
    "    sess.run(train)\n",
    "    if step % 20 == 0:\n",
    "        print(step,sess.run(Weights),sess.run(biases))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Session会话控制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix1 = tf.constant([[3,3]])\n",
    "matrix2 = tf.constant([[2],\n",
    "                       [2]])\n",
    "product = tf.matmul(matrix1,matrix2)    #matrix multiply输入必须是矩阵，等同于np.dot(m1,m2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[12]]\n"
     ]
    }
   ],
   "source": [
    "### method 1 手动关闭###\n",
    "sess = tf.Session()\n",
    "result = sess.run(product)\n",
    "print(result)\n",
    "sess.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[12]]\n"
     ]
    }
   ],
   "source": [
    "### method 2 在with中自动关闭###\n",
    "with tf.Session() as sess:\n",
    "    result2 = sess.run(product)\n",
    "    print(result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "counter_1:0\n"
     ]
    }
   ],
   "source": [
    "state = tf.Variable(0,name = 'counter')\n",
    "print(state.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "one = tf.constant(1)\n",
    "new_value = tf.add(state,one)   #变量加常量结果是变量\n",
    "update = tf.assign(state,new_value)    #把new_value的值加载到state上\n",
    "\n",
    "init = tf.initialize_all_variables()   #定义变量一定要初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:    #在session中开始执行\n",
    "    sess.run(init)\n",
    "    for _ in range(3):\n",
    "        sess.run(update)\n",
    "        print(sess.run(state))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 传入值placeholder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "input1 = tf.placeholder(tf.float32)    #tf.placeholder(type)\n",
    "input2 = tf.placeholder(tf.float32)\n",
    "\n",
    "output = tf.multiply(input1,input2)    #tf.multiply()矩阵中元素对应相乘"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[14.]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:     #feed_dict给placeholder传值\n",
    "    print(sess.run(output,feed_dict={input1:[7.],input2:[2.]})) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# activation function 激活函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tf.nn.relu(features,name = None)\n",
    "### tf.nn.relu6(features,name = None)\n",
    "### tf.nn.softplus(features,name = None)\n",
    "### tf.nn.dropout(x,keep_prob,noise_shape=None,seed=None,name = None)\n",
    "### tf.nn.bias_add(values,bias,name = None)\n",
    "### tf.sigmoid(x,name=None)\n",
    "### tf.tanh(x,name=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 添加层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_layer(inputs,in_size,out_size,n_layer,activation_function=None):\n",
    "    layer_name = 'layer%s'% n_layer\n",
    "    with tf.name_scope(layer_name):\n",
    "        with tf.name_scope('weights'):\n",
    "            Weights = tf.Variable(tf.random_normal([in_size,out_size]),name='W')\n",
    "            tf.summary.histogram(layer_name+'/weights',Weights)\n",
    "        with tf.name_scope('biases'):\n",
    "            biases = tf.Variable(tf.zeros([1,out_size]) + 0.1)\n",
    "            tf.summary.histogram(layer_name+'/biases',biases)\n",
    "        with tf.name_scope('Wx_plus_b'):\n",
    "            Wx_plus_b = tf.add(tf.matmul(inputs,Weights), biases)\n",
    "        if activation_function is None:\n",
    "            outputs = Wx_plus_b\n",
    "        else:\n",
    "            outputs = activation_function(Wx_plus_b)    #用非线性激活函数处理输出值\n",
    "        tf.summary.histogram(layer_name+'/outputs',outputs)\n",
    "        return outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 构建神经网络 + 可视化(在Jupyter中无法动态展示)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "x_data = np.linspace(-1,1,300)[:,np.newaxis]  #np.newaxis在其所在的位置增加一个维度\n",
    "noise = np.random.normal(0,0.05,x_data.shape) #np.random.normal(均值，方差，格式)\n",
    "y_data = np.square(x_data) - 0.5 + noise      #真实y值\n",
    "\n",
    "with tf.name_scope('inputs'):\n",
    "    xs = tf.placeholder(tf.float32,[None,1],name='x_input')    #[None,1]指行不定一列\n",
    "    ys = tf.placeholder(tf.float32,[None,1],name='y_input')    #name在图层中展示"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "###定义隐藏层\n",
    "layer1 = add_layer(xs,1,10,activation_function=tf.nn.relu)\n",
    "prediction = add_layer(layer1,10,1,activation_function=None)\n",
    "with tf.name_scope('loss'):\n",
    "    loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),reduction_indices=[1]))\n",
    "    tf.summary.scalar('loss',loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('train'):\n",
    "    train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)\n",
    "\n",
    "init = tf.global_variables_initializer()      #变量初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sess = tf.Session()\n",
    "merged = tf.summary.merge_all()\n",
    "writer = tf.summary.FileWriter('logs/',sess.graph)   #将框架写入文件中\n",
    "sess.run(init)\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "ax.scatter(x_data,y_data)\n",
    "plt.ion()    #绘图后不暂停\n",
    "plt.show()   \n",
    "\n",
    "for i in range(1000):\n",
    "    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})\n",
    "    if i % 50 == 0:\n",
    "        result = sess.run(merged,feed_dict={xs:x_data,ys:y_data})\n",
    "        writer.add_summary(result,i)\n",
    "        #print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}))\n",
    "        try:\n",
    "            ax.lines.remove(lines[0])   #先抹除第一条线\n",
    "        except Exception:\n",
    "            pass\n",
    "        prediction_value = sess.run(prediction,feed_dict={xs:x_data})\n",
    "        lines = ax.plot(x_data,prediction_value,'r-',lw=5)    #画出预测值和自变量的曲线\n",
    "        plt.pause(0.1)        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# optimizer优化器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tf.train. GradientDescentOptimizer\n",
    "### tf.train. AdadeltaOptimizer\n",
    "### tf.train. AdagradOptimizer\n",
    "### tf.train. MomentumOptimizer\n",
    "### tf.train. AdamOptimizer\n",
    "### tf.train. FtrlOptimizer\n",
    "### tf.train. RMSPropOptimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}