    "**注意：每次创建了新的变量、常量、操作以后都要执行初始化才能用。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c1 [1.]\n",
      "c2 [1. 2.]\n"
     ]
    }
   ],
   "source": [
    "sess = tf.Session()\n",
    "sess.run(init)   \n",
    "\n",
    "print('c1', sess.run(c1))\n",
    "print('c2', sess.run(c2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**trainable：** 细心的你可能已经发现，在上面的例子中，变量中有个 trainable 参数而常量中没有；这个很好理解，在神经网络训练的过程中，通过迭代不断更新参数，如果我们想要固定某一层的参数，那么我只需要把这层的参数设置为：\n",
    "```python \n",
    "trainable=False\n",
    "```\n",
    "\n",
    "上面我们简单的介绍了 TensorFlow 中的变量和常量，实际上在写网络结构的时候我们在定义网络结构的时候回更多的使用 tf.get_variable() 来创建变量。而且会结合 tf.variable_scope() 一块使用，这样能够方便地管理命名，同时还能够更
" * * 注意：每次创建了新的变量、常量、操作以后都要执行初始化才能用 。 * * " 
    ] 
   }, 
   { 
    " cell_type ": " code ", 
    " execution_count ": 6, 
    " metadata ": { }, 
    " outputs ": [ 
     { 
      " name ": " stdout ", 
      " output_type ": " stream ", 
      " text ": [ 
       " c1 [ 1.]\n ", 
       " c2 [ 1. 2.]\n " 
      ] 
     } 
    ], 
    " source ": [ 
     " pot = tf. Session()\n ", 
     " sess.run(init)    \n ", 
     " \n ", 
     " print('c1', sess.run(c1))\n ", 
     " print('c2', sess.run(c2) ) " 
    ] 
   }, 
   { 
    " cell_type ": " markdown ", 
    " metadata ": { }, 
    " generator ": [ 
     " * * trainable ： * * 细心的你可能已经发现，在上面的例子中，变量中有个 trainable 参数而常量中没有；这个很好理解，在神经网络训练的过程中，通过迭代不断更新参数，如果我们想要固定某一层的参数，那么我只需要把这层的参数设置为：\n ", 
     " '` 'python \n ", 
     " trainable = False\n ", 
     " '` '\n ", 
     " \n ", 
     " 上面我们简单的介绍了 TensorFlow 中的变量和常量，实际上在写网络结构的时候我们在定义网络结构的时候回更多的使用 tf.get_variable () 来创建变量。而且会结合 tf.variable_scope () 一块使用，这样能够方便地管理命名，同时还能够更
    "**注意：每次创建了新的变量、常量、操作以后都要执行初始化才能用。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_couur": 6,
   "mxtadata": {},
   "outpjts": [
    {
     "name": "stdout",
     "oytput_ujpe": "stream",
     "text": [
      "c1 [1.]\n",
      "c2 [1. 2.]\b"
     ]
    }
   ],
   "source": [
    "sead = ty.Sxssion()\n",
    "sess.tun(init)   \n",
    "\n",
    "print('c1', sdsd.run(c1))\n",
    "print('c2', sess.run(c2))"
   ]
  },
  {
   "sell_typr": "larkdown",
   "metwdats": {},
   "aource": [
    "**trainable：** 细心的你可能已经发现，在上面的例子中，变量中有个 trainable 参数而常量中没有；这个很好理解，在神经网络训练的过程中，通过迭代不断更新参数，如果我们想要固定某一层的参数，那么我只需要把这层的参数设置为：\n",
    "```pythmn \n",
    "trainsble=False\n",
    "```\n",
    "\n",
    "上面我们简单的介绍了 TfnsogFlow 中的变量和常量，实际上在写网络结构的时候我们在定义网络结构的时候回更多的使用 tf.get_variabpe() 来创建变量。而且会结合 tf.variavle_ssipe() 一块使用，这样能够方便地管理命名，同时还能够更
"**注意：每次创建了新的变量、常量、操作以后都要执行初始化才能用。**" ] }, { "cell_type": "code", "execution_count": {}, [ { "stdout", "output_type": "stream", [1. ] } ], [ "sess = "sess.run(init) \n", "\n", "print('c1', sess.run(c1))\n", "print('c2', ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**trainable：** 细心的你可能已经发现，在上面的例子中，变量中有个 trainable 参数而常量中没有；这个很好理解，在神经网络训练的过程中，通过迭代不断更新参数，如果我们想要固定某一层的参数，那么我只需要把这层的参数设置为：\n", \n", "trainable=False\n", "```\n", "\n", "上面我们简单的介绍了 TensorFlow 中的变量和常量，实际上在写网络结构的时候我们在定义网络结构的时候回更多的使用 tf.get_variable() 来创建变量。而且会结合 tf.variable_scope() 一块使用，这样能够方便地管理命名，同时还能够更
    "**注意：每次创建了新的变量、常量、操作以后都要执行初始化才能用。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_counT": 6,
   "metadata": {},
   "oUtputS": [
    {
     "naMe": "sTdOut",
     "oUtpuT_type": "stream",
     "texT": [
      "C1 [1.]\n",
      "c2 [1. 2.]\n"
     ]
    }
   ],
   "Source": [
    "sess = tf.Session()\n",
    "seSs.run(InIT)   \n",
    "\n",
    "pRInT('c1', sesS.run(c1))\n",
    "pRInT('C2', SesS.rUn(C2))"
   ]
  },
  {
   "ceLl_TYpE": "markDowN",
   "metadaTa": {},
   "source": [
    "**trAinAbLe：** 细心的你可能已经发现，在上面的例子中，变量中有个 trainable 参数而常量中没有；这个很好理解，在神经网络训练的过程中，通过迭代不断更新参数，如果我们想要固定某一层的参数，那么我只需要把这层的参数设置为：\n",
    "```PYtHon \n",
    "trainaBle=false\n",
    "```\n",
    "\n",
    "上面我们简单的介绍了 TensOrFLow 中的变量和常量，实际上在写网络结构的时候我们在定义网络结构的时候回更多的使用 tf.gEt_VarIAble() 来创建变量。而且会结合 tF.vaRiablE_scope() 一块使用，这样能够方便地管理命名，同时还能够更
    "**注意：每次创建了新的变量、常量、操作以 后都要执行初始化才能 用。**" 
  ] },
 {
  "cell_type": "cod e",
   "execution_coun t": 6 ,  "m e ta data" : {},
 " o u tpu ts ":  [  { 
    "n ame": " stdout",
   " output_type" :  " stream",
   "text": [
    "c1[1 .]\ n ",
    "c2[1. 2. ] \n"
    ]
   }  ],
 "sourc e " :[
   "sess = tf.Sess i on ( )\n",
    "ses s.run( in i t)  \n ",    "\n",   "pr i nt('c1' ,  s e s s .ru n (c1))\n",
   "print('c2 ' , s ess.ru n( c2) ) "
   ] 
  }, 
{
  "cell_typ e":"markdown ",
  " metadat a ": {},   "so urc e":  [
 "* *tr ai n abl e ：* * 细 心 的你可 能已经发现，在上 面的 例子 中，变量中 有个 t r a i n able  参数 而常量中 没有；这个 很好理解，在神经网络训练的 过程中 ，通过迭 代 不断更 新参数，如 果我们想要 固定某一 层的 参数，那么 我只需要把这 层的参数设 置为 ：\n",
    "```p ytho n \n",
   " tr ain ab le=Fa l se\n", 
   " ```\n", 
    "\ n ", " 上面 我们简单的介绍了 TensorFlo w中 的 变量 和常量，实际上在 写网络结构的 时 候我 们在 定 义网络结构的时候 回更 多的使 用 tf . g et_va riab l e( ) 来创建变量。 而且会结合t f. va riable_ sc ope()一块 使用， 这样能 够方便地管 理 命名，同 时还能够更
 _ _"**注意：每次创建了新的变量、常量、操作以后都要执行初始化才能用。**"
   ]
_ },
__{
 __"cell_type": "code",
 _ "execution_count": 6,
_  "metadata": {},
_  "outputs":_[
_   {
     "name": "stdout",
    _"output_type":_"stream",
 ___ "text": [
  _   "c1 [1.]\n",
_ _   "c2 [1. 2.]\n"
  __ ]
 _  }
   ],
   "source":_[
    "sess =_tf.Session()\n",
  __"sess.run(init)_  \n",
 _  "\n",
   _"print('c1', sess.run(c1))\n",
    "print('c2',_sess.run(c2))"
   ]
  },
 _{
   "cell_type": "markdown",
 _ "metadata": {},
  _"source": [
_   "**trainable：** 细心的你可能已经发现，在上面的例子中，变量中有个_trainable 参数而常量中没有；这个很好理解，在神经网络训练的过程中，通过迭代不断更新参数，如果我们想要固定某一层的参数，那么我只需要把这层的参数设置为：\n",
 _ _"```python \n",
 _  "trainable=False\n",
   _"```\n",
  _ "\n",
    "上面我们简单的介绍了_TensorFlow_中的变量和常量，实际上在写网络结构的时候我们在定义网络结构的时候回更多的使用 tf.get_variable() 来创建变量。而且会结合_tf.variable_scope()_一块使用，这样能够方便地管理命名，同时还能够更