Tensorflow_01_neuralnetwork_exercise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 深度学习01\n",
    "tensorflow实现神经网络，小练习"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "#0~1正太分布\n",
    "x_data = np.random.rand(100).astype(np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5495131], dtype=float32)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_data[1:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_data = x_data*0.1 + 0.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建神经网络结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "Weights = tf.Variable(tf.random_uniform([1], -1, 1))\n",
    "biases = tf.Variable(tf.zeros([1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = Weights*x_data + biases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = tf.reduce_mean(tf.square(y - y_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "梯度优化器，alpha是学习率，步长"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.GradientDescentOptimizer(0.5)\n",
    "train = optimizer.minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 激活神经网咯"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "sess = tf.Session()\n",
    "sess.run(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 [0.0999999] [0.30000007]\n",
      "40 [0.0999999] [0.30000007]\n",
      "60 [0.0999999] [0.30000007]\n",
      "80 [0.0999999] [0.30000007]\n",
      "100 [0.0999999] [0.30000007]\n",
      "120 [0.0999999] [0.30000007]\n",
      "140 [0.0999999] [0.30000007]\n",
      "160 [0.0999999] [0.30000007]\n",
      "180 [0.0999999] [0.30000007]\n",
      "200 [0.0999999] [0.30000007]\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,201):\n",
    "    sess.run(train)\n",
    "    \n",
    "    if i % 20 == 0:\n",
    "        print(i, sess.run(Weights), sess.run(biases))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tf的框架不是很熟悉，下面是一些小练习"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tensorflow.python.framework.ops.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "t1 = tf.square(2)\n",
    "print(type(t1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.练习tf.session()的两种用法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.0\n",
      "30.0\n"
     ]
    }
   ],
   "source": [
    "# Build a graph.\n",
    "a = tf.constant(5.0)\n",
    "b = tf.constant(6.0)\n",
    "c = a * b\n",
    "\n",
    "#方式1\n",
    "# Launch the graph in a session.\n",
    "sess = tf.Session()\n",
    "\n",
    "# Evaluate the tensor `c`.\n",
    "print(sess.run(c))\n",
    "\n",
    "#方式2\n",
    "with tf.Session() as sess:\n",
    "    result = sess.run(c)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.3539108   0.11981868 -1.4098587 ]\n",
      " [-1.2650666   1.1192477   0.135821  ]\n",
      " [-0.25941697 -0.27708125  0.45804536]\n",
      " [-0.31131345 -0.90213853  0.75700223]]\n",
      "==========\n",
      "[[-0.19245903 -0.6280875   0.5139842 ]\n",
      " [ 0.90787965 -0.4532622   0.4412122 ]\n",
      " [ 0.8621351   1.2975181  -0.40375742]\n",
      " [-0.996079   -0.86339086  0.35558647]]\n",
      "123\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "#返回服从正态分布的n个值\n",
    "v1=tf.Variable(tf.random_normal(shape=[4,3],mean=0,stddev=1),name='v1')\n",
    "v2=tf.Variable(tf.constant(123),name='v2') #常数\n",
    "v3=tf.Variable(tf.ones([4,3]),name='v3') #全1\n",
    "\n",
    "#方式1\n",
    "sess = tf.Session()\n",
    "init = tf.initialize_all_variables()\n",
    "sess.run(init) #先初始化\n",
    "print(sess.run(v1))\n",
    "\n",
    "print('==========')\n",
    "#方式2\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run(v1))\n",
    "    print(sess.run(v2))\n",
    "    print(sess.run(v3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.变量的练习,\n",
    "变量加法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "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": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tensorflow.python.framework.ops.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "one = tf.constant(1)\n",
    "print(type(one))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_value = tf.add(state, one)\n",
    "#赋值，更新\n",
    "update = tf.assign(state, new_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(init)\n",
    "    \n",
    "    for i in range(3):\n",
    "        sess.run(update)\n",
    "    print(sess.run(state))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[12]]\n",
      "(1, 2) (2, 1)\n"
     ]
    }
   ],
   "source": [
    "matrix1 = tf.constant([[2,2]])\n",
    "matrix2 = tf.constant([[3],\n",
    "                       [3]])\n",
    "result = tf.matmul(matrix1, matrix2)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    result = sess.run(result)\n",
    "print(result)\n",
    "print(matrix1.shape, matrix2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 传入值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.2]\n"
     ]
    }
   ],
   "source": [
    "#输入值先hold\n",
    "input1 = tf.placeholder(tf.float32)\n",
    "input2 = tf.placeholder(tf.float32)\n",
    "\n",
    "output = tf.multiply(input1, input2)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    #feed_dict和placeholder绑定的\n",
    "    print(sess.run(output, feed_dict={input1:[1.1],\n",
    "                                    input2:[2.]}))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "激励函数举例：Sigmoid function,Linear function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}