diff --git a/0_python/3_Data_Structure_1.ipynb b/0_python/3_Data_Structure_1.ipynb
index 0d4bd2c..561a699 100644
--- a/0_python/3_Data_Structure_1.ipynb
+++ b/0_python/3_Data_Structure_1.ipynb
@@ -898,14 +898,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1, 1, 4, 8, 7, 'name', 1, [5, 4, 2, 8], 5, 4, 2, 8]\n"
+     "ename": "NameError",
+     "evalue": "name 'lst' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-1-c109f115d7f9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlst\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minsert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'name'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlst\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'lst' is not defined"
      ]
     }
    ],
diff --git a/1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial.ipynb b/1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial.ipynb
index 09a6b9e..ad6cf59 100644
--- a/1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial.ipynb
+++ b/1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial.ipynb
@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Numpy -  multidimensional data arrays"
+    "# Numpy -  多维数据的数组"
    ]
   },
   {
@@ -13,9 +13,9 @@
    "source": [
     "J.R. Johansson (jrjohansson at gmail.com)\n",
     "\n",
-    "The latest version of this [IPython notebook](http://ipython.org/notebook.html) lecture is available at [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n",
+    "最新的[IPython notebook](http://ipython.org/notebook.html)课程可以在[http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures) 找到.\n",
     "\n",
-    "The other notebooks in this lecture series are indexed at [http://jrjohansson.github.io](http://jrjohansson.github.io)."
+    "其他有关这个课程的参考书在这里标注出[http://jrjohansson.github.io](http://jrjohansson.github.io).\n"
    ]
   },
   {
@@ -24,7 +24,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# what is this line all about?!? Answer in lecture 4\n",
+    "# 这一行的作用会在课程4中回答\n",
     "%matplotlib inline\n",
     "import matplotlib.pyplot as plt"
    ]
@@ -33,21 +33,21 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Introduction"
+    "## 简介"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The `numpy` package (module) is used in almost all numerical computation using Python. It is a package that provide high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran so when calculations are vectorized (formulated with vectors and matrices), performance is very good. \n",
+    "这个`numpy`包(模块)用在几乎所有使用Python的数值计算中。他是一个为Python提供高性能向量，矩阵和高维数据结构的模块。它是用C和Fortran语言实现的，因此当计算被向量化（用向量和矩阵表示）时，性能非常的好。\n",
     "\n",
-    "To use `numpy` you need to import the module, using for example:"
+    "为了使用`numpy`模块，你先要向下面的例子一样导入这个模块："
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -59,7 +59,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In the `numpy` package the terminology used for vectors, matrices and higher-dimensional data sets is *array*. \n",
+    "在`numpy`模块中，用于向量，矩阵和高维数据集的术语是*数组*。\n",
     "\n"
    ]
   },
@@ -67,37 +67,37 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Creating `numpy` arrays"
+    "## 创建`numpy`数组"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "There are a number of ways to initialize new numpy arrays, for example from\n",
+    "有很多种方法去初始化新的numpy数组, 例如从\n",
     "\n",
-    "* a Python list or tuples\n",
-    "* using functions that are dedicated to generating numpy arrays, such as `arange`, `linspace`, etc.\n",
-    "* reading data from files"
+    "* Python列表或元组\n",
+    "* 使用专门用来创建numpy arrays的函数，例如 `arange`, `linspace`等\n",
+    "* 从文件中读取数据"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### From lists"
+    "### 从列表中"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For example, to create new vector and matrix arrays from Python lists we can use the `numpy.array` function."
+    "例如，为了从Python列表创建新的向量和矩阵我们可以用`numpy.array`函数。\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -106,7 +106,7 @@
        "array([1, 2, 3, 4])"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -122,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -137,7 +137,7 @@
     }
    ],
    "source": [
-    "# a matrix: the argument to the array function is a nested Python list\n",
+    "# 矩阵:数组函数的参数是一个嵌套的Python列表\n",
     "M = array([[1, 2], [3, 4], [5, 6]])\n",
     "\n",
     "print(M)\n",
@@ -148,12 +148,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The `v` and `M` objects are both of the type `ndarray` that the `numpy` module provides."
+    "`v`和`M`两个都是属于`numpy`模块提供的`ndarray`类型。"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -162,7 +162,7 @@
        "(numpy.ndarray, numpy.ndarray)"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -175,12 +175,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The difference between the `v` and `M` arrays is only their shapes. We can get information about the shape of an array by using the `ndarray.shape` property."
+    "`v`和`M`之间的区别仅在于他们的形状。我们可以用属性函数`ndarray.shape`得到数组形状的信息。"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -189,7 +189,7 @@
        "(4,)"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -200,7 +200,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -209,7 +209,7 @@
        "(3, 2)"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -222,12 +222,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The number of elements in the array is available through the `ndarray.size` property:"
+    "通过属性函数`ndarray.size`我们可以得到数组中元素的个数"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -236,7 +236,7 @@
        "6"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -249,12 +249,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Equivalently, we could use the function `numpy.shape` and `numpy.size`"
+    "同样，我们可以用函数`numpy.shape`和`numpy.size`"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -263,7 +263,7 @@
        "(3, 2)"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -274,7 +274,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -283,7 +283,7 @@
        "6"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -296,21 +296,21 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "So far the `numpy.ndarray` looks awefully much like a Python list (or nested list). Why not simply use Python lists for computations instead of creating a new array type? \n",
+    "到目前为止`numpy.ndarray`看起来非常像Python列表(或嵌套列表)。为什么不简单地使用Python列表来进行计算，而不是创建一个新的数组类型?\n",
     "\n",
-    "There are several reasons:\n",
+    "下面有几个原因：\n",
     "\n",
-    "* Python lists are very general. They can contain any kind of object. They are dynamically typed. They do not support mathematical functions such as matrix and dot multiplications, etc. Implementing such functions for Python lists would not be very efficient because of the dynamic typing.\n",
-    "* Numpy arrays are **statically typed** and **homogeneous**. The type of the elements is determined when the array is created.\n",
-    "* Numpy arrays are memory efficient.\n",
-    "* Because of the static typing, fast implementation of mathematical functions such as multiplication and addition of `numpy` arrays can be implemented in a compiled language (C and Fortran is used).\n",
+    "* Python列表非常普遍。它们可以包含任何类型的对象。它们是动态类型的。它们不支持矩阵和点乘等数学函数。由于动态类型的关系，为Python列表实现这类函数的效率不是很高。\n",
+    "* Numpy数组是**静态类型的**和**同构的**。元素的类型是在创建数组时确定的。\n",
+    "* Numpy数组是内存高效的。\n",
+    "* 由于是静态类型，数学函数的快速实现，比如“numpy”数组的乘法和加法可以用编译语言实现(使用C和Fortran).\n",
     "\n",
-    "Using the `dtype` (data type) property of an `ndarray`, we can see what type the data of an array has:"
+    "利用`ndarray`的属性函数`dtype`（数据类型），我们可以看出数组的数据是那种类型。\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -319,7 +319,7 @@
        "dtype('int64')"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -332,12 +332,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We get an error if we try to assign a value of the wrong type to an element in a numpy array:"
+    "如果我们试图给一个numpy数组中的元素赋一个错误类型的值，我们会得到一个错误:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
@@ -347,7 +347,7 @@
      "traceback": [
       "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-17-e1f336250f69>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m<ipython-input-12-e1f336250f69>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
       "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'hello'"
      ]
     }
@@ -360,12 +360,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we want, we can explicitly define the type of the array data when we create it, using the `dtype` keyword argument: "
+    "如果我们想的话，我们可以利用`dtype`关键字参数显式地定义我们创建的数组数据类型："
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -375,7 +375,7 @@
        "       [3.+0.j, 4.+0.j]])"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -390,23 +390,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Common data types that can be used with `dtype` are: `int`, `float`, `complex`, `bool`, `object`, etc.\n",
+    "常规可以伴随`dtype`使用的数据类型是：`int`, `float`, `complex`, `bool`, `object`等\n",
     "\n",
-    "We can also explicitly define the bit size of the data types, for example: `int64`, `int16`, `float128`, `complex128`."
+    "我们也可以显式地定义数据类型的大小，例如：`int64`, `int16`, `float128`, `complex128`。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Using array-generating functions"
+    "### 使用数组生成函数"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For larger arrays it is inpractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generate arrays of different forms. Some of the more common are:"
+    "对于较大的数组，使用显式的Python列表人为地初始化数据是不切实际的。除此之外我们可以用`numpy`的很多函数得到不同类型的数组。有一些常用的分别是："
    ]
   },
   {
@@ -418,7 +418,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
@@ -431,9 +431,9 @@
     }
    ],
    "source": [
-    "# create a range\n",
+    "# 创建一个范围\n",
     "\n",
-    "x = np.arange(0, 10, 1) # arguments: start, stop, step\n",
+    "x = np.arange(0, 10, 1) # 参数：start, stop, step: \n",
     "y = range(0, 10, 1)\n",
     "print(x)\n",
     "print(list(y))"
@@ -441,7 +441,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
@@ -454,7 +454,7 @@
        "        6.00000000e-01,  7.00000000e-01,  8.00000000e-01,  9.00000000e-01])"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -474,7 +474,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
@@ -487,19 +487,19 @@
        "        8.33333333,  8.75      ,  9.16666667,  9.58333333, 10.        ])"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# using linspace, both end points ARE included\n",
+    "# 使用linspace两边的端点也被包含进去\n",
     "np.linspace(0, 10, 25)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -510,7 +510,7 @@
        "       7.25095809e+03, 2.20264658e+04])"
       ]
      },
-     "execution_count": 25,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -528,16 +528,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
-    "x, y = np.mgrid[0:5, 0:5] # similar to meshgrid in MATLAB"
+    "x, y = np.mgrid[0:5, 0:5] # 和MATLAB中的meshgrid类似"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
@@ -550,7 +550,7 @@
        "       [4, 4, 4, 4, 4]])"
       ]
      },
-     "execution_count": 27,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -561,7 +561,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -574,7 +574,7 @@
        "       [0, 1, 2, 3, 4]])"
       ]
      },
-     "execution_count": 28,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -592,7 +592,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -601,51 +601,51 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[0.82594014, 0.31160547, 0.77827738, 0.59082014, 0.69654657],\n",
-       "       [0.64715318, 0.05551977, 0.38057657, 0.45135262, 0.37209654],\n",
-       "       [0.01234335, 0.12906551, 0.75598568, 0.20905719, 0.86103339],\n",
-       "       [0.62784645, 0.87732666, 0.96543239, 0.41053462, 0.87116428],\n",
-       "       [0.44218283, 0.70837525, 0.15065753, 0.93552422, 0.79261749]])"
+       "array([[0.31850549, 0.64755869, 0.93737096, 0.06141188, 0.17055487],\n",
+       "       [0.95771684, 0.88466718, 0.81119863, 0.95268744, 0.73734857],\n",
+       "       [0.51036326, 0.8779331 , 0.41560197, 0.300393  , 0.42244209],\n",
+       "       [0.50866631, 0.84322931, 0.34459543, 0.47379641, 0.03312725],\n",
+       "       [0.96519922, 0.20557788, 0.38343937, 0.21493144, 0.27541461]])"
       ]
      },
-     "execution_count": 30,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# uniform random numbers in [0,1)\n",
+    "# 均匀随机数在[0,1)区间\n",
     "random.rand(5,5)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[ 0.69829709,  0.04679976,  0.95770162,  1.91007838, -0.41865049],\n",
-       "       [ 0.51678337, -0.34692074,  2.19264774, -0.59725524, -1.15314406],\n",
-       "       [ 0.03361378, -0.0054733 , -0.77389592, -0.12696594,  1.69339468],\n",
-       "       [-0.13267375,  0.95688595,  0.28043241,  0.83043672,  0.62677072],\n",
-       "       [-0.09168095, -0.25064829,  0.49440189, -1.18704973, -1.28781414]])"
+       "array([[ 1.12204579,  2.90667688, -1.06379302,  1.52801804,  1.34553205],\n",
+       "       [ 2.22610261, -0.18597008,  1.12948162, -1.44339033,  0.14366645],\n",
+       "       [ 0.12767746, -0.04534549,  0.1536468 ,  0.7333602 ,  0.96510913],\n",
+       "       [ 0.30848743, -2.31710677,  0.37803085, -0.52433003,  1.39883453],\n",
+       "       [-0.52307504,  0.40612781,  0.48341866, -1.96277249,  1.1671546 ]])"
       ]
      },
-     "execution_count": 31,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# standard normal distributed random numbers\n",
+    "# 标准正态分布随机数\n",
     "random.randn(5,5)"
    ]
   },
@@ -658,7 +658,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -669,19 +669,19 @@
        "       [0, 0, 3]])"
       ]
      },
-     "execution_count": 32,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# a diagonal matrix\n",
+    "# 一个对角矩阵\n",
     "np.diag([1,2,3])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
@@ -693,13 +693,13 @@
        "       [0, 0, 0, 0]])"
       ]
      },
-     "execution_count": 36,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# diagonal with offset from the main diagonal\n",
+    "# 从主对角线偏移的对角线\n",
     "diag([1,2,3], k=1) "
    ]
   },
@@ -712,7 +712,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
@@ -723,7 +723,7 @@
        "       [0., 0., 0.]])"
       ]
      },
-     "execution_count": 37,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -734,7 +734,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
@@ -745,7 +745,7 @@
        "       [1., 1., 1.]])"
       ]
      },
-     "execution_count": 38,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -758,26 +758,26 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## File I/O"
+    "## 文件 I/O"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Comma-separated values (CSV)"
+    "### 逗号分隔值 (CSV)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "A very common file format for data files is comma-separated values (CSV), or related formats such as TSV (tab-separated values). To read data from such files into Numpy arrays we can use the `numpy.genfromtxt` function. For example, "
+    "对于数据文件来说一种非常常见的文件格式是逗号分割值（CSV），或者有关的格式例如TSV（制表符分隔的值）。为了从这些文件中读取数据到Numpy数组中，我们可以用`numpy.genfromtxt`函数。例如："
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [
     {
@@ -803,7 +803,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -813,7 +813,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
@@ -822,7 +822,7 @@
        "(77431, 7)"
       ]
      },
-     "execution_count": 42,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -833,12 +833,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1008x288 with 1 Axes>"
       ]
@@ -865,23 +865,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Using `numpy.savetxt` we can store a Numpy array to a file in CSV format:"
+    "使用`numpy.savetxt`我们可以将一个Numpy数组以CSV格式存入:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[0.85030715, 0.33330859, 0.64002838],\n",
-       "       [0.52521743, 0.21572812, 0.33287991],\n",
-       "       [0.74605429, 0.35134767, 0.45873422]])"
+       "array([[0.73171836, 0.46544202, 0.72372739],\n",
+       "       [0.32390603, 0.09679475, 0.95467059],\n",
+       "       [0.36051701, 0.78361037, 0.00716923]])"
       ]
      },
-     "execution_count": 45,
+     "execution_count": 32,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -894,7 +894,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -903,16 +903,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "8.503071542574233144e-01 3.333085915891427220e-01 6.400283846962552259e-01\r\n",
-      "5.252174340396357222e-01 2.157281249144539226e-01 3.328799104985459278e-01\r\n",
-      "7.460542870039649221e-01 3.513476662217395186e-01 4.587342216214667090e-01\r\n"
+      "7.317183558113176112e-01 4.654420244898096470e-01 7.237273924754552556e-01\r\n",
+      "3.239060308567449642e-01 9.679474636543183852e-02 9.546705930168928322e-01\r\n",
+      "3.605170063363589694e-01 7.836103655978251536e-01 7.169228636445423852e-03\r\n"
      ]
     }
    ],
@@ -922,21 +922,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.85031 0.33331 0.64003\r\n",
-      "0.52522 0.21573 0.33288\r\n",
-      "0.74605 0.35135 0.45873\r\n"
+      "0.73172 0.46544 0.72373\r\n",
+      "0.32391 0.09679 0.95467\r\n",
+      "0.36052 0.78361 0.00717\r\n"
      ]
     }
    ],
    "source": [
-    "np.savetxt(\"random-matrix.csv\", M, fmt='%.5f') # fmt specifies the format\n",
+    "np.savetxt(\"random-matrix.csv\", M, fmt='%.5f') # fmt 确定格式\n",
     "\n",
     "!cat random-matrix.csv"
    ]
@@ -945,19 +945,19 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Numpy's native file format"
+    "### Numpy 的本地文件格式"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Useful when storing and reading back numpy array data. Use the functions `numpy.save` and `numpy.load`:"
+    "当存储和读取numpy数组时非常有用。利用函数`numpy.save`和`numpy.load`："
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [
     {
@@ -976,18 +976,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[0.85030715, 0.33330859, 0.64002838],\n",
-       "       [0.52521743, 0.21572812, 0.33287991],\n",
-       "       [0.74605429, 0.35134767, 0.45873422]])"
+       "array([[0.73171836, 0.46544202, 0.72372739],\n",
+       "       [0.32390603, 0.09679475, 0.95467059],\n",
+       "       [0.36051701, 0.78361037, 0.00716923]])"
       ]
      },
-     "execution_count": 51,
+     "execution_count": 37,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1000,12 +1000,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## More properties of the numpy arrays"
+    "## 更多Numpy数组的性质"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
@@ -1019,12 +1019,12 @@
    ],
    "source": [
     "print(M.dtype)\n",
-    "print(M.itemsize) # bytes per element\n"
+    "print(M.itemsize) # 每个元素的字节数\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
@@ -1033,18 +1033,18 @@
        "72"
       ]
      },
-     "execution_count": 53,
+     "execution_count": 39,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "M.nbytes # number of bytes"
+    "M.nbytes # 字节数"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [
     {
@@ -1053,39 +1053,39 @@
        "2"
       ]
      },
-     "execution_count": 54,
+     "execution_count": 40,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "M.ndim # number of dimensions"
+    "M.ndim # 维度"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Manipulating arrays"
+    "## 操作数组"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Indexing"
+    "### 索引"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can index elements in an array using square brackets and indices:"
+    "我们可以用方括号和下标索引元素："
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
@@ -1094,35 +1094,35 @@
        "1"
       ]
      },
-     "execution_count": 55,
+     "execution_count": 41,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "v = np.array([1, 2, 3, 4, 5])\n",
-    "# v is a vector, and has only one dimension, taking one index\n",
+    "# v 是一个向量，仅仅只有一维，取一个索引\n",
     "v[0]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.21572812491445392\n",
-      "0.21572812491445392\n",
-      "[0.52521743 0.21572812 0.33287991]\n"
+      "0.09679474636543184\n",
+      "0.09679474636543184\n",
+      "[0.32390603 0.09679475 0.95467059]\n"
      ]
     }
    ],
    "source": [
     "\n",
-    "# M is a matrix, or a 2 dimensional array, taking two indices \n",
+    "# M 是一个矩阵或者是一个二维的数组，取两个索引 \n",
     "print(M[1,1])\n",
     "print(M[1][1])\n",
     "print(M[1])"
@@ -1132,23 +1132,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we omit an index of a multidimensional array it returns the whole row (or, in general, a N-1 dimensional array) "
+    "如果我们省略了一个多维数组的索引，它将会返回整行（或者，总的来说，一个 N-1 维的数组）"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[0.85030715, 0.33330859, 0.64002838],\n",
-       "       [0.52521743, 0.21572812, 0.33287991],\n",
-       "       [0.74605429, 0.35134767, 0.45873422]])"
+       "array([[0.73171836, 0.46544202, 0.72372739],\n",
+       "       [0.32390603, 0.09679475, 0.95467059],\n",
+       "       [0.36051701, 0.78361037, 0.00716923]])"
       ]
      },
-     "execution_count": 57,
+     "execution_count": 43,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1159,16 +1159,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([0.52521743, 0.21572812, 0.33287991])"
+       "array([0.32390603, 0.09679475, 0.95467059])"
       ]
      },
-     "execution_count": 58,
+     "execution_count": 44,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1181,59 +1181,59 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The same thing can be achieved with using `:` instead of an index: "
+    "相同的事情可以利用`:`而不是索引来实现："
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([0.52521743, 0.21572812, 0.33287991])"
+       "array([0.32390603, 0.09679475, 0.95467059])"
       ]
      },
-     "execution_count": 59,
+     "execution_count": 45,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "M[1,:] # row 1"
+    "M[1,:] # 行 1"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 60,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([0.33330859, 0.21572812, 0.35134767])"
+       "array([0.46544202, 0.09679475, 0.78361037])"
       ]
      },
-     "execution_count": 60,
+     "execution_count": 46,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "M[:,1] # column 1"
+    "M[:,1] # 列 1"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can assign new values to elements in an array using indexing:"
+    "我们可以用索引赋新的值给数组中的元素:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1242,18 +1242,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[1.        , 0.33330859, 0.64002838],\n",
-       "       [0.52521743, 0.21572812, 0.33287991],\n",
-       "       [0.74605429, 0.35134767, 0.45873422]])"
+       "array([[1.        , 0.46544202, 0.72372739],\n",
+       "       [0.32390603, 0.09679475, 0.95467059],\n",
+       "       [0.36051701, 0.78361037, 0.00716923]])"
       ]
      },
-     "execution_count": 62,
+     "execution_count": 48,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1264,29 +1264,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# also works for rows and columns\n",
+    "# 对行和列也同样有用\n",
     "M[1,:] = 0\n",
     "M[:,2] = -1"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[ 1.        ,  0.85499268, -1.        ],\n",
+       "array([[ 1.        ,  0.46544202, -1.        ],\n",
        "       [ 0.        ,  0.        , -1.        ],\n",
-       "       [ 0.55448257,  0.53279085, -1.        ]])"
+       "       [ 0.36051701,  0.78361037, -1.        ]])"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 50,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1299,19 +1299,19 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Index slicing"
+    "### 切片索引"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Index slicing is the technical name for the syntax `M[lower:upper:step]` to extract part of an array:"
+    "切片索引是语法`M[lower:upper:step]`的技术名称，用于提取数组的一部分："
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [
     {
@@ -1320,7 +1320,7 @@
        "array([1, 2, 3, 4, 5])"
       ]
      },
-     "execution_count": 65,
+     "execution_count": 51,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1332,7 +1332,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 52,
    "metadata": {},
    "outputs": [
     {
@@ -1341,7 +1341,7 @@
        "array([2, 3])"
       ]
      },
-     "execution_count": 66,
+     "execution_count": 52,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1354,12 +1354,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Array slices are *mutable*: if they are assigned a new value the original array from which the slice was extracted is modified:"
+    "切片索引是*可变的*: 如果它们被分配了一个新值，那么从其中提取切片的原始数组将被修改：\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 53,
    "metadata": {},
    "outputs": [
     {
@@ -1368,7 +1368,7 @@
        "array([ 1, -2, -3,  4,  5])"
       ]
      },
-     "execution_count": 67,
+     "execution_count": 53,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1384,12 +1384,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "我们可以省略`M[lower:upper:step]`中任意的三个值\n",
     "We can omit any of the three parameters in `M[lower:upper:step]`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 54,
    "metadata": {},
    "outputs": [
     {
@@ -1398,18 +1399,18 @@
        "array([ 1, -2, -3,  4,  5])"
       ]
      },
-     "execution_count": 68,
+     "execution_count": 54,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "A[::] # lower, upper, step all take the default values"
+    "A[::] # lower, upper, step 都取默认值"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 69,
+   "execution_count": 55,
    "metadata": {},
    "outputs": [
     {
@@ -1418,7 +1419,7 @@
        "array([ 1, -2, -3,  4,  5])"
       ]
      },
-     "execution_count": 69,
+     "execution_count": 55,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1429,7 +1430,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 56,
    "metadata": {},
    "outputs": [
     {
@@ -1438,18 +1439,18 @@
        "array([ 1, -3,  5])"
       ]
      },
-     "execution_count": 70,
+     "execution_count": 56,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "A[::2] # step is 2, lower and upper defaults to the beginning and end of the array"
+    "A[::2] # step is 2, lower and upper 代表数组的开始和结束"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [
     {
@@ -1458,18 +1459,18 @@
        "array([ 1, -2, -3])"
       ]
      },
-     "execution_count": 71,
+     "execution_count": 57,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "A[:3] # first three elements"
+    "A[:3] # 前3个元素"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": 58,
    "metadata": {},
    "outputs": [
     {
@@ -1478,25 +1479,25 @@
        "array([4, 5])"
       ]
      },
-     "execution_count": 72,
+     "execution_count": 58,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "A[3:] # elements from index 3"
+    "A[3:] # 从索引3开始的元素"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Negative indices counts from the end of the array (positive index from the begining):"
+    "负索引计数从数组的结束(正索引从开始):"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1505,7 +1506,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 74,
+   "execution_count": 60,
    "metadata": {},
    "outputs": [
     {
@@ -1514,18 +1515,18 @@
        "5"
       ]
      },
-     "execution_count": 74,
+     "execution_count": 60,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "A[-1] # the last element in the array"
+    "A[-1] # 数组中最后一个元素"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": 61,
    "metadata": {},
    "outputs": [
     {
@@ -1534,25 +1535,25 @@
        "array([3, 4, 5])"
       ]
      },
-     "execution_count": 75,
+     "execution_count": 61,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "A[-3:] # the last three elements"
+    "A[-3:] # 最后三个元素"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Index slicing works exactly the same way for multidimensional arrays:"
+    "索引切片的工作方式与多维数组完全相同:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 76,
+   "execution_count": 62,
    "metadata": {},
    "outputs": [
     {
@@ -1565,7 +1566,7 @@
        "       [40, 41, 42, 43, 44]])"
       ]
      },
-     "execution_count": 76,
+     "execution_count": 62,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1578,7 +1579,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 77,
+   "execution_count": 63,
    "metadata": {},
    "outputs": [
     {
@@ -1589,19 +1590,19 @@
        "       [31, 32, 33]])"
       ]
      },
-     "execution_count": 77,
+     "execution_count": 63,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# a block from the original array\n",
+    "# 原始数组中的一个块\n",
     "A[1:4, 1:4]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [
     {
@@ -1612,13 +1613,13 @@
        "       [40, 42, 44]])"
       ]
      },
-     "execution_count": 63,
+     "execution_count": 64,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# strides\n",
+    "# 步长\n",
     "A[::2, ::2]"
    ]
   },
@@ -1626,19 +1627,19 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Fancy indexing"
+    "### 花式索引"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Fancy indexing is the name for when an array or list is used in-place of an index: "
+    "Fancy索引是一个名称时，一个数组或列表被使用在一个索引:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 78,
+   "execution_count": 65,
    "metadata": {},
    "outputs": [
     {
@@ -1664,7 +1665,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 79,
+   "execution_count": 66,
    "metadata": {},
    "outputs": [
     {
@@ -1673,13 +1674,13 @@
        "array([11, 22, 34])"
       ]
      },
-     "execution_count": 79,
+     "execution_count": 66,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "col_indices = [1, 2, -1] # remember, index -1 means the last element\n",
+    "col_indices = [1, 2, -1] # 索引-1 代表最后一个元素\n",
     "A[row_indices, col_indices]"
    ]
   },
@@ -1687,12 +1688,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can also use index masks: If the index mask is an Numpy array of data type `bool`, then an element is selected (True) or not (False) depending on the value of the index mask at the position of each element: "
+    "我们也可以使用索引掩码:如果索引掩码是一个数据类型`bool`的Numpy数组，那么一个元素被选择(True)或不(False)取决于索引掩码在每个元素位置的值:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 80,
+   "execution_count": 67,
    "metadata": {},
    "outputs": [
     {
@@ -1701,7 +1702,7 @@
        "array([0, 1, 2, 3, 4])"
       ]
      },
-     "execution_count": 80,
+     "execution_count": 67,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1713,7 +1714,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 81,
+   "execution_count": 68,
    "metadata": {},
    "outputs": [
     {
@@ -1722,7 +1723,7 @@
        "array([0, 2])"
       ]
      },
-     "execution_count": 81,
+     "execution_count": 68,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1734,7 +1735,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 82,
+   "execution_count": 69,
    "metadata": {},
    "outputs": [
     {
@@ -1743,13 +1744,13 @@
        "array([0, 2])"
       ]
      },
-     "execution_count": 82,
+     "execution_count": 69,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# same thing\n",
+    "# 相同的事情\n",
     "row_mask = array([1,0,1,0,0], dtype=bool)\n",
     "B[row_mask]"
    ]
@@ -1758,12 +1759,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This feature is very useful to conditionally select elements from an array, using for example comparison operators:"
+    "这个特性对于有条件地从数组中选择元素非常有用，例如使用比较运算符:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 84,
+   "execution_count": 70,
    "metadata": {},
    "outputs": [
     {
@@ -1773,7 +1774,7 @@
        "       6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])"
       ]
      },
-     "execution_count": 84,
+     "execution_count": 70,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1785,7 +1786,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 86,
+   "execution_count": 71,
    "metadata": {},
    "outputs": [
     {
@@ -1796,7 +1797,7 @@
        "       False, False])"
       ]
      },
-     "execution_count": 86,
+     "execution_count": 71,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1809,7 +1810,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 87,
+   "execution_count": 72,
    "metadata": {},
    "outputs": [
     {
@@ -1818,7 +1819,7 @@
        "array([5.5, 6. , 6.5, 7. ])"
       ]
      },
-     "execution_count": 87,
+     "execution_count": 72,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1829,7 +1830,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 92,
+   "execution_count": 73,
    "metadata": {},
    "outputs": [
     {
@@ -1838,7 +1839,7 @@
        "array([3.5, 4. , 4.5, 5. , 5.5])"
       ]
      },
-     "execution_count": 92,
+     "execution_count": 73,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1851,7 +1852,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Functions for extracting data from arrays and creating arrays"
+    "## 用于从数组中提取数据和创建数组的函数"
    ]
   },
   {
@@ -1865,12 +1866,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The index mask can be converted to position index using the `where` function"
+    "索引掩码可以使用`where`函数转换为位置索引"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 76,
    "metadata": {},
    "outputs": [
     {
@@ -1879,7 +1880,7 @@
        "(array([11, 12, 13, 14]),)"
       ]
      },
-     "execution_count": 47,
+     "execution_count": 76,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1892,7 +1893,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 75,
    "metadata": {},
    "outputs": [
     {
@@ -1901,13 +1902,13 @@
        "array([5.5, 6. , 6.5, 7. ])"
       ]
      },
-     "execution_count": 48,
+     "execution_count": 75,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "x[indices] # this indexing is equivalent to the fancy indexing x[mask]"
+    "x[indices] # 这个索引等同于花式索引x[mask]"
    ]
   },
   {
@@ -1921,7 +1922,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "With the diag function we can also extract the diagonal and subdiagonals of an array:"
+    "使用diag函数，我们还可以提取一个数组的对角线和亚对角线:"
    ]
   },
   {
@@ -1975,7 +1976,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The `take` function is similar to fancy indexing described above:"
+    "`take` 函数和上面描述的花式索引类似"
    ]
   },
   {
@@ -2017,7 +2018,7 @@
    ],
    "source": [
     "row_indices = [1, 3, 5]\n",
-    "v2[row_indices] # fancy indexing"
+    "v2[row_indices] # 花式索引"
    ]
   },
   {
@@ -2044,7 +2045,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "But `take` also works on lists and other objects:"
+    "但是`take`也作用在列表和其他的物体上："
    ]
   },
   {
@@ -2078,7 +2079,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Constructs an array by picking elements from several arrays:"
+    "通过从几个数组中选择元素来构造一个数组:"
    ]
   },
   {
@@ -2108,28 +2109,28 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Linear algebra"
+    "## 线性代数"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Vectorizing code is the key to writing efficient numerical calculation with Python/Numpy. That means that as much as possible of a program should be formulated in terms of matrix and vector operations, like matrix-matrix multiplication."
+    "向量化代码是使用Python/Numpy编写高效数值计算的关键。这意味着尽可能多的程序应该用矩阵和向量运算来表示，比如矩阵-矩阵乘法。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Scalar-array operations"
+    "### Scalar-array 操作"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers."
+    "我们可以使用常用的算术运算符来对标量数组进行乘、加、减和除运算。"
    ]
   },
   {
@@ -2213,14 +2214,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Element-wise array-array operations"
+    "### 数组间的元素操作"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "When we add, subtract, multiply and divide arrays with each other, the default behaviour is **element-wise** operations:"
+    "当我们对数组进行加法、减法、乘法和除法时，默认的行为是**element-wise**操作："
    ]
   },
   {
@@ -2243,7 +2244,7 @@
    "source": [
     "A = np.random.rand(2, 3)\n",
     "\n",
-    "A * A # element-wise multiplication"
+    "A * A # element-wise 乘法"
    ]
   },
   {
@@ -2270,7 +2271,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:"
+    "如果我们用兼容的形状进行数组的乘法，我们会得到每一行的对位相乘结果："
    ]
   },
   {
@@ -2318,14 +2319,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Matrix algebra"
+    "### 矩阵代数"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "What about matrix mutiplication? There are two ways. We can either use the `dot` function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments: "
+    "那么矩阵的乘法呢?有两种方法。我们可以使用点函数，它对两个参数应用矩阵-矩阵、矩阵-向量或内向量乘法"
    ]
   },
   {
@@ -2399,7 +2400,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Alternatively, we can cast the array objects to the type `matrix`. This changes the behavior of the standard arithmetic operators `+, -, *` to use matrix algebra."
+    "另外，我们可以将数组对象投到`matrix`类型上。这将改变标准算术运算符`+, -, *` 的行为，以使用矩阵代数。"
    ]
   },
   {
@@ -2501,7 +2502,7 @@
     }
    ],
    "source": [
-    "# inner product\n",
+    "# 內积\n",
     "v.T * v"
    ]
   },
@@ -2526,7 +2527,7 @@
     }
    ],
    "source": [
-    "# with matrix objects, standard matrix algebra applies\n",
+    "# 对于矩阵对象，适用标准的矩阵代数\n",
     "v + M*v"
    ]
   },
@@ -2534,7 +2535,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we try to add, subtract or multiply objects with incomplatible shapes we get an error:"
+    "如果我们尝试用不相配的矩阵形状加，减或者乘我们会得到错误："
    ]
   },
   {
@@ -2594,23 +2595,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "See also the related functions: `inner`, `outer`, `cross`, `kron`, `tensordot`. Try for example `help(kron)`."
+    "同样了解相关的函数：`inner`, `outer`, `cross`, `kron`, `tensordot`。例如用`help(kron)`。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Array/Matrix transformations"
+    "### 数组/矩阵转换"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Above we have used the `.T` to transpose the matrix object `v`. We could also have used the `transpose` function to accomplish the same thing. \n",
+    "同样我们也用`.T`对矩阵目标`v`进行转置。我们也可以利用`transpose`函数去实现同样的事情。\n",
     "\n",
-    "Other mathematical functions that transform matrix objects are:"
+    "变换矩阵对象的其他数学函数有:"
    ]
   },
   {
@@ -2685,7 +2686,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Hermitian conjugate: transpose + conjugate"
+    "厄米共轭:转置+共轭"
    ]
   },
   {
@@ -2713,7 +2714,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can extract the real and imaginary parts of complex-valued arrays using `real` and `imag`:"
+    "我们可以将复数数组的实部和虚部提取出来并用`real`和`imag`来表示:"
    ]
   },
   {
@@ -2762,7 +2763,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Or the complex argument and absolute value"
+    "或者说复数和绝对值"
    ]
   },
   {
@@ -2811,14 +2812,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Matrix computations"
+    "### 矩阵计算"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Inverse"
+    "#### 求逆"
    ]
   },
   {
@@ -2867,7 +2868,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Determinant"
+    "#### 行列式"
    ]
   },
   {
@@ -2914,16 +2915,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Data processing"
+    "### 数据处理"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Often it is useful to store datasets in Numpy arrays. Numpy provides a number of functions to calculate statistics of datasets in arrays. \n",
+    "通常将数据集存储在Numpy数组中是非常有用的。Numpy提供了许多函数用于计算数组中数据集的统计。\n",
     "\n",
-    "For example, let's calculate some properties from the Stockholm temperature dataset used above."
+    "例如，让我们从上面使用的斯德哥尔摩温度数据集计算一些属性。"
    ]
   },
   {
@@ -2943,7 +2944,7 @@
     }
    ],
    "source": [
-    "# reminder, the tempeature dataset is stored in the data variable:\n",
+    "# 提醒一下，温度数据集存储在数据变量中:\n",
     "np.shape(data)"
    ]
   },
@@ -2978,7 +2979,7 @@
     }
    ],
    "source": [
-    "# the temperature data is in column 3\n",
+    "# 温度数据在第三列中\n",
     "print(data.shape)\n",
     "np.mean(data[:,3])"
    ]
@@ -3008,14 +3009,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The daily mean temperature in Stockholm over the last 200 years has been about 6.2 C."
+    "在过去的200年里，斯德哥尔摩每天的平均气温大约是6.2 C。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### standard deviations and variance"
+    "#### 标准差和方差"
    ]
   },
   {
@@ -3042,7 +3043,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### min and max"
+    "#### 最小值和最大值"
    ]
   },
   {
@@ -3062,7 +3063,7 @@
     }
    ],
    "source": [
-    "# lowest daily average temperature\n",
+    "# 最低日平均温度\n",
     "data[:,3].min()"
    ]
   },
@@ -3083,7 +3084,7 @@
     }
    ],
    "source": [
-    "# highest daily average temperature\n",
+    "# 最高日平均温度\n",
     "data[:,3].max()"
    ]
   },
@@ -3132,7 +3133,7 @@
     }
    ],
    "source": [
-    "# sum up all elements\n",
+    "# 将所有的元素相加\n",
     "np.sum(d)"
    ]
   },
@@ -3153,7 +3154,7 @@
     }
    ],
    "source": [
-    "# product of all elements\n",
+    "# 全元素积分\n",
     "np.prod(d+1)"
    ]
   },
@@ -3174,7 +3175,7 @@
     }
    ],
    "source": [
-    "# cummulative sum\n",
+    "# 累计求和\n",
     "np.cumsum(d)"
    ]
   },
@@ -3196,7 +3197,7 @@
     }
    ],
    "source": [
-    "# cummulative product\n",
+    "# 累计成绩\n",
     "np.cumprod(d+1)"
    ]
   },
@@ -3217,7 +3218,7 @@
     }
    ],
    "source": [
-    "# same as: diag(A).sum()\n",
+    "# 计算对角线元素的和，和diag(A).sum()一样\n",
     "np.trace(A)"
    ]
   },
@@ -3225,16 +3226,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Computations on subsets of arrays"
+    "### 数组子集的计算"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can compute with subsets of the data in an array using indexing, fancy indexing, and the other methods of extracting data from an array (described above).\n",
+    "我们可以使用索引、花式索引和从数组中提取数据的其他方法(如上所述)来计算数组中的数据子集。\n",
     "\n",
-    "For example, let's go back to the temperature dataset:"
+    "例如，让我们回到温度数据集:"
    ]
   },
   {
@@ -3260,9 +3261,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The dataformat is: year, month, day, daily average temperature, low, high, location.\n",
+    "数据集的格式是：年，月，日，日平均气温，低，高，位置。\n",
     "\n",
-    "If we are interested in the average temperature only in a particular month, say February, then we can create a index mask and use it to select only the data for that month using:"
+    "如果我们对某个特定月份的平均温度感兴趣，比如二月，然后我们可以创建一个索引掩码，使用它来选择当月的数据:"
    ]
   },
   {
@@ -3282,7 +3283,7 @@
     }
    ],
    "source": [
-    "np.unique(data[:,1]) # the month column takes values from 1 to 12"
+    "np.unique(data[:,1]) # 列的值从1到12"
    ]
   },
   {
@@ -3318,7 +3319,7 @@
     }
    ],
    "source": [
-    "# the temperature data is in column 3\n",
+    "# 温度数据实在第三行\n",
     "print(np.mean(data[mask_feb,3]))\n",
     "print(np.std(data[mask_feb,3]))"
    ]
@@ -3327,7 +3328,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "With these tools we have very powerful data processing capabilities at our disposal. For example, to extract the average monthly average temperatures for each month of the year only takes a few lines of code: "
+    "有了这些工具，我们就有了非常强大的数据处理能力。例如，提取每年每个月的平均气温只需要几行代码:"
    ]
   },
   {
@@ -3362,14 +3363,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Calculations with higher-dimensional data"
+    "### 高维数据的计算"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "When functions such as `min`, `max`, etc. are applied to a multidimensional arrays, it is sometimes useful to apply the calculation to the entire array, and sometimes only on a row or column basis. Using the `axis` argument we can specify how these functions should behave: "
+    "当例如`min`, `max`等函数应用在高维数组上时，有时将计算应用于整个数组是有用的，而且很多时候有时只基于行或列。用`axis`参数我们可以决定这个函数应该怎样表现："
    ]
   },
   {
@@ -3464,21 +3465,21 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Many other functions and methods in the `array` and `matrix` classes accept the same (optional) `axis` keyword argument."
+    "许多其他的在`array` 和`matrix`类中的函数和方法接受同样（可选的）的关键字参数`axis`"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Reshaping, resizing and stacking arrays"
+    "## 阵列的重塑、调整大小和堆叠"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The shape of an Numpy array can be modified without copying the underlaying data, which makes it a fast operation even for large arrays."
+    "Numpy数组的形状可以被确定而无需复制底层数据，这使得即使对于大型数组也能有较快的操作。"
    ]
   },
   {
@@ -3741,21 +3742,21 @@
     }
    ],
    "source": [
-    "A # now A has not changed, because B's data is a copy of A's, not refering to the same data"
+    "A # 现在A并没有改变，因为B的数值是A的复制，并不指向同样的值。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Adding a new dimension: newaxis"
+    "## 添加新的维度：newaxis"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "With `newaxis`, we can insert new dimensions in an array, for example converting a vector to a column or row matrix:"
+    "有了`newaxis`，我们可以在数组中插入新的维度，例如将一个向量转换为列或行矩阵："
    ]
   },
   {
@@ -3837,7 +3838,7 @@
     }
    ],
    "source": [
-    "# make a column matrix of the vector v\n",
+    "# 做一个向量v的列矩阵\n",
     "v2 = v[:, np.newaxis]\n",
     "print(v.shape)\n",
     "print(v2.shape)\n"
@@ -3860,7 +3861,7 @@
     }
    ],
    "source": [
-    "# column matrix\n",
+    "# 列矩阵\n",
     "v[:,newaxis].shape"
    ]
   },
@@ -3881,7 +3882,7 @@
     }
    ],
    "source": [
-    "# row matrix\n",
+    "# 行矩阵\n",
     "v[newaxis,:].shape"
    ]
   },
@@ -3889,14 +3890,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Stacking and repeating arrays"
+    "## 叠加和重复数组"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Using function `repeat`, `tile`, `vstack`, `hstack`, and `concatenate` we can create larger vectors and matrices from smaller ones:"
+    "利用函数`repeat`, `tile`, `vstack`, `hstack`, 和`concatenate` 我们可以用较小的向量和矩阵来创建更大的向量和矩阵："
    ]
   },
   {
@@ -3942,7 +3943,7 @@
    "source": [
     "print(a)\n",
     "\n",
-    "# repeat each element 3 times\n",
+    "# 重复每一个元素三次\n",
     "np.repeat(a, 3)"
    ]
   },
@@ -3986,7 +3987,7 @@
     }
    ],
    "source": [
-    "# better method\n",
+    "# 更好的方案\n",
     "np.tile(a, (1, 3))"
    ]
   },
@@ -4128,14 +4129,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Copy and \"deep copy\""
+    "## 复制和“深度复制”"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To achieve high performance, assignments in Python usually do not copy the underlaying objects. This is important for example when objects are passed between functions, to avoid an excessive amount of memory copying when it is not necessary (technical term: pass by reference). "
+    "为了获得高性能，Python中的赋值通常不复制底层对象。例如，在函数之间传递对象时，这一点非常重要，以避免不必要时大量的内存复制(技术术语:通过引用传递)。"
    ]
   },
   {
@@ -4167,7 +4168,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# now B is referring to the same array data as A \n",
+    "# 现在B和A指的是同一个数组数据\n",
     "B = A "
    ]
   },
@@ -4189,7 +4190,7 @@
     }
    ],
    "source": [
-    "# changing B affects A\n",
+    "# 改变B影响A\n",
     "B[0,0] = 10\n",
     "\n",
     "B"
@@ -4220,7 +4221,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we want to avoid this behavior, so that when we get a new completely independent object `B` copied from `A`, then we need to do a so-called \"deep copy\" using the function `copy`:"
+    "如果我们想避免这种行为，那么当我们从`A`中复制一个新的完全独立的对象`B`时，我们需要使用函数`copy`来做一个所谓的“深度复制”:"
    ]
   },
   {
@@ -4250,7 +4251,7 @@
     }
    ],
    "source": [
-    "# now, if we modify B, A is not affected\n",
+    "# 现在如果我们改变B，A不受影响\n",
     "B[0,0] = -5\n",
     "\n",
     "B"
@@ -4281,16 +4282,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Iterating over array elements"
+    "## 遍历数组元素"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Generally, we want to avoid iterating over the elements of arrays whenever we can (at all costs). The reason is that in a interpreted language like Python (or MATLAB), iterations are really slow compared to vectorized operations. \n",
+    "通常，我们希望尽可能避免遍历数组元素(不惜一切代价)。原因是在像Python(或MATLAB)这样的解释语言中，迭代与向量化操作相比真的很慢。\n",
     "\n",
-    "However, sometimes iterations are unavoidable. For such cases, the Python `for` loop is the most convenient way to iterate over an array:"
+    "然而，有时迭代是不可避免的。对于这种情况，Python的For循环是最方便的遍历数组的方法:"
    ]
   },
   {
@@ -4348,7 +4349,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "When we need to iterate over each element of an array and modify its elements, it is convenient to use the `enumerate` function to obtain both the element and its index in the `for` loop: "
+    "当我们需要去\n",
+    "当我们需要遍历一个数组的每个元素并修改它的元素时，使用`enumerate`函数可以方便地在`for`循环中获得元素及其索引:"
    ]
   },
   {
@@ -4879,7 +4881,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial_EN.ipynb b/1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial_EN.ipynb
index 09a6b9e..67f52f1 100644
--- a/1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial_EN.ipynb
+++ b/1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial_EN.ipynb
@@ -406,7 +406,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For larger arrays it is inpractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generate arrays of different forms. Some of the more common are:"
+    "For larger arrays it is impractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generate arrays of different forms. Some of the more common are:"
    ]
   },
   {
@@ -4879,7 +4879,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/1_numpy_matplotlib_scipy_sympy/random-matrix.csv b/1_numpy_matplotlib_scipy_sympy/random-matrix.csv
index d8d72f9..7451061 100644
--- a/1_numpy_matplotlib_scipy_sympy/random-matrix.csv
+++ b/1_numpy_matplotlib_scipy_sympy/random-matrix.csv
@@ -1,3 +1,3 @@
-0.85031 0.33331 0.64003
-0.52522 0.21573 0.33288
-0.74605 0.35135 0.45873
+0.73172 0.46544 0.72373
+0.32391 0.09679 0.95467
+0.36052 0.78361 0.00717
diff --git a/1_numpy_matplotlib_scipy_sympy/random-matrix.npy b/1_numpy_matplotlib_scipy_sympy/random-matrix.npy
index ef1604a..60f92b3 100644
Binary files a/1_numpy_matplotlib_scipy_sympy/random-matrix.npy and b/1_numpy_matplotlib_scipy_sympy/random-matrix.npy differ
diff --git a/2_knn/knn_classification_EN.ipynb b/2_knn/knn_classification_EN.ipynb
index b25770c..24b6e46 100644
--- a/2_knn/knn_classification_EN.ipynb
+++ b/2_knn/knn_classification_EN.ipynb
@@ -336,7 +336,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.5"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/5_nn/3-softmax_ce_EN.ipynb b/5_nn/3-softmax_ce_EN.ipynb
index 08a8a3b..d5186cd 100644
--- a/5_nn/3-softmax_ce_EN.ipynb
+++ b/5_nn/3-softmax_ce_EN.ipynb
@@ -4,69 +4,67 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Softmax & 交叉熵代价函数\n"
+    "# Softmax & Cross entropy cost function\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "softmax经常被添加在分类任务的神经网络中的输出层，神经网络的反向传播中关键的步骤就是求导，从这个过程也可以更深刻地理解反向传播的过程，还可以对梯度传播的问题有更多的思考。\n",
+    "Softmax is often added as an output layer in the neural network for sorting tasks, the key process in the backward propagation is derivation. This process can also provide a deeper understanding of the back propagation process and give more thought to the problem of gradient propagation.\n",
     "\n",
-    "## 1. softmax 函数\n",
+    "## 1. softmax function\n",
     "\n",
-    "softmax(柔性最大值)函数，一般在神经网络中， softmax可以作为分类任务的输出层。其实可以认为softmax输出的是几个类别选择的概率，比如我有一个分类任务，要分为三个类，softmax函数可以根据它们相对的大小，输出三个类别选取的概率，并且概率和为1。\n",
+    "Softmax(Flexible maximum) function, usually in neural network, can work as the output layer of classification assignment. Actually we can think of softmax output as the probability of selecting several categories. For example, If I have a classification task that is divided into three classes, the Softmax function can output the probability of the selection of the three classes based on their relative size, and the probability sum is 1.\n",
     "\n",
-    "softmax函数的公式是这种形式：\n",
+    "The form of softmax function is:\n",
     "\n",
     "$$\n",
     "S_i = \\frac{e^{z_i}}{\\sum_k e^{z_k}}\n",
     "$$\n",
     "\n",
-    "* $S_i$是经过softmax的类别概率输出\n",
-    "* $z_k$是神经元的输出\n",
+    "* $S_i$ is the class probability output that pass through the softmax\n",
+    "* $z_k$ is the output of neuron\n",
     "\n",
-    "\n",
-    "更形象的如下图表示：\n",
+    "More vivid expression is shown as the following graph:\n",
     "\n",
     "![softmax_demo](images/softmax_demo.png)\n",
     "\n",
-    "softmax直白来说就是将原来输出是$[3,1,-3]$通过softmax函数一作用，就映射成为(0,1)的值，而这些值的累和为1（满足概率的性质），那么我们就可以将它理解成概率，在最后选取输出结点的时候，我们就可以选取概率最大（也就是值对应最大的）结点，作为我们的预测目标！\n",
-    "\n",
-    "\n",
+    "Softmax straightforward is the original output is $[3, 1, 3] $by softmax function role, is mapping the value of (0, 1), and these values are tired and 1 (meet the properties of probability), then we can understand it into probability, in the final selection of the output nodes, we can choose most probability (that is, value corresponding to the largest) node, as we predict the goal.\n",
+    "softm\n",
     "\n",
-    "首先是神经元的输出，一个神经元如下图：\n",
+    "First is the output of neuron, the following graph shows a neuron:\n",
     "\n",
     "![softmax_neuron](images/softmax_neuron.png)\n",
     "\n",
-    "神经元的输出设为：\n",
+    "we assume that the output of neuron is:\n",
     "\n",
     "$$\n",
     "z_i = \\sum_{j} w_{ij} x_{j} + b\n",
     "$$\n",
     "\n",
-    "其中$W_{ij}$是第$i$个神经元的第$j$个权重，$b$是偏置。$z_i$表示该网络的第$i$个输出。\n",
+    "Among them $W_{ij}$ is the $jth$ weight of $ith$ neuron and $b$ is the bias. $z_i$ represent the $ith$ output of this network.\n",
     "\n",
-    "给这个输出加上一个softmax函数，那就变成了这样：\n",
+    "Add a softmax function to the outpur we have:\n",
     "\n",
     "$$\n",
     "a_i = \\frac{e^{z_i}}{\\sum_k e^{z_k}}\n",
     "$$\n",
     "\n",
-    "$a_i$代表softmax的第$i$个输出值，右侧套用了softmax函数。\n",
+    "$a_i$ represent the $ith$ output value of softmax, while the right side uses softmax function.\n",
     "\n",
     "\n",
-    "### 1.1 损失函数 loss function\n",
+    "### 1.1  loss function\n",
     "\n",
-    "在神经网络反向传播中，要求一个损失函数，这个损失函数其实表示的是真实值与网络的估计值的误差，知道误差了，才能知道怎样去修改网络中的权重。\n",
+    "In the propagation of neural networks, we need to calculate a loss function, this loss function is actually the error between the true value and  the estimation of network. Only when we get the error, it is possible to know how to change the weight in the network.\n",
     "\n",
-    "损失函数可以有很多形式，这里用的是交叉熵函数，主要是由于这个求导结果比较简单，易于计算，并且交叉熵解决某些损失函数学习缓慢的问题。**[交叉熵函数](https://blog.csdn.net/u014313009/article/details/51043064)**是这样的：\n",
+    "There are many form of loss function, what we used here is the cross entropy function, it is mainly because that the derivation reasult is quiet easy and convenient to calculate, and cross entropy can solve some lower learning rate problem**[Cross entropy function](https://blog.csdn.net/u014313009/article/details/51043064)**is this：\n",
     "\n",
     "$$\n",
     "C = - \\sum_i y_i ln a_i\n",
     "$$\n",
     "\n",
-    "其中$y_i$表示真实的分类结果。\n",
+    "Among them $y_i$ represent the truly classification result.\n",
     "\n"
    ]
   },
@@ -74,31 +72,31 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 2. 推导过程\n",
+    "## 2. Derive process\n",
     "\n",
-    "首先，我们要明确一下我们要求什么，我们要求的是我们的$loss$对于神经元输出($z_i$)的梯度，即：\n",
+    "Firstly, we need to make sure what we want, we want to get the gradient of our $loss$ to neuron output($z_i$), which is:\n",
     "\n",
     "$$\n",
     "\\frac{\\partial C}{\\partial z_i}\n",
     "$$\n",
     "\n",
-    "根据复合函数求导法则：\n",
+    "According to the derivation rule of composite function:\n",
     "\n",
     "$$\n",
     "\\frac{\\partial C}{\\partial z_i} = \\frac{\\partial C}{\\partial a_j} \\frac{\\partial a_j}{\\partial z_i}\n",
     "$$\n",
     "\n",
-    "有个人可能有疑问了，这里为什么是$a_j$而不是$a_i$，这里要看一下$softmax$的公式了，因为$softmax$公式的特性，它的分母包含了所有神经元的输出，所以，对于不等于i的其他输出里面，也包含着$z_i$，所有的$a$都要纳入到计算范围中，并且后面的计算可以看到需要分为$i = j$和$i \\ne j$两种情况求导。\n",
+    "Someone may have question, why we have $a_j$ instead of $a_i$. We need to check the formula of $softmax$ here, because of the special characteristcs, its denominatorc contains all the output of neurons. Therefore, for the other output which do not equal to i, it also contains $z_i$, all the $a$ are needed to be included into the calcultaion range and the calcultaion backwards need to be divide into two parts, which is $i = j$ and $i\\ne j$.\n",
     "\n",
-    "### 2.1 针对$a_j$的偏导\n",
+    "### 2.1 The partial derviation of  $a_j$\n",
     "\n",
     "$$\n",
     "\\frac{\\partial C}{\\partial a_j} = \\frac{(\\partial -\\sum_j y_j ln a_j)}{\\partial a_j} = -\\sum_j y_j \\frac{1}{a_j}\n",
     "$$\n",
     "\n",
-    "### 2.2 针对$z_i$的偏导\n",
+    "### 2.2 The partial derviation of $z_i$\n",
     "\n",
-    "如果 $i=j$ :\n",
+    "If $i=j$ :\n",
     "\n",
     "\\begin{eqnarray}\n",
     "\\frac{\\partial a_i}{\\partial z_i} & = & \\frac{\\partial (\\frac{e^{z_i}}{\\sum_k e^{z_k}})}{\\partial z_i} \\\\\n",
@@ -107,7 +105,7 @@
     "  & = & a_i (1 - a_i)\n",
     "\\end{eqnarray}\n",
     "\n",
-    "如果 $i \\ne j$:\n",
+    "IF $i \\ne j$:\n",
     "\\begin{eqnarray}\n",
     "\\frac{\\partial a_j}{\\partial z_i} & = & \\frac{\\partial (\\frac{e^{z_j}}{\\sum_k e^{z_k}})}{\\partial z_i} \\\\\n",
     "  & = &  \\frac{0 \\cdot \\sum_k e^{z_k} - e^{z_j} \\cdot e^{z_i} }{(\\sum_k e^{z_k})^2} \\\\\n",
@@ -115,12 +113,12 @@
     "  & = & -a_j a_i\n",
     "\\end{eqnarray}\n",
     "\n",
-    "当u，v都是变量的函数时的导数推导公式：\n",
+    "When u, v are the dependent variable the derivation formula of derivative:\n",
     "$$\n",
     "(\\frac{u}{v})' = \\frac{u'v - uv'}{v^2} \n",
     "$$\n",
     "\n",
-    "### 2.3 整体的推导\n",
+    "### 2.3 Derivation of the whole\n",
     "\n",
     "\\begin{eqnarray}\n",
     "\\frac{\\partial C}{\\partial z_i} & = & (-\\sum_j y_j \\frac{1}{a_j} ) \\frac{\\partial a_j}{\\partial z_i} \\\\\n",
@@ -135,8 +133,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 3. 问题\n",
-    "如何将本节所讲的softmax，交叉熵代价函数应用到上节所讲的BP方法中？"
+    "## 3. Question\n",
+    "How to apply the softmax, cross entropy cost function in this section to the BP method in the previous section?"
    ]
   },
   {
@@ -168,7 +166,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/0_basic/Tensor-and-Variable.ipynb b/6_pytorch/0_basic/Tensor-and-Variable.ipynb
index 726f6a1..575a0fb 100644
--- a/6_pytorch/0_basic/Tensor-and-Variable.ipynb
+++ b/6_pytorch/0_basic/Tensor-and-Variable.ipynb
@@ -18,10 +18,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 5,
+   "metadata": {},
    "outputs": [],
    "source": [
     "import torch\n",
@@ -30,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -47,10 +45,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 7,
+   "metadata": {},
    "outputs": [],
    "source": [
     "pytorch_tensor1 = torch.Tensor(numpy_tensor)\n",
@@ -80,10 +76,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 8,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# 如果 pytorch tensor 在 cpu 上\n",
@@ -955,7 +949,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/0_basic/autograd.ipynb b/6_pytorch/0_basic/autograd.ipynb
index fec46ec..4041fb6 100644
--- a/6_pytorch/0_basic/autograd.ipynb
+++ b/6_pytorch/0_basic/autograd.ipynb
@@ -35,7 +35,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor([19.], grad_fn=<AddBackward>)\n"
+      "tensor([19.], grad_fn=<AddBackward0>)\n"
      ]
     }
    ],
@@ -92,14 +92,51 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([[-1.5318,  1.5200, -2.1316, -1.3238,  1.0080, -1.0832, -0.2814, -1.0486,\n",
+      "          1.0807, -2.2865,  0.6545, -0.3595,  0.4229, -0.9194,  0.1690, -0.3241,\n",
+      "          1.8970, -0.8979, -0.7827,  0.3879],\n",
+      "        [ 0.1404, -0.8016,  0.1156, -0.8397, -1.8886,  1.1072, -1.0186,  0.2249,\n",
+      "          0.5631,  0.4391,  0.7887, -2.3255, -0.4185,  0.6559,  0.7622,  1.6883,\n",
+      "         -1.4147,  0.2579, -0.6177,  0.2172],\n",
+      "        [-0.4866, -0.0322, -1.2484,  1.1913, -0.6569,  0.0810,  0.2491, -0.1258,\n",
+      "          2.5903, -0.8370, -0.0554,  1.2174,  0.4059, -1.0759,  0.6649,  0.1642,\n",
+      "         -0.3512, -0.7695,  1.1469, -0.3409],\n",
+      "        [ 1.8789, -1.6553, -0.7401, -0.3198, -0.1010, -0.5512, -0.4792, -0.2891,\n",
+      "         -0.2655, -0.8132,  0.7210,  1.0885, -0.9557, -0.4472, -1.5340,  0.8093,\n",
+      "          0.9349,  0.8352, -0.0774, -0.1728],\n",
+      "        [-0.3424,  0.1938, -2.4253, -0.0229,  0.3132, -0.7731,  0.8481, -1.3002,\n",
+      "         -0.1595, -0.0364, -1.5733,  0.8882,  0.1909, -0.1404, -1.5673, -1.1809,\n",
+      "         -0.7169,  0.7074,  0.3337, -1.0738],\n",
+      "        [-0.0501,  1.6210,  0.6854,  0.2216,  0.3034, -1.2762, -0.6216,  1.4884,\n",
+      "          0.6078,  2.1512, -0.7141,  0.4110, -0.8187,  0.9474, -0.5978, -0.2679,\n",
+      "          1.5315, -2.1550,  2.0969, -1.7669],\n",
+      "        [ 1.4505, -0.9497,  2.0269, -1.6402, -0.0047, -0.2716, -0.2727,  0.6795,\n",
+      "         -0.7367, -0.3248, -0.5312,  0.0887, -1.4303, -0.8390,  1.5324,  0.3761,\n",
+      "         -0.4658, -0.2044,  0.3050, -0.2756],\n",
+      "        [ 0.3265, -0.2513,  1.1441,  0.3805, -1.3629, -1.3120, -1.8571,  0.1180,\n",
+      "          0.7466, -0.2654, -0.2154,  1.0603, -0.4113, -2.5965,  1.0736,  1.1610,\n",
+      "          0.8165,  1.5916,  1.5556,  0.3078],\n",
+      "        [-0.4417,  0.1656, -2.1743, -0.1148, -1.2795,  1.0212, -0.7035, -0.8234,\n",
+      "          0.3010, -1.0891, -1.0676,  0.8385, -0.2886, -1.1881,  0.5097, -0.5097,\n",
+      "         -1.7893,  0.0494, -0.0162,  1.5170],\n",
+      "        [-0.6435, -1.8376,  1.0022, -0.0397,  0.7187, -0.0661, -0.8528,  1.3248,\n",
+      "         -0.2566, -2.2886,  0.8728, -0.7152,  1.6180,  0.8416,  0.2788,  0.5515,\n",
+      "         -0.1266, -1.0025,  0.1767, -0.4987]], requires_grad=True)\n"
+     ]
+    }
+   ],
    "source": [
     "x = Variable(torch.randn(10, 20), requires_grad=True)\n",
     "y = Variable(torch.randn(10, 5), requires_grad=True)\n",
     "w = Variable(torch.randn(20, 5), requires_grad=True)\n",
-    "\n",
+    "print(x)\n",
     "out = torch.mean(y - torch.matmul(x, w)) # torch.matmul 是做矩阵乘法\n",
     "out.backward()"
    ]
@@ -113,40 +150,43 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Variable containing:\n",
-      "\n",
-      "Columns 0 to 9 \n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "-0.0600 -0.0242 -0.0514  0.0882  0.0056 -0.0400 -0.0300 -0.0052 -0.0289 -0.0172\n",
-      "\n",
-      "Columns 10 to 19 \n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "-0.0372  0.0144 -0.1074 -0.0363 -0.0189  0.0209  0.0618  0.0435 -0.0591  0.0103\n",
-      "[torch.FloatTensor of size 10x20]\n",
-      "\n"
+      "tensor([[-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177],\n",
+      "        [-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177],\n",
+      "        [-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177],\n",
+      "        [-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177],\n",
+      "        [-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177],\n",
+      "        [-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177],\n",
+      "        [-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177],\n",
+      "        [-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177],\n",
+      "        [-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177],\n",
+      "        [-0.0198, -0.0066, -0.0288,  0.0080,  0.0079, -0.0569, -0.0489,  0.0505,\n",
+      "          0.0132, -0.0072, -0.0024,  0.0400,  0.0691, -0.0273,  0.0124,  0.0104,\n",
+      "          0.0098, -0.0598,  0.0365,  0.0177]])\n"
      ]
     }
    ],
@@ -157,27 +197,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Variable containing:\n",
-      "1.00000e-02 *\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "  2.0000  2.0000  2.0000  2.0000  2.0000\n",
-      "[torch.FloatTensor of size 10x5]\n",
-      "\n"
+      "tensor([[0.0200, 0.0200, 0.0200, 0.0200, 0.0200],\n",
+      "        [0.0200, 0.0200, 0.0200, 0.0200, 0.0200],\n",
+      "        [0.0200, 0.0200, 0.0200, 0.0200, 0.0200],\n",
+      "        [0.0200, 0.0200, 0.0200, 0.0200, 0.0200],\n",
+      "        [0.0200, 0.0200, 0.0200, 0.0200, 0.0200],\n",
+      "        [0.0200, 0.0200, 0.0200, 0.0200, 0.0200],\n",
+      "        [0.0200, 0.0200, 0.0200, 0.0200, 0.0200],\n",
+      "        [0.0200, 0.0200, 0.0200, 0.0200, 0.0200],\n",
+      "        [0.0200, 0.0200, 0.0200, 0.0200, 0.0200],\n",
+      "        [0.0200, 0.0200, 0.0200, 0.0200, 0.0200]])\n"
      ]
     }
    ],
@@ -188,36 +224,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Variable containing:\n",
-      " 0.1342  0.1342  0.1342  0.1342  0.1342\n",
-      " 0.0507  0.0507  0.0507  0.0507  0.0507\n",
-      " 0.0328  0.0328  0.0328  0.0328  0.0328\n",
-      "-0.0086 -0.0086 -0.0086 -0.0086 -0.0086\n",
-      " 0.0734  0.0734  0.0734  0.0734  0.0734\n",
-      "-0.0042 -0.0042 -0.0042 -0.0042 -0.0042\n",
-      " 0.0078  0.0078  0.0078  0.0078  0.0078\n",
-      "-0.0769 -0.0769 -0.0769 -0.0769 -0.0769\n",
-      " 0.0672  0.0672  0.0672  0.0672  0.0672\n",
-      " 0.1614  0.1614  0.1614  0.1614  0.1614\n",
-      "-0.0042 -0.0042 -0.0042 -0.0042 -0.0042\n",
-      "-0.0970 -0.0970 -0.0970 -0.0970 -0.0970\n",
-      "-0.0364 -0.0364 -0.0364 -0.0364 -0.0364\n",
-      "-0.0419 -0.0419 -0.0419 -0.0419 -0.0419\n",
-      " 0.0134  0.0134  0.0134  0.0134  0.0134\n",
-      "-0.0251 -0.0251 -0.0251 -0.0251 -0.0251\n",
-      " 0.0586  0.0586  0.0586  0.0586  0.0586\n",
-      "-0.0050 -0.0050 -0.0050 -0.0050 -0.0050\n",
-      " 0.1125  0.1125  0.1125  0.1125  0.1125\n",
-      "-0.0096 -0.0096 -0.0096 -0.0096 -0.0096\n",
-      "[torch.FloatTensor of size 20x5]\n",
-      "\n"
+      "tensor([[-0.0060, -0.0060, -0.0060, -0.0060, -0.0060],\n",
+      "        [ 0.0405,  0.0405,  0.0405,  0.0405,  0.0405],\n",
+      "        [ 0.0749,  0.0749,  0.0749,  0.0749,  0.0749],\n",
+      "        [ 0.0502,  0.0502,  0.0502,  0.0502,  0.0502],\n",
+      "        [ 0.0590,  0.0590,  0.0590,  0.0590,  0.0590],\n",
+      "        [ 0.0625,  0.0625,  0.0625,  0.0625,  0.0625],\n",
+      "        [ 0.0998,  0.0998,  0.0998,  0.0998,  0.0998],\n",
+      "        [-0.0050, -0.0050, -0.0050, -0.0050, -0.0050],\n",
+      "        [-0.0894, -0.0894, -0.0894, -0.0894, -0.0894],\n",
+      "        [ 0.1070,  0.1070,  0.1070,  0.1070,  0.1070],\n",
+      "        [ 0.0224,  0.0224,  0.0224,  0.0224,  0.0224],\n",
+      "        [-0.0438, -0.0438, -0.0438, -0.0438, -0.0438],\n",
+      "        [ 0.0337,  0.0337,  0.0337,  0.0337,  0.0337],\n",
+      "        [ 0.0952,  0.0952,  0.0952,  0.0952,  0.0952],\n",
+      "        [-0.0258, -0.0258, -0.0258, -0.0258, -0.0258],\n",
+      "        [-0.0494, -0.0494, -0.0494, -0.0494, -0.0494],\n",
+      "        [-0.0063, -0.0063, -0.0063, -0.0063, -0.0063],\n",
+      "        [ 0.0318,  0.0318,  0.0318,  0.0318,  0.0318],\n",
+      "        [-0.0824, -0.0824, -0.0824, -0.0824, -0.0824],\n",
+      "        [ 0.0340,  0.0340,  0.0340,  0.0340,  0.0340]])\n"
      ]
     }
    ],
@@ -250,21 +283,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Variable containing:\n",
-      " 2  3\n",
-      "[torch.FloatTensor of size 1x2]\n",
-      "\n",
-      "Variable containing:\n",
-      " 0  0\n",
-      "[torch.FloatTensor of size 1x2]\n",
-      "\n"
+      "tensor([[2., 3.]], requires_grad=True)\n",
+      "tensor([[0., 0.]])\n"
      ]
     }
    ],
@@ -277,22 +304,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Variable containing:\n",
-      "  4  27\n",
-      "[torch.FloatTensor of size 1x2]\n",
-      "\n"
+      "tensor(2., grad_fn=<SelectBackward>)\n",
+      "tensor([[ 4., 27.]], grad_fn=<CopySlices>)\n"
      ]
     }
    ],
    "source": [
     "# 通过 m 中的值计算新的 n 中的值\n",
+    "print(m[0,0])\n",
     "n[0, 0] = m[0, 0] ** 2\n",
     "n[0, 1] = m[0, 1] ** 3\n",
     "print(n)"
@@ -336,7 +362,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -345,17 +371,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Variable containing:\n",
-      "  4  27\n",
-      "[torch.FloatTensor of size 1x2]\n",
-      "\n"
+      "tensor([[ 4., 27.]])\n"
      ]
     }
    ],
@@ -541,10 +564,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 38,
+   "metadata": {},
    "outputs": [],
    "source": [
     "x = Variable(torch.FloatTensor([2, 3]), requires_grad=True)\n",
@@ -556,34 +577,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# k.backward(torch.ones_like(k)) \n",
+    "# print(x.grad)\n",
+    "# 和上一个的区别在于该算法是求得导数和，并不是分布求解。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Variable containing:\n",
-      " 13\n",
-      " 13\n",
-      "[torch.FloatTensor of size 2]\n",
-      "\n"
+      "tensor([13., 13.], grad_fn=<CopySlices>)\n"
      ]
     }
    ],
    "source": [
-    "print(k)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
     "j = torch.zeros(2, 2)\n",
-    "\n",
     "k.backward(torch.FloatTensor([1, 0]), retain_graph=True)\n",
+    "print(k)\n",
     "j[0] = x.grad.data\n",
     "\n",
     "x.grad.data.zero_() # 归零之前求得的梯度\n",
@@ -594,6 +613,23 @@
   },
   {
    "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([13., 13.], grad_fn=<CopySlices>)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(k)"
+   ]
+  },
+  {
+   "cell_type": "code",
    "execution_count": 9,
    "metadata": {},
    "outputs": [
@@ -637,7 +673,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/0_basic/dynamic-graph.ipynb b/6_pytorch/0_basic/dynamic-graph.ipynb
index 6669abd..69b304b 100644
--- a/6_pytorch/0_basic/dynamic-graph.ipynb
+++ b/6_pytorch/0_basic/dynamic-graph.ipynb
@@ -5,7 +5,7 @@
    "metadata": {},
    "source": [
     "# 动态图和静态图\n",
-    "目前神经网络框架分为静态图框架和动态图框架，PyTorch 和 TensorFlow、Caffe 等框架最大的区别就是他们拥有不同的计算图表现形式。 TensorFlow 使用静态图，这意味着我们先定义计算图，然后不断使用它，而在 PyTorch 中，每次都会重新构建一个新的计算图。通过这次课程，我们会了解静态图和动态图之间的优缺点。\n",
+    "目前神经网络框架分为[静态图框架和动态图框架](https://blog.csdn.net/qq_36653505/article/details/87875279)，PyTorch 和 TensorFlow、Caffe 等框架最大的区别就是他们拥有不同的计算图表现形式。 TensorFlow 使用静态图，这意味着我们先定义计算图，然后不断使用它，而在 PyTorch 中，每次都会重新构建一个新的计算图。通过这次课程，我们会了解静态图和动态图之间的优缺点。\n",
     "\n",
     "对于使用者来说，两种形式的计算图有着非常大的区别，同时静态图和动态图都有他们各自的优点，比如动态图比较方便debug，使用者能够用任何他们喜欢的方式进行debug，同时非常直观，而静态图是通过先定义后运行的方式，之后再次运行的时候就不再需要重新构建计算图，所以速度会比动态图更快。"
    ]
@@ -33,10 +33,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 15,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# tensorflow\n",
@@ -48,10 +46,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 16,
+   "metadata": {},
    "outputs": [],
    "source": [
     "def cond(first_counter, second_counter, *args):\n",
@@ -65,7 +61,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -74,27 +70,42 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "RuntimeError",
+     "evalue": "The Session graph is empty.  Add operations to the graph before calling run().",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-21-430d26a59053>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mv1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSession\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0msess\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mcounter_1_res\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounter_2_res\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msess\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mc1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/.local/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m    956\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    957\u001b[0m       result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0;32m--> 958\u001b[0;31m                          run_metadata_ptr)\n\u001b[0m\u001b[1;32m    959\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    960\u001b[0m         \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1104\u001b[0m       \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Attempted to use a closed Session.'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1105\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mversion\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1106\u001b[0;31m       raise RuntimeError('The Session graph is empty.  Add operations to the '\n\u001b[0m\u001b[1;32m   1107\u001b[0m                          'graph before calling run().')\n\u001b[1;32m   1108\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mRuntimeError\u001b[0m: The Session graph is empty.  Add operations to the graph before calling run()."
+     ]
+    }
+   ],
    "source": [
-    "with tf.Session() as sess:\n",
+    "with tf.compat.v1.Session() as sess:\n",
     "    counter_1_res, counter_2_res = sess.run([c1, c2])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "20\n",
-      "20\n"
+     "ename": "NameError",
+     "evalue": "name 'counter_1_res' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-19-62b1e84b7d43>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcounter_1_res\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcounter_2_res\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'counter_1_res' is not defined"
      ]
     }
    ],
@@ -197,7 +208,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/0_basic/ref_Autograd.ipynb b/6_pytorch/0_basic/ref_Autograd.ipynb
index 533fab6..703dd93 100644
--- a/6_pytorch/0_basic/ref_Autograd.ipynb
+++ b/6_pytorch/0_basic/ref_Autograd.ipynb
@@ -1546,7 +1546,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/1_NN/1-linear-regression-gradient-descend.ipynb b/6_pytorch/1_NN/1-linear-regression-gradient-descend.ipynb
index 6868f4b..d67b05e 100644
--- a/6_pytorch/1_NN/1-linear-regression-gradient-descend.ipynb
+++ b/6_pytorch/1_NN/1-linear-regression-gradient-descend.ipynb
@@ -128,7 +128,7 @@
     {
      "data": {
       "text/plain": [
-       "<torch._C.Generator at 0x7f53f805ecd0>"
+       "<torch._C.Generator at 0x7fe12f897d50>"
       ]
      },
      "execution_count": 7,
@@ -168,7 +168,7 @@
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f539410ee48>]"
+       "[<matplotlib.lines.Line2D at 0x7fe128232198>]"
       ]
      },
      "execution_count": 9,
@@ -177,7 +177,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -200,7 +200,15 @@
    "cell_type": "code",
    "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([2.2691], requires_grad=True)\n"
+     ]
+    }
+   ],
    "source": [
     "# 转换成 Tensor\n",
     "x_train = torch.from_numpy(x_train)\n",
@@ -208,7 +216,8 @@
     "\n",
     "# 定义参数 w 和 b\n",
     "w = Variable(torch.randn(1), requires_grad=True) # 随机初始化\n",
-    "b = Variable(torch.zeros(1), requires_grad=True) # 使用 0 进行初始化"
+    "b = Variable(torch.zeros(1), requires_grad=True) # 使用 0 进行初始化\n",
+    "print(w)"
    ]
   },
   {
@@ -249,7 +258,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7f53940f2320>"
+       "<matplotlib.legend.Legend at 0x7fe0b1174cc0>"
       ]
      },
      "execution_count": 13,
@@ -258,7 +267,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -315,7 +324,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor(153.3520, grad_fn=<MeanBackward1>)\n"
+      "tensor(153.3520, grad_fn=<MeanBackward0>)\n"
      ]
     }
    ],
@@ -392,7 +401,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7f53940bc438>"
+       "<matplotlib.legend.Legend at 0x7fe0b08e7cc0>"
       ]
      },
      "execution_count": 19,
@@ -401,7 +410,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -428,31 +437,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "epoch: 0, loss: 3.135772228240967\n",
-      "epoch: 1, loss: 0.355089008808136\n",
-      "epoch: 2, loss: 0.30295446515083313\n",
-      "epoch: 3, loss: 0.30131959915161133\n",
-      "epoch: 4, loss: 0.3006228804588318\n",
-      "epoch: 5, loss: 0.2999469041824341\n",
-      "epoch: 6, loss: 0.299274742603302\n",
-      "epoch: 7, loss: 0.2986060082912445\n",
-      "epoch: 8, loss: 0.2979407012462616\n",
-      "epoch: 9, loss: 0.29727888107299805\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:11: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n",
-      "  # This is added back by InteractiveShellApp.init_path()\n"
+      "tensor(0.2934)\n",
+      "epoch: 0, loss: 0.2933782935142517\n",
+      "tensor(0.2927)\n",
+      "epoch: 1, loss: 0.29273974895477295\n",
+      "tensor(0.2921)\n",
+      "epoch: 2, loss: 0.29210466146469116\n",
+      "tensor(0.2915)\n",
+      "epoch: 3, loss: 0.2914726436138153\n",
+      "tensor(0.2908)\n",
+      "epoch: 4, loss: 0.29084399342536926\n",
+      "tensor(0.2902)\n",
+      "epoch: 5, loss: 0.2902185022830963\n",
+      "tensor(0.2896)\n",
+      "epoch: 6, loss: 0.28959622979164124\n",
+      "tensor(0.2890)\n",
+      "epoch: 7, loss: 0.28897714614868164\n",
+      "tensor(0.2884)\n",
+      "epoch: 8, loss: 0.28836125135421753\n",
+      "tensor(0.2877)\n",
+      "epoch: 9, loss: 0.2877485454082489\n"
      ]
     }
    ],
@@ -464,30 +475,30 @@
     "    w.grad.zero_() # 记得归零梯度\n",
     "    b.grad.zero_() # 记得归零梯度\n",
     "    loss.backward()\n",
-    "    \n",
+    "    print(loss.data)\n",
     "    w.data = w.data - 1e-2 * w.grad.data # 更新 w\n",
     "    b.data = b.data - 1e-2 * b.grad.data # 更新 b \n",
-    "    print('epoch: {}, loss: {}'.format(e, loss.data[0]))"
+    "    print('epoch: {}, loss: {}'.format(e, loss.item()))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7f53942d5550>"
+       "<matplotlib.legend.Legend at 0x7fe0b086b978>"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -975,7 +986,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/1_NN/2-logistic-regression.ipynb b/6_pytorch/1_NN/2-logistic-regression.ipynb
index f865ed9..bbbe8c0 100644
--- a/6_pytorch/1_NN/2-logistic-regression.ipynb
+++ b/6_pytorch/1_NN/2-logistic-regression.ipynb
@@ -113,7 +113,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -126,16 +126,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<torch._C.Generator at 0x7f089c0fccb0>"
+       "<torch._C.Generator at 0x7fd3e0d2dd20>"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -156,22 +156,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fb05e2923c8>"
+       "<matplotlib.legend.Legend at 0x7fd36236a860>"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAH7RJREFUeJzt3X2MXNWZ5/HvY2Nj9Y4TwO6RIrdd3Vk5GwxBm7jNZCJlE4VlcZisvUlGI6BhgyYTh2xIRtpMFCIIioxayaxWMwpadiXnZWLcHRDLHyuPhsWMBlC0Uci6Ea82gRgP2O2MlE6b7IYELy959o9bDdXlerlddV/Ouff3kUquun1cdereW8899znnnmvujoiIVMuqsisgIiLZU3AXEakgBXcRkQpScBcRqSAFdxGRClJwFxGpIAV3EZEKUnAXEakgBXcRkQo6p6wP3rhxo4+Pj5f18SIiUXr00Ud/6e6j/cqVFtzHx8eZm5sr6+NFRKJkZi+mKae0jIhIBSm4i4hUkIK7iEgFKbiLiFSQgruISAX1De5m9j0z+4WZPd3l72Zmt5vZMTN70szel301MzQ7C+PjsGpV8u/sbNk1EhHJXJqW+/eBnT3+/lFga/OxB/hvw1crJ7OzsGcPvPgiuCf/7tmjAC8ildM3uLv7D4HTPYrsBu70xCPAeWb2jqwqmKmbb4bf/nb5st/+NlkuIlIhWeTcNwEnW17PN5edxcz2mNmcmc0tLCxk8NErdOLEypaLiESq0A5Vd9/n7pPuPjk62vfq2ext2bKy5RlRmr+etN2lTFkE91PA5pbXY81l4ZmehpGR5ctGRpLlOVGav5603aVsWQT3g8C/b46aeT/wf9z9nzJ43+xNTcG+fdBogFny7759yfKcKM1fnjJbztruUrY0QyHvAn4M/AszmzezT5vZDWZ2Q7PIfcBx4BjwbeA/5FbbLExNwQsvwO9+l/ybY2AHpfmL1BrMN26EP/3T8lrOMWx3pY0qzt1LeWzfvt3roNFwT8LL8kejUXbNqmVmxn1kpPO6LmO9D7rdZ2aSMmbJvzMz+dSv0/oaGcnv8yQ7wJyniLG6QjVnJaT5a6lTGqSTolrOg2z3IvP0ShtVX3WDeyDnnCWk+WspbdDOeWDUmwbZ7kUG3BjSRjIcS1r5xZucnPTcbtax1ARq/aWMjCiqVtj4eNLS7SX0XWDVqqTF3s4s6SLKUrf11WgkXVESLjN71N0n+5WrZstd55y10ykNsmYNbNgQzxlTkZdhKF1YfdUM7jrnrJ1OaZC/+Rv45S8LGxg1tCIDrtKF1VfNtIzOOSVSs7PJCeaJE0mLfXpaAVeWq3daRuecEqmCL8OQCqtmcNc5p4jUXDWDO6gJJEEKZISu1MA5ZVdApC7aR+guXaQEantI9qrbchcJjEboSpEU3EUKEtMIXaWP4qfgLlKQku4Vs2Kai74aFNxFChLLCF2lj6pBwV2kILGM0O2WJuo3d4+ERcFdpEAxjNDtliYyU2omJgruIpHLuvNzejoJ5O3clZqJiYK7SMTy6Pycmuo89TCEObJHOlNwF4nQUmv92mvz6fxsNDovD21kj3SXKrib2U4ze9bMjpnZTR3+3jCzfzCzJ83sYTMby76qEgONj85fa2u9m2Fb2LGM7JHu+gZ3M1sN3AF8FNgGXG1m29qK/WfgTne/BNgLfCPrikr4ND66GGnuFztsCzuWkT3SXZqW+6XAMXc/7u6vAncDu9vKbAMebD5/qMPfpWBltKA1ProY/VrlWbWwYxjZ00+dzyTTBPdNwMmW1/PNZa2eAD7RfP5xYL2ZbRi+ejKIslrQMV1eH7NerXK1sN9S9zPJrDpU/wL4kJk9BnwIOAW80V7IzPaY2ZyZzS0sLGT00dKurBZ0LJfXx65bPnxmJt4Wdh7qfiaZJrifAja3vB5rLnuTu//c3T/h7u8Fbm4u+1X7G7n7PnefdPfJ0dHRIaotvZTVglYnXDF65cPrnIZo/+7dOpxrcybp7j0fJHO+HwcmgLUkKZiL2spsBFY1n08De/u97/bt210SMzPujYa7WfLvzMxw79douCcnossfjcbwde0n6+8i6c3MuI+MLN/mIyP12AadvrtZeb+DPAFz3ie+evJVUxSCK4HngOeBm5vL9gK7ms//GPhZs8x3gHP7vaeCeyKPH2Sdf+R1VuZBvWzdvnt7gM/zd1BUwybT4J7HQ8E9kdcPUi3o+unWUjUru2b56/bdl35Lef8OimxQpQ3ulpQt3uTkpM/NzZXy2SFZtarzpd5myRA06W52NukcO3Ei6bSdnq53Z2K3PHOjkXS0VlnZ373IzzezR919sl85TT9QMo0wGUzdh7m1WupIfPHFsyf8qkuHdtmd+SEOA1ZwL1nZO2WsQhzmVsZIlfapCNzfCvB1GvNe9hW1QTbS0uRu8ngo5/4W5cdXLrT8clmd2HXuRA2Jcu4tlHOXYZSdY21XZH1a+xq6/XzVZ1O8ovqAlHOXSgstnVVUzrW9r6Eb9dkUL7S5eBTcJUpl51jbFZVzTTMjpPpsBBTcJWIhtZSKOpPodSYQwkFOwnFO2RUQqYKlYJp3znXLlrD6GiRcarmLZKSIM4nQ+hokXAruIhEJra9BwqW0jEhkpqYUzKU/tdxFRCpIwV1EpIIU3EVEKkjBXWqtzrelk2pTh6rU1tKl/EtXfC5NGwzqsJT4qeUutRXitMEiWVFwl9oK8QYLIllRcJfaCvIGCyIZSRXczWynmT1rZsfM7KYOf99iZg+Z2WNm9qSZXZl9VUWypUv5pcr6BnczWw3cAXwU2AZcbWbb2ordAtzj7u8FrgL+a9YVrSwN1yiNLuWXKkvTcr8UOObux939VeBuYHdbGQfe1nz+duDn2VWxwnSX59KFMG2wju+ShzTBfRNwsuX1fHNZq68D15rZPHAf8IVMald1Gq5Rezq+S16y6lC9Gvi+u48BVwIHzOys9zazPWY2Z2ZzCwsLGX30EMpuMmm4RunK3gV0fJe8pAnup4DNLa/HmstafRq4B8DdfwysAza2v5G773P3SXefHB0dHazGWQmhyaThGqUKYRfQ8V3ykia4Hwa2mtmEma0l6TA92FbmBHAZgJldSBLcA2ia9xBCk0nDNUoVwi6g43s4yj6Ly1rf4O7urwM3AoeAZ0hGxRwxs71mtqtZ7EvAZ8zsCeAu4Hr3XvdmD0AITSYN1yhVCLuAju9hCOEsLnPuXspj+/btXqpGwz3ZjssfjUa59ZLChLILzMwkn2mW/DszU+znDyrWencSyr6QBjDnKWJsfa9QzbPJVLXzu4oKpdUcwnDMlapaSzeEs7jMpTkC5PEoveXunk/TY2bGfWRk+eF/ZCSaZk2IrbE86xTi941BTC3dNGL6PqRsudc7uOchpr2kTYjHpRDrVDWDHODMOu/mZnnXNh8x7WcK7r3k2VyLeK8P8bgUYp2qZNCgVsXtEstZXNrgbknZ4k1OTvrc3FzxH9x+hwZIEq1ZjVIZH08SkO0ajSShGrBVq5KfaDuzJB9chhDrVCWD7q55/4ykOzN71N0n+5WrX4dq3oObQ+mlG0CIY65DrFOVDNqRqFG84atfcM+7WzzivT7E41KIdaqSbgfJVav6D/aKcZRPraTJ3eTxKC3nXsVkYYZCzDuGWKeq6JRzb3+E2rFYVyjn3oWShSLLzM4mWckTJ5LW+htvnF0mgi6j2lDOvZs0aRNdhBQNbarhtaZXunVSR30xT03Vr+Xej1r20ei0qdauhfXr4fTpJJ88Pa3NthIRD/aqDbXcBxXCVIGSSqdN9eqrsLhYjUviy6AO7HwVeaap4N6ukpNMVFOaTaLj8spEPNgreEXPx6O0TDudl0aj26ZqpwueJARZhRalZQaV9Xmpevxy02lTdaILniQERScFFNzbZXleWrV5UQPTvqk2bIA1a5aXUb5YQlH01dZKy+RJKZ7CtY7Z1mgZCUlWA/GUlgmBOmcLp0viz6bMYBiK7qxWcM+TZr0qXdUC20q/T9Uyg7Fvz0IbH2nmKAB2As8Cx4CbOvz9r4HHm4/ngF/1e8/K3qyjVUx3AEghtjleKrb6B/o+VZpKqWrbc1BkdbMOYDXwPPBOYC3wBLCtR/kvAN/r9761CO7u8UXELmL8YVUpsLkP9n0ivnfMWaq2PQeVNrinSctcChxz9+Pu/ipwN7C7R/mrgbtWdPpQZRVJAsd44W7VujwG+T7dMoDu8aU1Qt6evdJFZaWSzklRZhNwsuX1PPAHnQqaWQOYAB4cvmoSkpB/WN1s2dJ5sFKsXR6DfJ/p6bNHaCxZyr9DHG2OULdn+yiY1vUK3f+W9zrPukP1KuBed+8waSiY2R4zmzOzuYWFhYw/WvIUY99w1eZJGeT7tI7Q6CT0s69WoW7PXme1pZ7x9svbAH8IHGp5/VXgq13KPgZ8IE0+qDY594qIMefuXpkujzcN832qkH8PcXv2Wq95rHOyulmHmZ1DMgLmMuAUcBi4xt2PtJV7N3A/MOH93pSaXMRUMbpAKG66pi4fvdYrZL/OM7uIyd1fB24EDgHPAPe4+xEz22tmu1qKXgXcnSawS5wq0jdcW6GmNWLXa72Wus7TNO/zeCgtI1K8ENMaVdBrvWa9ztE9VCtIeZFgaFNIWdKmZdIMhZQQ9BpvpahSKG0KiYHmlolFjFcRVZQ2RRhin2cmbwrusYjxKqKK0qYoX14TolXpgKHgnoUi9ogYryKqKG2K8uVx9lS1GTQV3IdV1B4R+Ti2KrWIIt8UlZDH2VPl0m1phtTk8ajMUMgip6qLdBxbrFe39hLppqiMPH52sVzBi4ZCFmTVqmQfaGeWXO0jujJSMpfVLetaxbKf6jZ7RVECti91QErW8rhlXdXSbQruw6raHpEDHf8kD1lPh1H0PU7zpuA+rKrtEb0M2Cuq45/EokrzJ+kK1SxMTcW9F6QxxGWZS3/W5foixVGHqqQTS2+TSMWpQ1WypV5RkagouEs66hUViYqCu6SjXlGRqCi4Szp1GhXURZWmUJDilLXfKLhLekvjxA4cSF5fd11tolzVJpWSYpS539Q7uKsptnI1jXKVm1RKClHmflPf4F7TIHWWlR7gahrlNFhIBlHmfpMquJvZTjN71syOmdlNXcr8iZkdNbMjZvaDbKuZg5oGqWUGOcDltLeGfhKlwUIyiFL3m37TRgKrgeeBdwJrgSeAbW1ltgKPAec3X/9+v/ctfcrfWOb3zNMg86bmMNdqDFMCx1BHCU8e+w0pp/xN03K/FDjm7sfd/VXgbmB3W5nPAHe4+0vNA8Yvhj3o5E5NscFa4TkMiYzhJEqDhWQQZe43aYL7JuBky+v55rJW7wLeZWY/MrNHzGxnVhXMjcZtD3aAy2FvjSWfXaVJpaQ4Ze03WXWonkOSmvkwcDXwbTM7r72Qme0xszkzm1tYWMjoowekptjgB7iM91adRIlkL01wPwVsbnk91lzWah446O6vufs/As+RBPtl3H2fu0+6++To6Oigdc5O3ZtigRzgdBIlkr00wf0wsNXMJsxsLXAVcLCtzP8gabVjZhtJ0jTHM6yn5CWAA1wgxxiRSukb3N39deBG4BDwDHCPux8xs71mtqtZ7BCwaGZHgYeAL7v7Yl6VluoJ4BgjBQl92GtVaD53ESlMHje2rhvN515lavpI4LrtojEMe60K3WYvNkPc7k6kCL120ViGvVaB0jKx0e3uJHC9dlHQ7jsspWWqSk0fCVyvXVTDXouj4B4bXfEjgeu1i2rYa3EU3GOjpo8Ert8uqmGvxVBwj42aPhI47aJhUIeqiEhE1KEqIlJjCu4iIhWk4C4iUkEK7iIZ0+wQEgIFd8lPDaPcIPccF8mDgntd5R14Q4lyBR9gNDGWhEJDIeuoiHlXQ5gDp4T5ZVetSo5l7cySi3ZEhpV2KKSCex0VEXhDiHIlHGBCOKZJtWmcu3RXxORjIcyBU8Ika5odQkKh4F5HRQTeEKJcCQcYXXovoVBwr6MiAm/ZUW52Fl5++ezlBRxgNDGWhEDBvY56Bd4sR5eUFeWWOlIX2+7RvmGDmtFSG6mCu5ntNLNnzeyYmd3U4e/Xm9mCmT3efPxZ9lWlluOmc9Mp8IYyfHFYncYjAvze7ymwS230HS1jZquB54DLgXngMHC1ux9tKXM9MOnuN6b94BWPltFt0/NXlaEeIYzUEclJlqNlLgWOuftxd38VuBvYPWwFV0xXh+Sv2yiSTgE/ZCGM1BEpWZrgvgk42fJ6vrms3SfN7Ekzu9fMNnd6IzPbY2ZzZja3sLCwsprq3qH56xb8zOJKzYQwUqemlDkNR1Ydqn8LjLv7JcDfA/s7FXL3fe4+6e6To6OjK/sEtcbyNz2dBPJ27nGdIZU9UqemqtJlUxVpcu5/CHzd3a9ovv4qgLt/o0v51cBpd397r/dVzj1QnYL70nLlq6WHqnTZhC7LnPthYKuZTZjZWuAq4GDbh72j5eUu4JmVVDYVtcaK0Wh0Xq4zpCgVmSZR5jQsfYO7u78O3AgcIgna97j7ETPba2a7msW+aGZHzOwJ4IvA9bnUNs9x00oWJpSvroyi0yTKnAbG3Ut5bN++3YMxM+M+MuKe/AaSx8hIsryOZmbcGw13s+Tfz31u+eu6rpdu2tdXIOun0Vi+Sy89Go18Pk8/o2IAc54ixiq4uxf/K4iJfrG9lbh++h1TzDrv1mbl1UmGlza4a8pf0EUvvaiXrLeS1k+a8QXadNWkKX9XQsnCzmZnu1/ApF6yREm9iGmu6VP3yeCq0AWn4A76FXSy1DTspu4HviUlNQzSHFPqMMAsjyBcmfH6aXI3eTyCyrm7K1nYrls/hHLuy5WUc1c3UX6rPvR1izpUZSjdeuNAgb1dCQ2DvI8pMbR18grCZXREr0Ta4K4OVelMvXHBm51NcuwnTiRZoOnpbFIusVwMntc4iNB3/ep2qGaRZKtCb0ne1A8RvLyu6YtlAta8ujsqs+unad7n8RgoLZPFuajGbacXw7m5ZC7LtESeu1CeP+WQd30qmXNfaZKt0xYKvbdEpGRZ/USKaEe1/sQ3bEgeIQbkLFUzuK+kSdFtz+rWSRhKb4nEIeSm3ZCyCspFtqPqdEJezeC+kr2lW9nVq9Vyr5IygmwNIkmq1dqnUJGjTup0Ql7N4L6SH1WvoXwV/2HWRllBtk6RpJsU677I1RT68MUsVTO4u6dvqfXasyp8Sl0rZQXZOkWSblKs+yKPvXU63lY3uKdVg1Pn2isryIYQScpuoKRc90VVs04/dwV39/J/AJKvsoJs2ZGk7M93D+MA16YuP3cFd6m+ooNcKOPuQgisIRxgaiptcI/vClWRJUVOe9g+VeDiIrzyChw4kP0tH/sJ4WalU1PwqU/B6tXJ69Wrk9chzU9Qc5pbRiSNkCYcCaEusUxAU0Fp55ZJFdzNbCfwLWA18B13/2aXcp8E7gV2uHvPyN0puL/22mvMz89z5syZvnWKwbp16xgbG2PNmjVlV0WGFdLdukIIrCEcYGoqbXA/J8UbrQbuAC4H5oHDZnbQ3Y+2lVsP/Dnwk8GqDPPz86xfv57x8XHMbNC3CYK7s7i4yPz8PBMTE2VXR4a1ZUvnYFbGTUuWAngeU0KmFUJqSHpKk3O/FDjm7sfd/VXgbmB3h3K3AX8JDNzsPnPmDBs2bIg+sAOYGRs2bKjMWUjmYpuZM7SpAvOaEjIt3ZoyeGmC+ybgZMvr+eayN5nZ+4DN7v53w1aoCoF9SZW+S6ZivI9ZHe5ZtxKhHexWKrbGxQCGHi1jZquAvwK+lKLsHjObM7O5hYWFYT9aYhXLhOHtym4thyTmg12MjYsBpAnup4DNLa/HmsuWrAcuBh42sxeA9wMHzeyshL+773P3SXefHB0dHbzWS0o8+u7fv5+tW7eydetW9u/fX9jnVoLytdUQ68FukMZFjC39fgPhSTpdjwMTwFrgCeCiHuUfBib7vW+ni5iOHj2afiR/iRdRLC4u+sTEhC8uLvrp06d9YmLCT58+3bHsir5TXYRwEY7U10qnrQjsgi2yuojJ3V8HbgQOAc8A97j7ETPba2a78jjgpJLDqf3hw4e55JJLOHPmDL/5zW+46KKLePrpp88qd+jQIS6//HIuuOACzj//fC6//HLuv//+gT+3dmLP10rcVtoZHGkase9QSAB3vw+4r23ZrV3Kfnj4aqWQw6n9jh072LVrF7fccguvvPIK1157LRdffPFZ5U6dOsXmzW9lqsbGxjh16tRZ5aSLEIbySX1NT3e+TqBb4yLSNGKq4B6knMYd33rrrezYsYN169Zx++23D/Ve0sPUlIK5lGOljYuQrnFYgXjnlsnp1H5xcZGXX36ZX//6113HqG/atImTJ98aHTo/P8+mTZs6lhWRAK2kMzjSNGK8wT2noVif/exnue2225iamuIrX/lKxzJXXHEFDzzwAC+99BIvvfQSDzzwAFdcccVQnysigYp02Ge8aRnI/NT+zjvvZM2aNVxzzTW88cYbfOADH+DBBx/kIx/5yLJyF1xwAV/72tfYsWMHkKRyLrjggszqISKBiTCNGNSskM888wwXXnhhKfXJSxW/00BmZ9WBKpKBzCYOExla+yyGS1cEggK8SE4U3Ht46qmnuO6665YtO/fcc/nJTwae+LKeeo0TVnAXyYWCew/vec97ePzxx8uuRvwiHScsErN4R8tIPDQ9rEjhFNwlf5GOExaJmYK75C/SccIiMVPOXYoR4ThhkZhF3XIvc4rlnTt3ct555/Gxj32suA8VEUkp2uBe9s1UvvzlL3PgwIFiPkxEZIWiDe55TLGcdj53gMsuu4z169cP/mEiIjmKNueex9DptPO5i4iELtrgntcUy5rPXUSqINq0TF5Dp9PM5y4iErpog3teQ6fTzOcuEoQyh4tJ8KJNy0D2Q6fTzucO8MEPfpCf/vSnvPzyy4yNjfHd735XN+yQ4mimTekj1XzuZrYT+BawGviOu3+z7e83AJ8H3gBeBva4+9Fe76n53EWGMD7eudOp0UhuGyeVlXY+975pGTNbDdwBfBTYBlxtZtvaiv3A3d/j7v8S+E/AXw1QZxFJSzNtSh9p0jKXAsfc/TiAmd0N7AbebJm7+/9tKf/PgHJu75QxzecuwcpruJhURprgvgk42fJ6HviD9kJm9nngPwJrgbOT1BHSfO4SrOnp5Tl30Eybskxmo2Xc/Q53/+fAV4BbOpUxsz1mNmdmcwsLC93eJ6sqla5K30UCo5k2pY80wf0UsLnl9VhzWTd3A/+u0x/cfZ+7T7r75Ojo6Fl/X7duHYuLi5UIiu7O4uIi69atK7sqUlVTU0nn6e9+l/yrwC4t0qRlDgNbzWyCJKhfBVzTWsDMtrr7z5ov/wj4GQMYGxtjfn6ebq362Kxbt46xsbGyqyEiNdQ3uLv762Z2I3CIZCjk99z9iJntBebc/SBwo5n9a+A14CXgU4NUZs2aNUxMTAzyX0VEpEWqi5jc/T7gvrZlt7Y8//OM6yUiIkOIdvoBERHpTsFdRKSCUk0/kMsHmy0AHa7CSGUj8MsMq5OnmOoKcdU3prqC6punmOoKw9W34e5nDzdsU1pwH4aZzaWZWyEEMdUV4qpvTHUF1TdPMdUViqmv0jIiIhWk4C4iUkGxBvd9ZVdgBWKqK8RV35jqCqpvnmKqKxRQ3yhz7iIi0lusLXcREekh6OBuZjvN7FkzO2ZmN3X4+w1m9pSZPW5m/6vDTUQK06+uLeU+aWZuZqX27KdYt9eb2UJz3T5uZn9WRj2bdem7bs3sT8zsqJkdMbMfFF3Htrr0W7d/3bJenzOzX5VRz2Zd+tV1i5k9ZGaPmdmTZnZlGfVsqU+/+jbM7B+adX3YzEqb3MnMvmdmvzCzp7v83czs9uZ3edLM3pdpBdw9yAfJPDbPA+8kmSP+CWBbW5m3tTzfBdwfal2b5dYDPwQeASYDX7fXA/8lkv1gK/AYcH7z9e+HXN+28l8gma8pyLqS5IY/13y+DXgh5HUL/HfgU83nHwEOlFjffwW8D3i6y9+vBP4nYMD7gZ9k+fkht9zfvAOUu79KMpXw7tYCHs4doPrWtek24C+BM0VWroO09Q1Bmrp+BrjD3V8CcPdfFFzHVitdt1cDdxVSs7OlqasDb2s+fzvw8wLr1y5NfbcBDzafP9Th74Vx9x8Cp3sU2Q3c6YlHgPPM7B1ZfX7Iwb3THaA2tRcys8+b2fMk9279YkF1a9e3rs1Trs3u/ndFVqyLVOsW+GTzdPFeM9vc4e9FSFPXdwHvMrMfmdkjzRu6lyXtusXMGsAEbwWjoqWp69eBa81snmTywC8UU7WO0tT3CeATzecfB9ab2YYC6jaI1PvKIEIO7ql4ijtAlc3MVpHcNPxLZddlBf4WGHf3S4C/B/aXXJ9eziFJzXyYpCX8bTM7r9QapXMVcK+7v1F2RXq4Gvi+u4+RpBEONPfnUP0F8CEzewz4EMk9KEJev7kJeSNldgeoAvSr63rgYuBhM3uBJL92sMRO1b7r1t0X3f3/NV9+B9heUN3apdkP5oGD7v6au/8j8BxJsC/DSvbbqygvJQPp6vpp4B4Ad/8xsI5kXpQypNlvf+7un3D39wI3N5eV1mHdx0pj3MqU1dmQojPiHOA4yWnrUufJRW1ltrY8/7ckNw8Jsq5t5R+m3A7VNOv2HS3PPw48EnBddwL7m883kpzqbgi1vs1y7wZeoHmtSah1Jenwu775/EKSnHspdU5Z343AqubzaWBvWeu3WYdxuneo/hHLO1T/d6afXeYXT7FiriRphT0P3NxcthfY1Xz+LeAI8DhJ50nXgFp2XdvKlhrcU67bbzTX7RPNdfvugOtqJGmvo8BTwFUhr9vm668D3yyzninX7TbgR8394HHg3wRe3z8muc3ncyRnnOeWWNe7gH8iuUPdPMlZ0A3ADc2/G3BH87s8lXVM0BWqIiIVFHLOXUREBqTgLiJSQQruIiIVpOAuIlJBCu4iIhWk4C4iUkEK7iIiFaTgLiJSQf8fr3/Tekz1AzcAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -187,7 +187,6 @@
     "with open('./data.txt', 'r') as f:\n",
     "    data_list = [i.split('\\n')[0].split(',') for i in f.readlines()]\n",
     "    data = [(float(i[0]), float(i[1]), float(i[2])) for i in data_list]\n",
-    "\n",
     "# 标准化\n",
     "x0_max = max([i[0] for i in data])\n",
     "x1_max = max([i[1] for i in data])\n",
@@ -215,13 +214,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [],
    "source": [
     "np_data = np.array(data, dtype='float32') # 转换成 numpy array\n",
-    "x_data = torch.from_numpy(np_data[:, 0:2]) # 转换成 Tensor, 大小是 [100, 2]\n",
-    "y_data = torch.from_numpy(np_data[:, -1]).unsqueeze(1) # 转换成 Tensor，大小是 [100, 1]"
+    "x_data = torch.from_numpy(np_data[:, 0:2]) # 转换成 Tensor, 大小是 [100, 2]\n"
    ]
   },
   {
@@ -237,7 +235,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -255,22 +253,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fb05e21e0b8>]"
+       "[<matplotlib.lines.Line2D at 0x7fd3622d7588>]"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAcAElEQVR4nO3deZhU5Zn38e8tqygKCLIjOIKRZIxLS6KOr/oqCkRB4wbRuKFMiDhxXEYdHTVqriSS10QnGkTFuLPE6RYQLlTUMVFRGiKoINK4NsqiIiIGmpb7/eOp1rKppqubqnpq+X2u61xVdc7Tfe4+ffj14TnLY+6OiIgUvp1iFyAiIpmhQBcRKRIKdBGRIqFAFxEpEgp0EZEi0TLWijt37ux9+/aNtXoRkYK0YMGCj929S6pl0QK9b9++VFZWxlq9iEhBMrP3GlqmLhcRkSKhQBcRKRIKdBGRIqFAFxEpEgp0EZEi0Wigm9kkM1tjZq83sNzM7HYzqzKzxWZ2UObLFBGRxqRzhP5nYMh2lg8F+iemMcCfdrwsERFpqkavQ3f3582s73aajAAe8PAc3nlm1sHMurv7RxmqUUSKlTts3px62rQJamqgtha++ir1tL1lX30FW7eGddRNdets6rymfl39n7G+E0+EQw7J7LYkMzcW9QQ+SPpcnZi3TaCb2RjCUTx9+vTJwKpFJJraWvjkE/j4Y1i7NrzWvV+3DjZs2Hb64ovw+uWXIbC3bIn9U+SG2bc/9+iRt4GeNnefCEwEKCsr08gaIvnMHaqrYelSeOsteP/9MH3wQXj98MNwBJzKrrtC+/bfTLvuCr16ffO5XTto0yZMbdt+8z55atsWWreGli2hRYttp4bmJ0877RTCNHmC5s1rytdFkolAXwn0TvrcKzFPRArF5s2weDHMnw+vvAKvvw5vvgkbN37Tpk0b6N0b+vSBY44J77t1gy5doHPnb1732CMEseRcJgJ9OjDOzCYDPwDWq/9cJM/V1MBLL8FTT8HcubBwYZgHsOee8P3vw+jRsN9+Ydp3X+jaNfoRqGxfo4FuZo8CRwGdzawauB5oBeDuE4BZwDCgCvgSOC9bxYrIDtiwAWbMgGnTQpBv3Bi6JQ45BH7xCxg0KEy9eyu4C1Q6V7mMamS5AxdlrCIRyZytW+HJJ2HiRJg1K3St9OwJ554LgwfDUUfB7rvHrlIyJNrjc0Ukiz7/HCZMCNM774T+7X/9Vzj9dDj00HCyUIqOAl2kmHz6Kdx+O9x2G3z2GRx5JPz613DSSeGkphQ1BbpIMaipgTvugF/+EtavDwF+7bVw8MGxK5McUqCLFLqnn4Zx42DZMjj+eLjlFth//9hVSQTqSBMpVBs2hH7xwYPDyc+ZM2H2bIV5CdMRukghevllGDkS3nsPrrgCbrwx3FkpJU1H6CKFxD1cuXLEEeHz3/4WulgU5oICXaRwbNkCF14IY8eGW+8XLIDDDotdleQRBbpIIdi4EUaMgHvvhWuuCf3lnTrFrkryjPrQRfLdp5/C0KFQWQl33QVjxsSuSPKUAl0kn61fD8cdF55++Nhj4fpykQYo0EXy1YYN4ch88WIoL4cf/Sh2RZLnFOgi+WjLFjj55PBs8mnTFOaSFgW6SL5xD1eyzJ0L998fgl0kDbrKRSTf/O534WqWa6+Fs8+OXY0UEAW6SD6ZMweuvBLOOCM8aEukCRToIvli5Uo46yz43vdg0iQ9s1yaTHuMSD6orYVRo+Af/wgnQdu1i12RFCCdFBXJBzfdBH/9Kzz0UBiQWaQZdIQuEtvChfCrX8E558CZZ8auRgqYAl0kppqaMGBz167w+9/HrkYKnLpcRGK6+WZ47bXwsK2OHWNXIwVOR+gisSxZEgZw/ulPdSeoZIQCXSQGd7j4YmjfHm69NXY1UiTU5SISw7Rp8MwzcOed0Llz7GqkSOgIXSTXvvgCLrsMDjhAzzaXjNIRukiu3XILVFfD5MnQokXsaqSI6AhdJJdWrw595qefDocfHrsaKTIKdJFcuvlm2LQp3BkqkmEKdJFcefvtMCbo6NEwYEDsaqQIKdBFcuW660Kf+fXXx65EilRagW5mQ8xsmZlVmdlVKZb3MbNnzezvZrbYzIZlvlSRArZsGTzySLj2vEeP2NVIkWo00M2sBXAHMBQYCIwys4H1ml0LTHX3A4GRwJ2ZLlSkoP3mN9CmTbhcUSRL0jlCHwRUufvb7l4DTAZG1GvjwG6J97sDH2auRJEC99574bG4F14YHsIlkiXpBHpP4IOkz9WJecluAM4ys2pgFnBxqm9kZmPMrNLMKteuXduMckUK0PjxYAZXXBG7EilymTopOgr4s7v3AoYBD5rZNt/b3Se6e5m7l3Xp0iVDqxbJY6tWwT33hMGee/eOXY0UuXQCfSWQvCf2SsxLNhqYCuDuLwFtAT2gQuS222DLFrhqm2sJRDIunUCfD/Q3s35m1ppw0nN6vTbvA8cAmNl+hEBXn4qUti+/DNedn3wy7LNP7GqkBDQa6O5eC4wD5gBLCVezvGFmN5rZ8ESzy4ALzWwR8Chwrrt7tooWKQgPPgjr1sEll8SuREqExcrdsrIyr6ysjLJukaxzh+9+F3beGSorw0lRkQwwswXuXpZqmZ62KJINTz0FS5fCAw8ozCVndOu/SDb84Q/QrVt4qqJIjijQRTKtqgpmz4axY8PdoSI5okAXybS77w4P4brwwtiVSIlRoItkUk0N3HcfnHgidO8euxopMQp0kUx6/HFYu1ZjhUoUCnSRTJo4Efr0geOOi12JlCAFukimrFgBTz8NF1ygwZ8lCgW6SKbccw/stBOcf37sSqREKdBFMqG2NpwMPeEE6Fn/6dIiuaFAF8mEJ5+E1avhvPNiVyIlTIEukgkPPAB77AHDNJyuxKNAF9lR69dDRQWMHAmtW8euRkqYAl1kR/3lL7B5M/z0p7ErkRKnQBfZUQ88AAMGwKBBsSuREqdAF9kR774Lzz8fxgzVY3IlMgW6yI546KHweuaZcesQQYEu0nzuobvlyCOhb9/Y1Ygo0EWabeFCWL5cR+eSNxToIs01ZQq0bAmnnBK7EhFAgS7SPO4wdSoMHgydOsWuRgRQoIs0z8svw3vvwRlnxK5E5GsKdJHmmDo13BU6YkTsSkS+pkAXaaqtW0OgH388dOgQuxqRrynQRZrqxRdh5Up1t0jeUaCLNNWUKdC2LQwfHrsSkW9RoIs0xVdfhYdxDRsG7dvHrkbkWxToIk3x17/CqlXqbpG8pEAXaYpp02DnneFHP4pdicg2FOgi6dq6FR5/HIYMgV12iV2NyDbSCnQzG2Jmy8ysysyuaqDN6Wa2xMzeMLNHMlumSB5YsCBc3XLyybErEUmpZWMNzKwFcAcwGKgG5pvZdHdfktSmP3A1cLi7rzOzPbNVsEg0FRXQooW6WyRvpXOEPgiocve33b0GmAzUvz3uQuAOd18H4O5rMlumSB6oqAiPytWzWyRPpRPoPYEPkj5XJ+YlGwAMMLMXzGyemQ1J9Y3MbIyZVZpZ5dq1a5tXsUgMb70FS5bASSfFrkSkQZk6KdoS6A8cBYwC7jazbe6JdveJ7l7m7mVdunTJ0KpFcqCiIrzq2S2Sx9IJ9JVA76TPvRLzklUD0919i7u/A7xFCHiR4lBRAQcdBH36xK5EpEHpBPp8oL+Z9TOz1sBIYHq9NhWEo3PMrDOhC+btDNYpEs9HH8G8ebq6RfJeo4Hu7rXAOGAOsBSY6u5vmNmNZlb3MIs5wCdmtgR4FrjC3T/JVtEiOTVjRhjQQv3nkufM3aOsuKyszCsrK6OsW6RJhg0LJ0WXLwez2NVIiTOzBe5elmqZ7hQV2Z7PP4e5c8PRucJc8pwCXWR7Zs+Gmhp1t0hBUKCLbE9FBey5Jxx6aOxKRBqlQBdpyObN8MQTYSCLFi1iVyPSKAW6SEOeew42bFB3ixQMBbpIQyoqwmNyjzkmdiUiaVGgi6RS9+zzoUPD+KEiBUCBLpLKK6+EO0TV3SIFRIEukkpFBbRsqWefS0FRoIukUlEBRx8NHbZ5aKhI3lKgi9T35puwbJm6W6TgKNBF6isvD6/Dh2+/nUieUaCL1FdRAYccAr16xa5EpEkU6CLJVq4MV7jo2edSgBToIsmmJ8ZuUf+5FCAFukiyigoYMAC+853YlYg0mQJdpM5nn8Ezz+jZ51KwFOgidWbNgtpadbdIwVKgi9SpqIBu3eAHP4hdiUizKNBFADZtCqMTjRgBO+mfhRQm7bkiEPrOv/hC3S1S0BToIhDuDm3fPjy/RaRAKdBFvvoqXH8+bBi0aRO7GpFmU6CLvPQSrFmju0Ol4CnQRcrLoXXrMDqRSAFToEtpcw+BfuyxsNtusasR2SEKdCltr70G77yjq1ukKCjQpbSVl4fb/PXscykCCnQpbeXlcPjh0LVr7EpEdpgCXUrXO+/AokW6ukWKhgJdSldFRXhV/7kUibQC3cyGmNkyM6sys6u20+4UM3MzK8tciSJZUl4O++8Pe+8duxKRjGg00M2sBXAHMBQYCIwys4Ep2rUHfgG8nOkiRTJuzRr429/U3SJFJZ0j9EFAlbu/7e41wGRgRIp2NwG/BTZlsD6R7JgxI1yDru4WKSLpBHpP4IOkz9WJeV8zs4OA3u7+xPa+kZmNMbNKM6tcu3Ztk4sVyZjycujbF77//diViGTMDp8UNbOdgFuByxpr6+4T3b3M3cu6dOmyo6sWaZ4NG+Dpp0N3i4aakyKSTqCvBHonfe6VmFenPfA94Dkzexf4ITBdJ0Ylb82cCZs3w49/HLsSkYxKJ9DnA/3NrJ+ZtQZGAtPrFrr7enfv7O593b0vMA8Y7u6VWalYZEdNnQo9esBhh8WuRCSjGg10d68FxgFzgKXAVHd/w8xuNDPdLy2FZcOGMNTcqadqqDkpOi3TaeTus4BZ9eZd10Dbo3a8LJEsqetuOe202JWIZJwOUaS0qLtFipgCXUqHulukyGmvltIxY4a6W6SoKdCldEybpu4WKWoKdCkN6m6REqA9W0qDulukBCjQpTRMmaLuFil6CnQpfp98ErpbRo1Sd4sUNe3dUvymTYMtW+DMM2NXIpJVCnQpfg8/DAMHwgEHxK5EJKsU6FLc3n03jEx01ll6VK4UPQW6FLdHHgmvP/lJ3DpEckCBLsXLHR56CI44AvbaK3Y1IlmnQJfi9eqrsHSpToZKyVCgS/F66CFo1Uo3E0nJUKBLcdqyJQT6CSdAp06xqxHJCQW6FKeZM2HNGhg9OnYlIjmjQJfidO+94Vb/44+PXYlIzijQpfisXBlu9T/3XGiZ1iiLIkVBgS7F5/77YetWOO+82JWI5JQCXYrL1q0waRIceSTss0/sakRySoEuxeX552HFCp0MlZKkQJfiMmECdOgAp5wSuxKRnFOgS/H48EN47DE4/3xo1y52NSI5p0CX4jFxInz1FYwdG7sSkSgU6FIcamrgrrtg6FCdDJWSpUCX4lBeDqtWwbhxsSsRiUaBLsXhj3+Ef/on3RkqJU2BLoVv/vwwKtFFF2kQaClp2vul8I0fD7vvDhdcELsSkajSCnQzG2Jmy8ysysyuSrH8UjNbYmaLzWyumWl4GMmNqqpwqeLYsdC+fexqRKJqNNDNrAVwBzAUGAiMMrOB9Zr9HShz9/2BvwC3ZLpQkZRuvTU8gOvf/i12JSLRpXOEPgiocve33b0GmAyMSG7g7s+6+5eJj/OAXpktUySFtWvhvvvg7LOhe/fY1YhEl06g9wQ+SPpcnZjXkNHA7FQLzGyMmVWaWeXatWvTr1IklT/8ATZvhssui12JSF7I6ElRMzsLKAPGp1ru7hPdvczdy7p06ZLJVUup+fhjuP12OP10+M53YlcjkhfSefr/SqB30udeiXnfYmbHAtcAR7r75syUJ9KA3/0ONm6E66+PXYlI3kjnCH0+0N/M+plZa2AkMD25gZkdCNwFDHf3NZkvUyTJmjXw3/8NP/kJ7Ldf7GpE8kajge7utcA4YA6wFJjq7m+Y2Y1mNjzRbDywKzDNzF41s+kNfDuRHTd+PGzaBNddF7sSkbyS1oCL7j4LmFVv3nVJ74/NcF0iqb3/frjN/6yzYMCA2NWI5BXdKSqF5T//M7zefHPcOkTykAJdCscrr8DDD4fLFHv3bry9SIlRoEthcIdLL4WuXeHKK2NXI5KX0upDF4lu8mR44QW4+249s0WkATpCl/y3bh38+79DWRmcd17sakTylo7QJf9dfXV4bsvs2dCiRexqRPKWjtAlv734Yhgr9JJL4MADY1cjktcU6JK/Nm6Ec8+FPn3gl7+MXY1I3lOXi+Svyy8PA1jMnQu77hq7GpG8pyN0yU9PPAETJoRLFY8+OnY1IgVBgS75p7o6XM3yz/8Mv/pV7GpECoYCXfLL5s1w2mnwj3/AlCnQpk3sikQKhvrQJb9ceinMmwfTpunRuCJNpCN0yR933hmmyy+HU0+NXY1IwVGgS354/HG4+GI48UT49a9jVyNSkBToEt8LL8CoUXDwwfDoo9BSPYEizaFAl7hefBGGDoVevWDmTNhll9gViRQsBbrE89JLMGQIdOsGzz4Le+4ZuyKRgqZAlzhmzoRjj/0mzHv2jF2RSMFToEvu/elPMGJEuCzx+ecV5iIZokCX3Nm0CcaOhZ//HIYNg//933CELiIZoUCX3FixAg47LDyf5YoroLxcJ0BFMkzXh0l2bd0aQvzKK6FVK5gxA044IXZVIkVJR+iSPUuWwFFHwUUXwaGHwt//rjAXySIFumTe6tXws5+FpyW+9hrcdx/MmQN77RW7MpGipi4XyZwPP4Tf/z5cxbJ5M4wbB//1X9C5c+zKREqCAl12jDssWBD6yR98EGpr4YwzwpBx/fvHrk6kpCjQpXlWrw6PuL3nHli0CHbeGS64AC67DPbeO3Z1IiVJgS7pcYe33gp3eJaXh2ewuIcHat15Z3i4VocOsasUKWkKdEmtthaWLQvPW3n2WXjuudBHDnDAAXDDDXDyyeHEp4jkBQV6qdu6NQT18uXhCHzRIli4EBYvDsPAAXTtGgZqPvpoGDwY+vWLW7OIpJRWoJvZEOA2oAVwj7v/pt7yNsADwMHAJ8AZ7v5uZkuVJtuyBT77DFatCqFdf1qxAqqqvglugN12gwMPDJcdHnggHHII7LsvmMX7OUQkLY0Gupm1AO4ABgPVwHwzm+7uS5KajQbWufs+ZjYS+C1wRjYKLkjuoQujtjaEbN37+p/rL6upgS+/DIGb/Fp/3hdfhOBet+7b08aNqevp1Am6dw8nLwcPhn32CVek9O8PvXvDTro9QaQQpXOEPgiocve3AcxsMjACSA70EcANifd/Af5oZubunsFag0mTYPz4EJIQXpOndOfl6utra0O3RjbsvHOYdtklnJDs2DGEdMeO30wdOoQHYPXoEabu3aFt2+zUIyJRpRPoPYEPkj5XAz9oqI2715rZemAP4OPkRmY2BhgD0KdPn+ZV3LlzOBFX1wVgtu2Uan668zLdtmXLMLVqlfr99j63agXt2oXQTn5t1w7atNGRtIh8S05Pirr7RGAiQFlZWfOO3ocPD5OIiHxLOod4K4HeSZ97JealbGNmLYHdCSdHRUQkR9IJ9PlAfzPrZ2atgZHA9HptpgPnJN6fCjyTlf5zERFpUKNdLok+8XHAHMJli5Pc/Q0zuxGodPfpwL3Ag2ZWBXxKCH0REcmhtPrQ3X0WMKvevOuS3m8CTstsaSIi0hS6TEJEpEgo0EVEioQCXUSkSCjQRUSKhMW6utDM1gLvNfPLO1PvLtQ8obqaRnU1Xb7WprqaZkfq2svdu6RaEC3Qd4SZVbp7Wew66lNdTaO6mi5fa1NdTZOtutTlIiJSJBToIiJFolADfWLsAhqguppGdTVdvtamupomK3UVZB+6iIhsq1CP0EVEpB4FuohIkcjbQDez08zsDTPbamZl9ZZdbWZVZrbMzI5v4Ov7mdnLiXZTEo/+zXSNU8zs1cT0rpm92kC7d83stUS7ykzXkWJ9N5jZyqTahjXQbkhiG1aZ2VU5qGu8mb1pZovNrNzMOjTQLifbq7Gf38zaJH7HVYl9qW+2aklaZ28ze9bMliT2/1+kaHOUma1P+v1el+p7ZaG27f5eLLg9sb0Wm9lBOahp36Tt8KqZfW5ml9Rrk7PtZWaTzGyNmb2eNK+TmT1lZssTrx0b+NpzEm2Wm9k5qdo0yt3zcgL2A/YFngPKkuYPBBYBbYB+wAqgRYqvnwqMTLyfAIzNcr3/D7iugWXvAp1zuO1uAC5vpE2LxLbbG2id2KYDs1zXcUDLxPvfAr+Ntb3S+fmBnwMTEu9HAlNy8LvrDhyUeN8eeCtFXUcBM3O1P6X7ewGGAbMBA34IvJzj+loAqwg33kTZXsD/AQ4CXk+adwtwVeL9Van2e6AT8HbitWPifcemrj9vj9Ddfam7L0uxaAQw2d03u/s7QBVhIOuvmZkB/5cwYDXA/cBJ2ao1sb7TgUeztY4s+Hrwb3evAeoG/84ad3/S3WsTH+cRRr+KJZ2ffwRh34GwLx2T+F1njbt/5O4LE+83AEsJY/YWghHAAx7MAzqYWfccrv8YYIW7N/cO9B3m7s8TxoRIlrwfNZRFxwNPufun7r4OeAoY0tT1522gb0eqQavr7/B7AJ8lhUeqNpl0BLDa3Zc3sNyBJ81sQWKg7FwYl/hv76QG/ouXznbMpvMJR3Op5GJ7pfPzf2vwc6Bu8POcSHTxHAi8nGLxoWa2yMxmm9l3c1RSY7+X2PvUSBo+qIqxvep0dfePEu9XAV1TtMnItsvpINH1mdnTQLcUi65x98dzXU8qadY4iu0fnf+Lu680sz2Bp8zszcRf8qzUBfwJuInwD/AmQnfQ+TuyvkzUVbe9zOwaoBZ4uIFvk/HtVWjMbFfgMeASd/+83uKFhG6FLxLnRyqA/jkoK29/L4lzZMOBq1MsjrW9tuHubmZZu1Y8aqC7+7HN+LJ0Bq3+hPDfvZaJI6tUbTJSo4VBsX8MHLyd77Ey8brGzMoJ/93foX8I6W47M7sbmJliUTrbMeN1mdm5wAnAMZ7oPEzxPTK+vVJoyuDn1ZbDwc/NrBUhzB929/+pvzw54N19lpndaWad3T2rD6FK4/eSlX0qTUOBhe6+uv6CWNsryWoz6+7uHyW6oNakaLOS0Ndfpxfh/GGTFGKXy3RgZOIKhH6Ev7SvJDdIBMWzhAGrIQxgna0j/mOBN929OtVCM9vFzNrXvSecGHw9VdtMqddveXID60tn8O9M1zUE+A9guLt/2UCbXG2vvBz8PNFHfy+w1N1vbaBNt7q+fDMbRPh3nNU/NGn+XqYDZyeudvkhsD6pqyHbGvxfcoztVU/yftRQFs0BjjOzjoku0uMS85omF2d+mzMRgqga2AysBuYkLbuGcIXCMmBo0vxZQI/E+70JQV8FTAPaZKnOPwM/qzevBzArqY5FiekNQtdDtrfdg8BrwOLEztS9fl2Jz8MIV1GsyFFdVYR+wlcT04T6deVye6X6+YEbCX9wANom9p2qxL60dw620b8QusoWJ22nYcDP6vYzYFxi2ywinFw+LAd1pfy91KvLgDsS2/M1kq5Oy3JtuxACevekeVG2F+GPykfAlkR+jSacd5kLLAeeBjol2pYB9yR97fmJfa0KOK8569et/yIiRaIQu1xERCQFBbqISJFQoIuIFAkFuohIkVCgi4gUCQW6iEiRUKCLiBSJ/w+7XlyOwpsRRAAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -292,7 +290,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -311,7 +309,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -320,7 +318,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -341,22 +339,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fb05e19dbe0>"
+       "<matplotlib.legend.Legend at 0x7fd362245390>"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 34,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -395,11 +393,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 计算loss\n",
+    "# 计算loss, 使用clamp的目的是防止数据过小而对结果产生较大影响。\n",
     "def binary_loss(y_pred, y):\n",
     "    logits = (y * y_pred.clamp(1e-12).log() + (1 - y) * (1 - y_pred).clamp(1e-12).log()).mean()\n",
     "    return -logits"
@@ -416,14 +414,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor(0.8986, grad_fn=<NegBackward>)\n"
+      "tensor(0.6412, grad_fn=<NegBackward>)\n"
      ]
     }
    ],
@@ -442,113 +440,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "tensor(0.7402, grad_fn=<NegBackward>)\n",
-      "tensor(0.7348, grad_fn=<NegBackward>)\n",
-      "tensor(0.7299, grad_fn=<NegBackward>)\n",
-      "tensor(0.7254, grad_fn=<NegBackward>)\n",
-      "tensor(0.7212, grad_fn=<NegBackward>)\n",
-      "tensor(0.7175, grad_fn=<NegBackward>)\n",
-      "tensor(0.7140, grad_fn=<NegBackward>)\n",
-      "tensor(0.7108, grad_fn=<NegBackward>)\n",
-      "tensor(0.7079, grad_fn=<NegBackward>)\n",
-      "tensor(0.7052, grad_fn=<NegBackward>)\n",
-      "tensor(0.7028, grad_fn=<NegBackward>)\n",
-      "tensor(0.7005, grad_fn=<NegBackward>)\n",
-      "tensor(0.6984, grad_fn=<NegBackward>)\n",
-      "tensor(0.6965, grad_fn=<NegBackward>)\n",
-      "tensor(0.6947, grad_fn=<NegBackward>)\n",
-      "tensor(0.6931, grad_fn=<NegBackward>)\n",
-      "tensor(0.6916, grad_fn=<NegBackward>)\n",
-      "tensor(0.6901, grad_fn=<NegBackward>)\n",
-      "tensor(0.6888, grad_fn=<NegBackward>)\n",
-      "tensor(0.6876, grad_fn=<NegBackward>)\n",
-      "tensor(0.6865, grad_fn=<NegBackward>)\n",
-      "tensor(0.6855, grad_fn=<NegBackward>)\n",
-      "tensor(0.6845, grad_fn=<NegBackward>)\n",
-      "tensor(0.6836, grad_fn=<NegBackward>)\n",
-      "tensor(0.6827, grad_fn=<NegBackward>)\n",
-      "tensor(0.6819, grad_fn=<NegBackward>)\n",
-      "tensor(0.6811, grad_fn=<NegBackward>)\n",
-      "tensor(0.6804, grad_fn=<NegBackward>)\n",
-      "tensor(0.6797, grad_fn=<NegBackward>)\n",
-      "tensor(0.6791, grad_fn=<NegBackward>)\n",
-      "tensor(0.6785, grad_fn=<NegBackward>)\n",
-      "tensor(0.6779, grad_fn=<NegBackward>)\n",
-      "tensor(0.6773, grad_fn=<NegBackward>)\n",
-      "tensor(0.6768, grad_fn=<NegBackward>)\n",
-      "tensor(0.6763, grad_fn=<NegBackward>)\n",
-      "tensor(0.6758, grad_fn=<NegBackward>)\n",
-      "tensor(0.6753, grad_fn=<NegBackward>)\n",
-      "tensor(0.6749, grad_fn=<NegBackward>)\n",
-      "tensor(0.6745, grad_fn=<NegBackward>)\n",
-      "tensor(0.6740, grad_fn=<NegBackward>)\n",
-      "tensor(0.6736, grad_fn=<NegBackward>)\n",
-      "tensor(0.6732, grad_fn=<NegBackward>)\n",
-      "tensor(0.6728, grad_fn=<NegBackward>)\n",
-      "tensor(0.6725, grad_fn=<NegBackward>)\n",
-      "tensor(0.6721, grad_fn=<NegBackward>)\n",
-      "tensor(0.6718, grad_fn=<NegBackward>)\n",
-      "tensor(0.6714, grad_fn=<NegBackward>)\n",
-      "tensor(0.6711, grad_fn=<NegBackward>)\n",
-      "tensor(0.6707, grad_fn=<NegBackward>)\n",
-      "tensor(0.6704, grad_fn=<NegBackward>)\n",
-      "tensor(0.6701, grad_fn=<NegBackward>)\n",
-      "tensor(0.6698, grad_fn=<NegBackward>)\n",
-      "tensor(0.6694, grad_fn=<NegBackward>)\n",
-      "tensor(0.6691, grad_fn=<NegBackward>)\n",
-      "tensor(0.6688, grad_fn=<NegBackward>)\n",
-      "tensor(0.6685, grad_fn=<NegBackward>)\n",
-      "tensor(0.6682, grad_fn=<NegBackward>)\n",
-      "tensor(0.6679, grad_fn=<NegBackward>)\n",
-      "tensor(0.6676, grad_fn=<NegBackward>)\n",
-      "tensor(0.6673, grad_fn=<NegBackward>)\n",
-      "tensor(0.6671, grad_fn=<NegBackward>)\n",
-      "tensor(0.6668, grad_fn=<NegBackward>)\n",
-      "tensor(0.6665, grad_fn=<NegBackward>)\n",
-      "tensor(0.6662, grad_fn=<NegBackward>)\n",
-      "tensor(0.6659, grad_fn=<NegBackward>)\n",
-      "tensor(0.6656, grad_fn=<NegBackward>)\n",
-      "tensor(0.6654, grad_fn=<NegBackward>)\n",
-      "tensor(0.6651, grad_fn=<NegBackward>)\n",
-      "tensor(0.6648, grad_fn=<NegBackward>)\n",
-      "tensor(0.6645, grad_fn=<NegBackward>)\n",
-      "tensor(0.6643, grad_fn=<NegBackward>)\n",
-      "tensor(0.6640, grad_fn=<NegBackward>)\n",
-      "tensor(0.6637, grad_fn=<NegBackward>)\n",
-      "tensor(0.6634, grad_fn=<NegBackward>)\n",
-      "tensor(0.6632, grad_fn=<NegBackward>)\n",
-      "tensor(0.6629, grad_fn=<NegBackward>)\n",
-      "tensor(0.6626, grad_fn=<NegBackward>)\n",
-      "tensor(0.6624, grad_fn=<NegBackward>)\n",
-      "tensor(0.6621, grad_fn=<NegBackward>)\n",
-      "tensor(0.6618, grad_fn=<NegBackward>)\n",
-      "tensor(0.6616, grad_fn=<NegBackward>)\n",
-      "tensor(0.6613, grad_fn=<NegBackward>)\n",
-      "tensor(0.6610, grad_fn=<NegBackward>)\n",
-      "tensor(0.6608, grad_fn=<NegBackward>)\n",
-      "tensor(0.6605, grad_fn=<NegBackward>)\n",
-      "tensor(0.6603, grad_fn=<NegBackward>)\n",
-      "tensor(0.6600, grad_fn=<NegBackward>)\n",
-      "tensor(0.6597, grad_fn=<NegBackward>)\n",
-      "tensor(0.6595, grad_fn=<NegBackward>)\n",
-      "tensor(0.6592, grad_fn=<NegBackward>)\n",
-      "tensor(0.6589, grad_fn=<NegBackward>)\n",
-      "tensor(0.6587, grad_fn=<NegBackward>)\n",
-      "tensor(0.6584, grad_fn=<NegBackward>)\n",
-      "tensor(0.6582, grad_fn=<NegBackward>)\n",
-      "tensor(0.6579, grad_fn=<NegBackward>)\n",
-      "tensor(0.6576, grad_fn=<NegBackward>)\n",
-      "tensor(0.6574, grad_fn=<NegBackward>)\n",
-      "tensor(0.6571, grad_fn=<NegBackward>)\n",
-      "tensor(0.6569, grad_fn=<NegBackward>)\n",
-      "tensor(0.6566, grad_fn=<NegBackward>)\n"
+     "ename": "AttributeError",
+     "evalue": "'NoneType' object has no attribute 'data'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-37-8e380a74b61d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# 自动求导并更新参数\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'data'"
      ]
     }
    ],
@@ -571,22 +474,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fb0598c0cc0>"
+       "<matplotlib.legend.Legend at 0x7fd3621cf9b0>"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 38,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -627,7 +530,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -644,29 +547,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:15: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n",
-      "  from ipykernel import kernelapp as app\n",
-      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:17: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n"
-     ]
-    },
-    {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "epoch: 200, Loss: 0.39010, Acc: 0.00000\n",
-      "epoch: 400, Loss: 0.32184, Acc: 0.00000\n",
-      "epoch: 600, Loss: 0.28917, Acc: 0.00000\n",
-      "epoch: 800, Loss: 0.26983, Acc: 0.00000\n",
-      "epoch: 1000, Loss: 0.25700, Acc: 0.00000\n",
+      "epoch: 200, Loss: 0.39672, Acc: 0.92000\n",
+      "epoch: 400, Loss: 0.32435, Acc: 0.92000\n",
+      "epoch: 600, Loss: 0.29053, Acc: 0.91000\n",
+      "epoch: 800, Loss: 0.27069, Acc: 0.91000\n",
+      "epoch: 1000, Loss: 0.25759, Acc: 0.90000\n",
       "\n",
-      "During Time: 0.248 s\n"
+      "During Time: 0.591 s\n"
      ]
     }
    ],
@@ -685,9 +579,9 @@
     "    optimizer.step() # 使用优化器来更新参数\n",
     "    # 计算正确率\n",
     "    mask = y_pred.ge(0.5).float()\n",
-    "    acc = (mask == y_data).sum().data[0] / y_data.shape[0]\n",
+    "    acc = (mask == y_data).sum().item() / y_data.shape[0]\n",
     "    if (e + 1) % 200 == 0:\n",
-    "        print('epoch: {}, Loss: {:.5f}, Acc: {:.5f}'.format(e+1, loss.data[0], acc))\n",
+    "        print('epoch: {}, Loss: {:.5f}, Acc: {:.5f}'.format(e+1, loss.item(), acc))\n",
     "during = time.time() - start\n",
     "print()\n",
     "print('During Time: {:.3f} s'.format(during))"
@@ -711,22 +605,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7f083e823400>"
+       "<matplotlib.legend.Legend at 0x7fd3621aee48>"
       ]
      },
-     "execution_count": 36,
+     "execution_count": 43,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -772,10 +666,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 44,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# 使用自带的loss\n",
@@ -792,17 +684,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\n",
-      " 0.6363\n",
-      "[torch.FloatTensor of size 1]\n",
-      "\n"
+      "tensor(0.6363)\n"
      ]
     }
    ],
@@ -814,20 +703,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "epoch: 200, Loss: 0.39538, Acc: 0.88000\n",
-      "epoch: 400, Loss: 0.32407, Acc: 0.87000\n",
-      "epoch: 600, Loss: 0.29039, Acc: 0.87000\n",
-      "epoch: 800, Loss: 0.27061, Acc: 0.87000\n",
-      "epoch: 1000, Loss: 0.25753, Acc: 0.88000\n",
+      "epoch: 200, Loss: 0.39427, Acc: 0.88000\n",
+      "epoch: 400, Loss: 0.32362, Acc: 0.87000\n",
+      "epoch: 600, Loss: 0.29014, Acc: 0.87000\n",
+      "epoch: 800, Loss: 0.27045, Acc: 0.87000\n",
+      "epoch: 1000, Loss: 0.25743, Acc: 0.88000\n",
       "\n",
-      "During Time: 0.527 s\n"
+      "During Time: 0.372 s\n"
      ]
     }
    ],
@@ -843,11 +732,11 @@
     "    optimizer.zero_grad()\n",
     "    loss.backward()\n",
     "    optimizer.step()\n",
-    "    # 计算正确率\n",
-    "    mask = y_pred.ge(0.5).float()\n",
-    "    acc = (mask == y_data).sum().data[0] / y_data.shape[0]\n",
+    "    # 计算正确率 0.5以上的判断为正确\n",
+    "    mask = y_pred.ge(0.5).float()        \n",
+    "    acc = (mask == y_data).sum().item() / y_data.shape[0]\n",
     "    if (e + 1) % 200 == 0:\n",
-    "        print('epoch: {}, Loss: {:.5f}, Acc: {:.5f}'.format(e+1, loss.data[0], acc))\n",
+    "        print('epoch: {}, Loss: {:.5f}, Acc: {:.5f}'.format(e+1, loss.item(), acc))\n",
     "\n",
     "during = time.time() - start\n",
     "print()\n",
@@ -867,6 +756,13 @@
    "source": [
     "下一节课我们会介绍 PyTorch 中构建模型的模块 `Sequential` 和 `Module`，使用这个可以帮助我们更方便地构建模型"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -885,7 +781,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/1_NN/3-nn-sequential-module.ipynb b/6_pytorch/1_NN/3-nn-sequential-module.ipynb
index 134eac8..bf7813d 100644
--- a/6_pytorch/1_NN/3-nn-sequential-module.ipynb
+++ b/6_pytorch/1_NN/3-nn-sequential-module.ipynb
@@ -129,7 +129,7 @@
     "    h = 0.01\n",
     "    # Generate a grid of points with distance h between them\n",
     "    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n",
-    "    # Predict the function value for the whole grid\n",
+    "    # Predict the function value for the whole grid .c_按行连接两个矩阵，左右相加。\n",
     "    Z = model(np.c_[xx.ravel(), yy.ravel()])\n",
     "    Z = Z.reshape(xx.shape)\n",
     "    # Plot the contour and training examples\n",
@@ -261,6 +261,7 @@
    ],
    "source": [
     "for e in range(100):\n",
+    "    #更新并自动计算\n",
     "    out = logistic_regression(Variable(x))\n",
     "    loss = criterion(out, Variable(y))\n",
     "    optimizer.zero_grad()\n",
diff --git a/6_pytorch/1_NN/4-deep-nn.ipynb b/6_pytorch/1_NN/4-deep-nn.ipynb
index cec052e..b83aba5 100644
--- a/6_pytorch/1_NN/4-deep-nn.ipynb
+++ b/6_pytorch/1_NN/4-deep-nn.ipynb
@@ -688,7 +688,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/1_NN/6-nn_summary.ipynb b/6_pytorch/1_NN/6-nn_summary.ipynb
index 1e995c6..b5a0cd5 100644
--- a/6_pytorch/1_NN/6-nn_summary.ipynb
+++ b/6_pytorch/1_NN/6-nn_summary.ipynb
@@ -1947,7 +1947,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/2_CNN/2-batch-normalization.ipynb b/6_pytorch/2_CNN/2-batch-normalization.ipynb
index 7725e36..f3a9d8b 100644
--- a/6_pytorch/2_CNN/2-batch-normalization.ipynb
+++ b/6_pytorch/2_CNN/2-batch-normalization.ipynb
@@ -561,7 +561,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/2_CNN/6-vgg.ipynb b/6_pytorch/2_CNN/6-vgg.ipynb
index 3649f57..411fa4d 100644
--- a/6_pytorch/2_CNN/6-vgg.ipynb
+++ b/6_pytorch/2_CNN/6-vgg.ipynb
@@ -35,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-12-22T09:01:51.296457Z",
@@ -63,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-12-22T09:01:51.312500Z",
@@ -92,7 +92,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 4,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-12-22T08:20:40.819497Z",
@@ -106,11 +106,11 @@
      "text": [
       "Sequential(\n",
       "  (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "  (1): ReLU(inplace)\n",
+      "  (1): ReLU(inplace=True)\n",
       "  (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "  (3): ReLU(inplace)\n",
+      "  (3): ReLU(inplace=True)\n",
       "  (4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "  (5): ReLU(inplace)\n",
+      "  (5): ReLU(inplace=True)\n",
       "  (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       ")\n"
      ]
@@ -123,7 +123,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 5,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-12-22T07:52:04.632406Z",
@@ -157,7 +157,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 6,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-12-22T09:01:54.497712Z",
@@ -184,7 +184,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 7,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-12-22T09:01:55.149378Z",
@@ -199,43 +199,43 @@
       "Sequential(\n",
       "  (0): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (1): ReLU(inplace)\n",
+      "    (1): ReLU(inplace=True)\n",
       "    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (3): ReLU(inplace)\n",
+      "    (3): ReLU(inplace=True)\n",
       "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (1): Sequential(\n",
       "    (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (1): ReLU(inplace)\n",
+      "    (1): ReLU(inplace=True)\n",
       "    (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (3): ReLU(inplace)\n",
+      "    (3): ReLU(inplace=True)\n",
       "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (2): Sequential(\n",
       "    (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (1): ReLU(inplace)\n",
+      "    (1): ReLU(inplace=True)\n",
       "    (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (3): ReLU(inplace)\n",
+      "    (3): ReLU(inplace=True)\n",
       "    (4): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (5): ReLU(inplace)\n",
+      "    (5): ReLU(inplace=True)\n",
       "    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (3): Sequential(\n",
       "    (0): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (1): ReLU(inplace)\n",
+      "    (1): ReLU(inplace=True)\n",
       "    (2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (3): ReLU(inplace)\n",
+      "    (3): ReLU(inplace=True)\n",
       "    (4): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (5): ReLU(inplace)\n",
+      "    (5): ReLU(inplace=True)\n",
       "    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (4): Sequential(\n",
       "    (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (1): ReLU(inplace)\n",
+      "    (1): ReLU(inplace=True)\n",
       "    (2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (3): ReLU(inplace)\n",
+      "    (3): ReLU(inplace=True)\n",
       "    (4): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-      "    (5): ReLU(inplace)\n",
+      "    (5): ReLU(inplace=True)\n",
       "    (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       ")\n"
@@ -256,7 +256,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 8,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-12-22T08:52:44.049650Z",
@@ -287,7 +287,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 9,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2017-12-22T09:01:57.323034Z",
@@ -415,7 +415,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/2_CNN/7-googlenet.ipynb b/6_pytorch/2_CNN/7-googlenet.ipynb
index 54f3b0f..ef45f1e 100644
--- a/6_pytorch/2_CNN/7-googlenet.ipynb
+++ b/6_pytorch/2_CNN/7-googlenet.ipynb
@@ -49,7 +49,7 @@
    "source": [
     "import sys\n",
     "sys.path.append('..')\n",
-    "\n",
+    " \n",
     "import numpy as np\n",
     "import torch\n",
     "from torch import nn\n",
@@ -377,7 +377,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/2_CNN/8-resnet.ipynb b/6_pytorch/2_CNN/8-resnet.ipynb
index e389a17..bdeccc8 100644
--- a/6_pytorch/2_CNN/8-resnet.ipynb
+++ b/6_pytorch/2_CNN/8-resnet.ipynb
@@ -373,7 +373,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,
diff --git a/6_pytorch/3_RNN/pytorch-rnn.ipynb b/6_pytorch/3_RNN/pytorch-rnn.ipynb
index 5853ad4..79fa800 100644
--- a/6_pytorch/3_RNN/pytorch-rnn.ipynb
+++ b/6_pytorch/3_RNN/pytorch-rnn.ipynb
@@ -41,10 +41,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 1,
+   "metadata": {},
    "outputs": [],
    "source": [
     "import torch\n",
@@ -54,10 +52,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 2,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# 定义一个单步的 rnn\n",
@@ -66,25 +62,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "Parameter containing:\n",
-       "1.00000e-02 *\n",
-       " 6.2260 -5.3805  3.5870  ...  -2.2162  6.2760  1.6760\n",
-       "-5.1878 -4.6751 -5.5926  ...  -1.8942  0.1589  1.0725\n",
-       " 3.3236 -3.2726  5.5399  ...   3.3193  0.2117  1.1730\n",
-       "          ...             ⋱             ...          \n",
-       " 2.4032 -3.4415  5.1036  ...  -2.2035 -0.1900 -6.4016\n",
-       " 5.2031 -1.5793 -0.0623  ...   0.3424  6.9412  6.3707\n",
-       "-5.4495  4.5280  2.1774  ...   1.8767  2.4968  5.3403\n",
-       "[torch.FloatTensor of size 200x200]"
+       "tensor([[-2.7963e-02,  3.6102e-02,  5.6609e-03,  ..., -3.0035e-02,\n",
+       "          2.7740e-02,  2.3327e-02],\n",
+       "        [-2.8567e-02, -3.2150e-02, -2.6686e-02,  ..., -4.6441e-02,\n",
+       "          3.5804e-02,  9.7260e-05],\n",
+       "        [ 4.6686e-02, -1.5825e-02,  6.7149e-02,  ...,  3.3435e-02,\n",
+       "         -2.7623e-02, -6.7693e-02],\n",
+       "        ...,\n",
+       "        [-2.0338e-02, -1.6551e-02,  5.8996e-02,  ..., -4.0145e-02,\n",
+       "         -6.9111e-03, -3.2740e-02],\n",
+       "        [-2.4584e-02,  2.3591e-02,  8.3090e-03,  ..., -3.6077e-02,\n",
+       "         -6.0432e-03,  5.6279e-02],\n",
+       "        [ 5.6955e-02, -5.1925e-02,  3.1950e-02,  ..., -5.6692e-02,\n",
+       "          6.1773e-02,  1.9715e-02]], requires_grad=True)"
       ]
      },
-     "execution_count": 48,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -96,14 +96,58 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[[ 1.4637, -2.0015,  0.6298,  ..., -1.1210, -1.6310,  0.5122],\n",
+       "         [-0.1500, -0.6931,  0.1568,  ..., -0.9185, -0.5088, -1.0746],\n",
+       "         [ 0.1717,  1.2186, -0.8093,  ...,  0.8630,  0.4601, -1.0218],\n",
+       "         [-0.3034,  2.8634,  2.2470,  ...,  0.1678, -2.0585, -0.9628],\n",
+       "         [-2.3764, -0.4235, -1.1760,  ..., -1.2251,  0.6761, -1.0323]],\n",
+       "\n",
+       "        [[-1.3497, -0.6778, -0.0528,  ..., -0.1852, -0.3997, -0.7633],\n",
+       "         [ 1.0105,  0.7974,  0.4253,  ..., -1.1167, -1.3870, -1.3583],\n",
+       "         [ 0.2785,  0.5013, -0.5881,  ..., -0.0283,  0.6044, -0.3249],\n",
+       "         [-1.9298, -0.6575, -1.2878,  ...,  0.5636, -0.3266,  1.9391],\n",
+       "         [ 1.3117, -1.1429, -1.5837,  ..., -1.5248, -0.2046,  1.0696]],\n",
+       "\n",
+       "        [[-0.8637, -1.0572, -0.2438,  ...,  0.1011, -0.4630,  0.0526],\n",
+       "         [-0.0056, -0.9442, -0.5588,  ..., -0.6881, -1.2189, -1.1846],\n",
+       "         [ 0.8341,  0.6924, -0.4376,  ...,  1.1331, -0.9766,  1.3822],\n",
+       "         [-0.3815, -1.3457,  0.5320,  ...,  0.8280,  0.2146, -0.8704],\n",
+       "         [-0.6424,  1.3608, -0.5325,  ..., -0.3414,  1.0094,  1.2650]],\n",
+       "\n",
+       "        [[-0.1776, -0.2037, -0.7093,  ..., -1.1442, -1.0058, -0.6898],\n",
+       "         [ 0.2921, -1.9473, -0.6989,  ...,  0.6852, -0.2225, -0.6484],\n",
+       "         [-0.8576,  1.9338, -1.5359,  ..., -0.3545, -0.9438,  0.1476],\n",
+       "         [ 2.3669,  0.8673,  2.0521,  ..., -0.4679, -0.4050,  0.7761],\n",
+       "         [ 0.3706,  1.2876, -0.5311,  ...,  0.4794, -0.4209,  0.5343]],\n",
+       "\n",
+       "        [[-0.2726, -1.2583, -0.8259,  ...,  0.8811,  0.5900,  0.1770],\n",
+       "         [ 1.1066, -0.4899,  0.9143,  ..., -2.2898,  0.1525, -2.2099],\n",
+       "         [-1.3824,  0.3142,  1.2140,  ...,  0.5470, -0.4883, -0.3204],\n",
+       "         [ 1.8471,  0.6011,  0.0613,  ...,  1.1584, -0.8014,  0.4891],\n",
+       "         [ 1.5201, -1.7853,  1.3107,  ...,  0.0032, -1.3422,  0.7332]],\n",
+       "\n",
+       "        [[ 0.3025, -0.7314, -0.2032,  ..., -0.9658, -1.8131,  0.5922],\n",
+       "         [-0.0878,  0.0909,  0.7064,  ...,  2.4186, -0.0863,  0.0930],\n",
+       "         [-1.4278, -1.0901,  1.6742,  ...,  0.3020, -0.6106, -0.4299],\n",
+       "         [-1.8291, -1.1337, -0.2405,  ..., -1.2000,  2.0510,  1.3617],\n",
+       "         [-2.7953, -0.0559,  1.0224,  ...,  0.4400,  0.9099, -1.5845]]])"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# 构造一个序列，长为 6，batch 是 5， 特征是 100\n",
-    "x = Variable(torch.randn(6, 5, 100)) # 这是 rnn 的输入格式"
+    "x = Variable(torch.randn(6, 5, 100)) # 这是 rnn 的输入格式\n",
+    "x"
    ]
   },
   {
diff --git a/6_pytorch/4_GAN/autoencoder.ipynb b/6_pytorch/4_GAN/autoencoder.ipynb
index 4691d55..6f38db4 100644
--- a/6_pytorch/4_GAN/autoencoder.ipynb
+++ b/6_pytorch/4_GAN/autoencoder.ipynb
@@ -22,13 +22,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 4,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2018-01-01T10:09:21.223959Z",
      "start_time": "2018-01-01T10:09:20.758909Z"
-    },
-    "collapsed": true
+    }
    },
    "outputs": [],
    "source": [
@@ -53,13 +52,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 7,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2018-01-01T10:09:21.368959Z",
      "start_time": "2018-01-01T10:09:21.341312Z"
-    },
-    "collapsed": true
+    }
    },
    "outputs": [],
    "source": [
@@ -68,19 +66,18 @@
     "    tfs.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) # 标准化\n",
     "])\n",
     "\n",
-    "train_set = MNIST('./mnist', transform=im_tfs)\n",
+    "train_set = MNIST('./mnist', transform=im_tfs, download=True )\n",
     "train_data = DataLoader(train_set, batch_size=128, shuffle=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 8,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2018-01-01T10:09:23.526707Z",
      "start_time": "2018-01-01T10:09:23.489417Z"
-    },
-    "collapsed": true
+    }
    },
    "outputs": [],
    "source": [
@@ -125,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 10,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2018-01-01T10:09:26.677033Z",
@@ -137,7 +134,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "torch.Size([1, 3])\n"
+      "torch.Size([1, 3])\n",
+      "tensor([[0.3032, 0.0394, 0.2175]], grad_fn=<AddmmBackward>)\n",
+      "torch.Size([1, 784])\n"
      ]
     }
    ],
@@ -145,7 +144,7 @@
     "net = autoencoder()\n",
     "x = Variable(torch.randn(1, 28*28)) # batch size 是 1\n",
     "code, _ = net(x)\n",
-    "print(code.shape)"
+    "print(code.shape)\n"
    ]
   },
   {
diff --git a/6_pytorch/4_GAN/mnist/MNIST/processed/test.pt b/6_pytorch/4_GAN/mnist/MNIST/processed/test.pt
new file mode 100644
index 0000000..b1a1249
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/processed/test.pt differ
diff --git a/6_pytorch/4_GAN/mnist/MNIST/processed/training.pt b/6_pytorch/4_GAN/mnist/MNIST/processed/training.pt
new file mode 100644
index 0000000..d88a4a8
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/processed/training.pt differ
diff --git a/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-images-idx3-ubyte b/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-images-idx3-ubyte
new file mode 100644
index 0000000..1170b2c
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-images-idx3-ubyte differ
diff --git a/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-images-idx3-ubyte.gz b/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-images-idx3-ubyte.gz
new file mode 100644
index 0000000..5ace8ea
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-images-idx3-ubyte.gz differ
diff --git a/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-labels-idx1-ubyte b/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-labels-idx1-ubyte
new file mode 100644
index 0000000..d1c3a97
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-labels-idx1-ubyte differ
diff --git a/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-labels-idx1-ubyte.gz b/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-labels-idx1-ubyte.gz
new file mode 100644
index 0000000..a7e1415
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/raw/t10k-labels-idx1-ubyte.gz differ
diff --git a/6_pytorch/4_GAN/mnist/MNIST/raw/train-images-idx3-ubyte b/6_pytorch/4_GAN/mnist/MNIST/raw/train-images-idx3-ubyte
new file mode 100644
index 0000000..bbce276
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/raw/train-images-idx3-ubyte differ
diff --git a/6_pytorch/4_GAN/mnist/MNIST/raw/train-images-idx3-ubyte.gz b/6_pytorch/4_GAN/mnist/MNIST/raw/train-images-idx3-ubyte.gz
new file mode 100644
index 0000000..b50e4b6
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/raw/train-images-idx3-ubyte.gz differ
diff --git a/6_pytorch/4_GAN/mnist/MNIST/raw/train-labels-idx1-ubyte b/6_pytorch/4_GAN/mnist/MNIST/raw/train-labels-idx1-ubyte
new file mode 100644
index 0000000..d6b4c5d
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/raw/train-labels-idx1-ubyte differ
diff --git a/6_pytorch/4_GAN/mnist/MNIST/raw/train-labels-idx1-ubyte.gz b/6_pytorch/4_GAN/mnist/MNIST/raw/train-labels-idx1-ubyte.gz
new file mode 100644
index 0000000..707a576
Binary files /dev/null and b/6_pytorch/4_GAN/mnist/MNIST/raw/train-labels-idx1-ubyte.gz differ
diff --git a/6_pytorch/5_NLP/Word2Vec.ipynb b/6_pytorch/5_NLP/Word2Vec.ipynb
index f4efd92..06ae23c 100644
--- a/6_pytorch/5_NLP/Word2Vec.ipynb
+++ b/6_pytorch/5_NLP/Word2Vec.ipynb
@@ -136,7 +136,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.8"
   }
  },
  "nbformat": 4,