[1/2] incubator-singa git commit: SINGA-352 Complete SINGA documentation in Chinese version

[wangwei]

Repository: incubator-singa
Updated Branches:
  refs/heads/master c67c3b63f -> c343ff950


http://git-wip-us.apache.org/repos/asf/incubator-singa/blob/c343ff95/doc/zh/docs/optimizer.md
----------------------------------------------------------------------
diff --git a/doc/zh/docs/optimizer.md b/doc/zh/docs/optimizer.md
new file mode 100644
index 0000000..6657e41
--- /dev/null
+++ b/doc/zh/docs/optimizer.md
@@ -0,0 +1,237 @@
+# 优化器(Optimizer)
+
+这个模块包含一系列用于模型参数更新的优化器。
+
+示例用法：
+
+```python
+from singa import optimizer
+from singa import tensor
+
+sgd = optimizer.SGD(lr=0.01, momentum=0.9, weight_decay=1e-4)
+p = tensor.Tensor((3,5))
+p.uniform(-1, 1)
+g = tensor.Tensor((3,5))
+g.gaussian(0, 0.01)
+
+sgd.apply(1, g, p, 'param')  # use the global lr=0.1 for epoch 1
+sgd.apply_with_lr(2, 0.03, g, p, 'param')  # use lr=0.03 for epoch 2
+```
+
+-----
+
+### class singa.optimizer.Optimizer(lr=None, momentum=None, weight_decay=None, 
regularizer=None, constraint=None)
+
+基类：`object`
+
+Python优化器类的基类。
+典型地，优化器有如下作用：
+
+1. 构建优化器
+2. （可选）以参数名为注册每种参数
+3. 使用优化器依照给定参数梯度及其他信息更新参数值
+
+它的子类应该重写apply_with_lr函数已用于真实的参数更新。
+
+**参数：**
+- **lr (float)** – 学习速率
+- **momentum (float)** – 动量
+- **weight_decay (float)** – 
L2正则化系数，被排除于‘regularizer’之外
+- **regularizer** –  
Regularizer或RegularizerConf实例；如被设置，正则化将被用于apply_with_lr()。
 用户也可以在优化器外部做正则化。
+- **constraint** – 
Constraint或ConstraintConf实例；如被设置，正则化将被用于apply_with_lr()。
 用户也可以在优化器外部做正则化。
+
+-----
+
+#### register(name, specs)
+
+注册参数，包括为每个参数对象创建正则化和约束条件。 
这里参数特定的正则化和约束比全局设置有更高优先级。 
如果所有参数对于学习速率、正规化器和约束条件å…
±äº«ç›¸åŒçš„设置，则不需要调用该函数。
+
+**参数：**
+- **name (str)** – 参数名
+- **specs (ParamSpec)** – protobuf对象，包
括正则化和约束条件、学习速率和权值衰减乘子。
+
+-----
+
+#### apply_regularizer_constraint(epoch, value, grad, name=None, step=-1)
+
+如果可用，将采用正则化和约束条件。 如果å…
¨å±€æ­£åˆ™åŒ–和参数特定的正则化都存在，会采用参数特定的正则化。
+
+**参数：**
+- **epoch (int)** – 训练的epoch ID 
（完整训练一遍训练数据称为一个epoch）
+- **value (Tensor)** – 参数Tensor
+- **grad (Tensor)** – 参数梯度Tensor
+- **name (string)** – 
参数名以索引到特定的规则（正则化或约束条件）
+- **step (int)** – 每个epoch内的迭代ID
+
+**返回值：** 更新后的梯度tensor
+
+-----
+
+#### apply_with_lr(epoch, lr, grad, value, name=None, step=-1)
+
+如果grad非空，则根据给定学习速率更新参数。
+
+子类优化器必
须重写这个函数。如果grad为空，将不做任何操作。
+
+**参数：**
+- **epoch (int)** – 训练的epoch ID 
（完整训练一遍训练数据称为一个epoch）
+- **lr (float)** – 学习速率
+- **value (Tensor)** – 参数Tensor
+- **grad (Tensor)** – 参数梯度Tensor
+- **name (string)** – 
参数名以索引到特定的规则（正则化或约束条件）
+- **step (int)** – 每个epoch内的迭代ID
+**返回值：** 更新后的参数值
+
+-----
+
+#### apply(epoch, grad, value, name=None, step=-1)
+
+假设学习速率生成器配置完成，完成参数更新。 
子类不需要重写这个函数。
+
+**参数：**
+- **epoch (int)** – 训练的epoch ID 
（完整训练一遍训练数据称为一个epoch）
+- **value (Tensor)** – 参数Tensor
+- **grad (Tensor)** – 参数梯度Tensor
+- **name (string)** – 
参数名以索引到特定的规则（正则化或约束条件）
+- **step (int)** – 每个epoch内的迭代ID
+
+**返回值：** 更新后的参数值
+
+-----
+
+### class singa.optimizer.SGD(lr=None, momentum=None, weight_decay=None, 
regularizer=None, constraint=None)
+
+基类：`singa.optimizer.Optimizer`
+
+原始的包含动量的随机梯度下降算法。 
参数详见Optimizer基类。
+
+
+#### apply_with_lr(epoch, lr, grad, value, name, step=-1)
+
+-----
+
+### class singa.optimizer.Nesterov(lr=None, momentum=0.9, weight_decay=None, 
regularizer=None, constraint=None)
+
+基类：`singa.optimizer.Optimizer`
+
+包
含Nesterov动量的随机梯度下降算法。参数详见Optimizer基类。
+
+#### apply_with_lr(epoch, lr, grad, value, name, step=-1)
+
+-----
+
+### class singa.optimizer.RMSProp(rho=0.9, epsilon=1e-08, lr=None, 
weight_decay=None, regularizer=None, constraint=None)
+
+基类：`singa.optimizer.Optimizer`
+
+RMSProp优化器。构造器参数请参考Optimizer基类。
+
+**参数：**
+- **rho (float)** – [0, 1]间的浮点数
+- **epsilon (float)** – 很小的值，以避免数值误差
+
+#### apply_with_lr(epoch, lr, grad, value, name, step=-1)
+
+-----
+
+### class singa.optimizer.AdaGrad(epsilon=1e-08, lr=None, weight_decay=None, 
lr_gen=None, regularizer=None, constraint=None)
+
+基类：`singa.optimizer.Optimizer`
+
+AdaGrad优化器。构造器参数请参考Optimizer基类。
+
+**参数：** 
+- **epsilon (float)** – 很小的值，以避免数值误差
+
+#### apply_with_lr(epoch, lr, grad, value, name, step=-1)
+
+-----
+
+### class singa.optimizer.Adam(beta_1=0.9, beta_2=0.999, epsilon=1e-08, 
lr=None, weight_decay=None, regularizer=None, constraint=None)
+
+基类：`singa.optimizer.Optimizer`
+
+Ada优化器。构造器参数请参考Optimizer基类。
+
+**参数：**
+- **beta_1 (float)** – 动量系数
+- **beta_2 (float)** – 整合的梯度平方的系数
+- **epsilon (float)** – 很小的值，以避免数值误差
+
+#### apply_with_lr(epoch, lr, grad, value, name, step=-1)
+
+更新一个参数对象
+
+**参数：**
+- **step (int)** – 累积训练迭代数，而不是当前迭代ID
+
+-----
+
+### class singa.optimizer.Regularizer
+
+基类：`object`
+
+Python参数梯度正则化的基类。
+
+#### apply(epoch, value, grad, step=-1)
+
+-----
+
+### class singa.optimizer.CppRegularizer(conf)
+
+基类：`singa.optimizer.Regularizer`
+
+正则化的封装使用C++实现。
+
+**参数：**
+- **conf (RegularizerConf)** – protobuf配置信息
+
+#### apply(epoch, value, grad, step=-1)
+
+-----
+
+### class singa.optimizer.L2Regularizer(coefficient)
+
+基类：`singa.optimizer.Regularizer`
+
+L2正则化。
+
+**参数：**
+- **coefficient (float)** – 正则化系数
+
+#### apply(epoch, value, grad, step=-1)
+
+-----
+
+### class singa.optimizer.Constraint
+
+基类：`object`
+
+Python参数梯度约束的基类。
+
+#### apply(epoch, value, grad, step=-1)
+
+-----
+
+### class singa.optimizer.CppConstraint(conf)
+
+基类：`singa.optimizer.Constraint`
+
+约束的封装使用C++实现。
+
+**参数：**
+- **conf (RegularizerConf)** – protobuf配置信息
+
+#### apply(epoch, value, grad, step=-1)
+
+-----
+
+### class singa.optimizer.L2Constraint(threshold=None)
+
+基类：`singa.optimizer.Constraint`
+
+梯度缩放使得L2 norm小于给定阀值。
+
+#### apply(epoch, value, grad, step=-1)
+
+-----

http://git-wip-us.apache.org/repos/asf/incubator-singa/blob/c343ff95/doc/zh/docs/snapshot.md
----------------------------------------------------------------------
diff --git a/doc/zh/docs/snapshot.md b/doc/zh/docs/snapshot.md
new file mode 100644
index 0000000..9978ca1
--- /dev/null
+++ b/doc/zh/docs/snapshot.md
@@ -0,0 +1,42 @@
+# Snapshot
+
+此模块包含io::snapshot类及其方法。
+
+示例用法：
+
+```python
+from singa import snapshot
+
+sn1 = snapshot.Snapshot('param', False)
+params = sn1.read()  # read all params as a dictionary
+
+sn2 = snapshot.Snapshot('param_new', False)
+for k, v in params.iteritems():
+    sn2.write(k, v)
+```
+
+---
+
+### class singa.snapshot.Snapshot(f, mode, buffer_size=10)
+
+`singa::Snapshot`类和成员函数。
+
+---
+
+#### read()
+
+调用read方法加载所有信息（参数名，参数值）。
+
+**返回值：** （参数名，参数值）的字典
+
+---
+
+#### write(param_name, param_val)
+
+调用write方法写回参数。
+
+**参数：**
+- **param_name (string)** – 参数名
+- **param_val (Tensor)** – 参数值的tensor
+
+---

http://git-wip-us.apache.org/repos/asf/incubator-singa/blob/c343ff95/doc/zh/docs/software_stack.md
----------------------------------------------------------------------
diff --git a/doc/zh/docs/software_stack.md b/doc/zh/docs/software_stack.md
new file mode 100644
index 0000000..94f66fd
--- /dev/null
+++ b/doc/zh/docs/software_stack.md
@@ -0,0 +1,61 @@
+# 软件架构
+
+SINGA的软件架构包括三个主要部分，即核心（Core），输å…
¥è¾“出（IO）和模型（Model）。 
图1阐述了这些组件以及硬件。核心部分提供了内存管理和张
量操作；输入输出包括从（向）磁盘和网络读取（写å…
¥ï¼‰çš„类；模型部分为机器学习
模型提供数据结构和算法支持，比如用于神经网络模型的层，用于通用机器学ä¹
 æ¨¡åž‹çš„优化器/初始化/度量/损失函数等。
+
+
+<img src="../_static/images/singav1-sw.png" align="center" width="500px"/>
+<br/>
+<span><strong>Figure 1 - SINGA V1 software stack.</strong></span>
+
+## 核心
+
+å¼ 
量([Tensor](tensor.html))和设备([Device](device.html))是SINGA的两个æ 
¸å¿ƒæŠ½è±¡ç±»ã€‚ 
Tensor代表了一个多维数组，存储了模型的变量并且为机器学ä¹
 ç®—法提供线性代数的操作，这些操作包
括矩阵乘法和随机函数。每个Tensor实例被分é…
åœ¨ä¸€ä¸ªè®¾å¤‡å®žä¾‹ä¸Šã€‚ 
每个Device实例被创建在一台硬件设备上，如GPU或CPUæ 
¸ä¸Šã€‚设备类用于管理张量所占用的内存以及在执行单å…
ƒä¸Šæ‰§è¡Œå¼ é‡æ“ä½œï¼Œæ¯”如CPU线程或CUDA流。
+
+依赖于硬件和编程语言，SINGA实现了以下特定的设备类：
+
+* **CudaGPU** 代表一个Nvidia GPU。 执行单元是CUDA流。
+* **CppCPU** 代表一个CPU。 执行单元是CPU线程。
+* **OpenclGPU** 代表Nvidia和AMD的GPU。执行单å…
ƒæ˜¯CommandQueues。OpenCL和很多硬件设备å…
¼å®¹ï¼Œæ¯”如FPGA和ARM，所以OpenclGPU可以扩展到其他设备上。
+
+不同类型的设备使用不同编程语言书写用于张量操作的æ 
¸å‡½æ•°ï¼Œ
+
+* CppMath (tensor_math_cpp.h) 用Cpp实现了CppCPU的张量操作
+* CudaMath (tensor_math_cuda.h) 用CUDA实现了CudaGPU的张量操作
+* OpenclMath (tensor_math_opencl.h) 用OpenCL实现了OpenclGPU的张量操作
+
+另外，不同类型的数据，比如float32和float16,可以通过加å…
¥ç›¸åº”的张量函数来支持。
+
+典型地，用户将创建一个Device实例并把它传
给多个Tensor实例。 
当用户调用Tensor函数时，这些函数会自动唤起对应的实现(CppMath/CudaMath/OpenclMath)。
 换句话说，Tensor操作的实现对用户是透明的。
+
+大多数机器学习算法可以用（紧密的或稀疏的）Tensor表达。 
所以，通过张量的抽象，SINGA可以运行很多模型，包
括深度学习模型和其他传统机器学习模型。 
+
+Tensor和Device的抽象化可以扩展通过不同编程语言以支持大量硬件设备。
 一个新的硬件设备可以通过添加
一个新的Device子类和实现相应的张量操作（xxxMath）加
以支持。
+
+基于速度和空间占用的优化可以被Device实现。 
它管理着操作执行和内存的分配和释放。 
更多的优化细节可以在[Device页面](device.html)看到。
+
+
+## 模型
+
+在Tensor和Device的抽象化之上，SINGA提供了更高级的类用于机器学ä¹
 æ¨¡åž‹ã€‚
+
+* [Layer](layer.html)和它的子类特别用于神经网络。 
每个层为向前传递特征和向后传递梯度提供函数支持。 
它们将复杂的操作封装
起来使用户可以很容易创建神经网络连接一系列层。
+
+* 
[Initializer](initializer.html)和它的子类为初始化模型参数（存储在Tesnor实例中）提供了可变的方法，åŒ
…括Uniform,Gaussian等等。
+
+* [Loss](loss.html)和它的子类定义了训练目标损失函数。与目æ 
‡æŸå¤±å¯¹åº”的计算损失值和计算梯度的函数都已被实现。 
常见的损失函数包括平方差和交叉熵。
+
+* 
[Metric](metric.html)和它的子类提供了评估模型性能的函数，比如精确度。
+
+* 
[Optimizer](optimizer.html)和它的子类实现了如何利用参数梯度更新模型参数的方法，åŒ
…括SGD, AdaGrad, RMSProp等等。
+
+
+## 输入输出
+
+输入输出包含数据加载，数据预处理和信息传递类。
+
+* Reader和它的子类从磁盘文件加载字符串记录
+* Writer和它的子类将字符串记录写到磁盘文件中
+* Encoder和它的子类将Tensor实例编译成字符串记录
+* Decoder和它的子类将字符串记录解码为Tensor实例
+* Endpoint代表为消息传递提供函数的交互终端
+* Message代表Endpoint实例间的交互消息。它会传递å…
ƒæ•°æ®å’Œè´Ÿè½½

http://git-wip-us.apache.org/repos/asf/incubator-singa/blob/c343ff95/doc/zh/docs/tensor.md
----------------------------------------------------------------------
diff --git a/doc/zh/docs/tensor.md b/doc/zh/docs/tensor.md
new file mode 100644
index 0000000..f8cd5b8
--- /dev/null
+++ b/doc/zh/docs/tensor.md
@@ -0,0 +1,683 @@
+# 张量(Tensor)
+
+每个Tensor实例都是一个分配在特定Device实例上的多维数组。 
Tensor实例存储了变量并提供了用户不可见的支持多种设备的代数操作。注意，用户需要确保除了拷贝之外的tensor操作都是在相同的设备上进行的。
+
+Tensor的实现
+
+SINGA有三种Tensor函数的实现，分别在不同设备上。
+
+* `tensor_math_cpp.h` 用Cpp实现了CppCPU上的各种操作
+* `tensor_math_cuda.h` 用Cuda (和cuBLAS)实现了CudaGPU上的各种操作
+* `tensor_math_opencl.h` 用OpenCL实现了OpenclGPU上的各种操作
+
+
+## PYTHON API
+
+用法示例：
+
+```python
+import numpy as np
+from singa import tensor
+from singa import device
+
+# create a tensor with shape (2,3), default CppCPU device and float32
+x = tensor.Tensor((2, 3))
+x.set_value(0.4)
+
+# create a tensor from a numpy array
+npy = np.zeros((3, 3), dtype=np.float32)
+y = tensor.from_numpy(npy)
+
+y.uniform(-1, 1)  # sample values from the uniform distribution
+
+z = tensor.mult(x, y)  # gemm -> z of shape (2, 3)
+
+x += z  # element-wise addition
+
+dev = device.get_default_device()
+x.to_device(dev)  # move the data to a gpu device
+
+r = tensor.relu(x)
+
+s = tensor.to_numpy(r)  # tensor -> numpy array
+```
+
+有两种类型的tensor函数:
+
+**Tensor成员函数**
+
+将会改变Tensor实例的状态
+
+**Tensor模块化函数**
+
+接受Tensor实例作为自变量以及返回Tensor实例
+
+每个Tensor实例在读取数据前都必须做初始化
+
+---
+
+### class singa.tensor.Tensor(shape=None, device=None, dtype=0)
+
+创建Py Tensor，封装了一个基于swig转换的CPP Tensor。
+三个参数分别是Tensor的三个属性。
+
+**参数：**
+- **shape (list<int>)** – 
一个列表的整形数据作为Tensor的形状。如果shape没有指定，将会创建一个伪Tensor。
+- **device** – swig转化的使用设备模块化的Device实例。 
如果为None，默认的CPU设备将会被使用。
+- **dtype** – 数据类型。 目前，大多数操作仅支持kFloat32。
+
+---
+
+#### T()
+
+浅拷贝。
+
+**返回值：** 一个新Tensor，共享底层数据所占内存，但æ 
‡è®°ä¸ºè¯¥tensor的转置版本。
+
+---
+
+#### add_column(v)
+
+对该Tensor每列加上一个tensor。
+
+**参数：**
+- **v (Tensor)** – 被作为一列加到原tensor的Tensor
+
+---
+
+#### add_row(v)
+
+对该tensor每行加一个tensor。
+
+**参数：**
+- **v (Tensor)** – 被作为行加到原tensor的Tensor
+
+---
+
+#### bernoulli(p)
+
+对每个元素，按照给定概率从0/1中取样。
+
+**参数：**
+- **p (float)** – 以概率p取样一个元素为1
+
+---
+
+#### clone()
+
+**返回值：** 一个新Tensor，是待拷贝Tensor的深拷贝
+
+---
+
+#### copy()
+
+调用singa::Tensor的拷贝构造器进行浅拷贝。
+
+---
+
+#### copy_data(t)
+
+从另一个Tensor实例拷贝数据。
+
+**参数：**
+- **t (Tensor)** – 源Tensor
+
+---
+
+#### copy_from_numpy(np_array, offset=0)
+
+从numpy数组中拷贝数据。
+
+**参数：**
+- **np_array** – 源numpy数组
+- **offset (int)** – 目标偏移
+
+---
+
+#### deepcopy()
+
+同clone()
+
+**返回值：** 新Tensor
+
+---
+
+#### div_column(v)
+
+将Tensor每列除以v。
+
+**参数：**
+- **v (Tensor)** – 1维tensor，和源tensor的列长相同
+
+---
+
+#### div_row(v)
+
+将Tensor每行除以v。
+
+**参数：**
+- **v (Tensor)** – 1维tensor，和源tensor的行长相同
+
+---
+
+#### gaussian(mean, std)
+
+按照高斯分布对每个元素采样。
+
+**参数：**
+- **mean (float)** – 分布的均值
+- **std (float)** – 分布的标准差
+
+---
+
+#### is_empty()
+
+**返回值：** 根据tensor的形状，如果是空的返回True
+
+---
+
+#### is_transpose()
+
+**返回值：** 如果内部数据被转置则返回True，否则返回False
+
+---
+
+#### l1()
+
+**返回值：** L1 norm
+
+---
+
+#### l2()
+
+**返回值：** L2 norm
+
+---
+
+#### memsize()
+
+- **返回值：** 被分配给该tensor的Bytes数
+
+---
+
+#### mult_column(v)
+
+将tensor每列和v做元素级别乘法。
+
+**参数：**
+- **v (Tensor)** – 1维tensor，同源tensor列长等长
+
+---
+
+#### mult_row(v)
+
+将tensor每行和v做元素级别乘法。
+
+**参数：**
+- **v (Tensor)** – 1维tensor，同源tensor行长等长
+
+---
+
+#### ndim()
+
+**返回值：** tensor的维度
+
+---
+
+#### reset_like(t)
+
+根据给定tensor重置源tensor形状，数据类型和设备。
+
+**参数：**
+- **t (Tensor)** – 需要重置的tensor
+
+---
+
+#### set_value(x)
+
+设置所有元素值为给定值。
+
+**参数：**
+- **x(float)** - 待设定的值
+
+---
+
+#### size()
+
+**返回值：** tensor中的元素个数
+
+---
+
+#### to_device(device)
+
+将tensor中数据传到指定设备上。
+
+**参数：**
+- **device** - 从CudaGPU/CppCPU/OpenclGPU转换的swig设备
+
+---
+
+#### to_host()
+
+将tensor数据传到默认的CppCPU设备上。
+
+---
+
+#### uniform(low, high)
+
+从均匀分布中进行采样。
+
+**参数：**
+- **low (float)** – 下界
+- **high (float)** – 上界
+
+---
+
+#### singa.tensor.abs(t)
+
+**参数：**
+- **t(Tensor)** - 输入tensor
+
+**返回值：** 一个新tensor，其元素值为y=abs(x)，x是t中的元素
+
+---
+
+#### singa.tensor.add(lhs, rhs, ret=None)
+
+元素级别加法。
+
+**参数：**
+- **lhs (Tensor)** – 左操作tensor
+- **rhs (Tensor)** – 右操作tensor
+- **ret (Tensor, optional)** – 如果不是空， 结果将被保存在å…
¶ä¸­ï¼›å¦åˆ™ï¼Œä¸€ä¸ªæ–°tensor会被创建以保存结果。
+
+**返回值：** 新tensor
+
+---
+
+#### singa.tensor.add_column(alpha, v, beta, M)
+
+将v加到M的每个列向量, 定义M一列为m，m=alpha * v + beta * m
+
+**参数：**
+- **alpha (float)** – v的系数
+- **v (Tensor)** – 1维tensor
+- **beta (float)** – M的系数
+- **M (Tensor)** – 2维tensor
+
+**返回值：** M
+
+---
+
+#### singa.tensor.add_row(alpha, v, beta, M)
+
+将v加到M的每个行向量, 定义M一行为m，m=alpha * v + beta * m。
+
+**参数：**
+- **alpha (float)** – v的系数
+- **v (Tensor)** – 1维tensor
+- **beta (float)** – M的系数
+- **M (Tensor)** – 2维tensor
+
+**返回值：** M
+
+---
+
+#### singa.tensor.average(t, axis=None)
+
+**参数：**
+- **t (Tensor)** – 输入Tensor
+- **axis (int, optional)** – 如果为空，取所有元素
的平均值；否则，取给定维度的元素
平均值。0表示列均值，1表示行均值。
+
+**返回值：** 
如果axis是空，返回一个float值；否则，返回一个新tensor
+
+---
+
+#### singa.tensor.axpy(alpha, x, y)
+
+元素级别操作 y += alpha * x。
+
+**参数：**
+- **alpha (float)** – x的系数
+- **x (Tensor)** – 被加的tensor
+- **y (Tensor)** – 原tensor
+
+**返回值：** y
+
+---
+
+#### singa.tensor.bernoulli(p, t)
+
+对每个元素生成一个二进制位。
+
+**参数：**
+- **p (float)** – each element is 1 with probability p; and 0 with 1 - p
+- **t (Tensor)** – the results are put into t
+
+**返回值：** t
+
+---
+
+#### singa.tensor.copy_data_to_from(dst, src, size, dst_offset=0, src_offset=0)
+
+将数据从一个tensor实例拷贝到另一个tensor实例。
+
+**参数：**
+- **dst (Tensor)** – 目标Tensor
+- **src (Tensor)** – 源Tensor
+- **size (int)** – 拷贝元素数目
+- **dst_offset (int)** – 拷贝到dst元素在dst的起始偏移
+- **src_offset (int)** – 待拷贝的元素在src中的起始偏移
+
+---
+
+#### singa.tensor.div(lhs, rhs, ret=None)
+
+元素级别的除法。
+
+**参数：**
+- **lhs (Tensor)** – 左操作tensor
+- **rhs (Tensor)** – 右操作tensor
+- **ret (Tensor, optional)** – 如果非空，将把结果写å…
¥ï¼›å¦åˆ™ï¼Œåˆ›å»ºä¸€ä¸ªæ–°tensor并将结果写入
+
+**返回值：** 存有运算结果的tensor
+
+---
+
+#### singa.tensor.eltwise_mult(lhs, rhs, ret=None)
+
+元素级别的乘法。
+
+**参数：**
+- **lhs (Tensor)** – 左操作tensor
+- **rhs (Tensor)** – 右操作tensor
+- **ret (Tensor, optional)** – 如果非空，将把结果写å…
¥ï¼›å¦åˆ™ï¼Œåˆ›å»ºä¸€ä¸ªæ–°tensor并将结果写入
+
+**返回值：** 保存运算结果的tensor
+
+---
+
+#### singa.tensor.exp(t)
+
+**参数：**
+- **t (Tensor)** – 输入tensor
+
+**返回值：** 新tensor，其中元素为 y = exp(x)，x为t中元素
+
+---
+
+#### singa.tensor.from_numpy(np_array)
+
+根据numpy数组的形状、数据类型和数值创建一个tensor。
+
+**参数：**
+- **np_array** – numpy数组
+
+**返回值：** 分配在默认CppCPU设备上的tensor实例
+
+---
+
+#### singa.tensor.gaussian(mean, std, t)
+
+按照给定高斯分布生成数值。
+
+**参数：**
+- **mean (float)** – 高斯分布的均值
+- **std (float)** – 高斯分布的标准差
+- **t (Tensor)** – 结果被存入t
+
+**返回值：** t
+
+---
+
+#### singa.tensor.ge(t, x)
+
+元素级别的比较，t >= x。
+
+**参数：**
+- **t (Tensor)** – 左操作数
+- **x (Tensor or float)** – 右操作数
+
+**返回值：** 0.0f 或 t[i] >= x[i] ? 1.0f:0.0f
+
+**返回值类型：** tensor，每个元素为 t[i] >= x ? 1.0f
+
+---
+
+#### singa.tensor.gt(t, x)
+
+元素级别的比较，t > x。
+
+**参数：**
+- **t (Tensor)** – 左操作tensor
+- **x (Tensor or float)** – 右操作tensor或数
+
+**返回值：** 0.0f 或 t[i] > x[i] ? 1.0f:0.0f
+
+**返回值类型：** tensor，每个元素为 t[i] > x ? 1.0f
+
+---
+
+#### singa.tensor.le(t, x)
+
+元素级别的比较，t <= x。
+
+**参数：**
+- **t (Tensor)** – 左操作tensor
+- **x (Tensor or float)** – 右操作tensor或数
+
+**返回值：** 0.0f 或 t[i] <= x[i] ? 1.0f:0.0f
+
+**返回值类型：** tensor，每个元素为 t[i] <= x ? 1.0f
+
+---
+
+#### singa.tensor.lt(t, x)
+
+元素级别的比较，t < x。
+
+**参数：**
+- **t (Tensor)** – 左操作tensor
+- **x (Tensor or float)** – 右操作tensor或数
+
+**返回值：** 0.0f 或 t[i] < x[i] ? 1.0f:0.0f
+
+**返回值类型：** tensor，每个元素为 t[i] < x ? 1.0f
+
+---
+
+#### singa.tensor.log(t)
+
+**参数：**
+- **t (Tensor)** – 输入tensor
+
+**返回值：** 一个新tensor，其元素值为y = log(x)，x是t中的å…
ƒç´ 
+
+---
+
+#### singa.tensor.mult(A, B, C=None, alpha=1.0, beta=0.0)
+
+矩阵-矩阵或矩阵-向量乘法, 函数返回 C = alpha * A * B + beta * 
C。
+
+**参数：**
+- **A (Tensor)** – 2维Tensor
+- **B (Tensor)** – 如果B是1维Tensor, 
将调用GEMV做矩阵-向量乘法；否则将调用GEMM。
+- **C (Tensor, optional)** – 
存储结果；如果为空，将创建新tensor存储结果。
+- **alpha (float)** – A * B 的系数
+- **beta (float)** – C 的系数
+
+**返回值：** 保存运算结果的tensor
+
+---
+
+#### singa.tensor.pow(t, x, out=None)
+
+**参数：**
+- **t (Tensor)** – 输入tensor
+- **x (float or Tensor)** – 如果x是浮点数 y[i] = t[i]^x; 否则 y[i]= 
t[i]^x[i]
+- **out (None or Tensor)** – 如果非空，将存å…
¥ç»“果；否则，将创建一个新tensor保存结果。
+
+**返回值：** 保存运算结果的tensor
+
+---
+
+#### singa.tensor.relu(t)
+
+**参数：**
+- **t (Tensor)** – 输入tensor
+
+**返回值：** tensor，其中元素为 y = x 若x >0；否则y = 
0，x为t中元素
+
+---
+
+#### singa.tensor.reshape(t, s)
+
+改变tensor的形状。
+
+**参数：**
+- **t (Tensor)** – 待改变形状的tensor
+- **s (list<int>)** – 新形状，体积和原tensor体积相同
+
+**返回值：** 新tensor
+
+---
+
+#### singa.tensor.sigmoid(t)
+
+**参数：**
+- **t (Tensor)** – 输入tensor
+
+**返回值：** tensor，其中元素为 y = sigmoid(x)，x为t中元素
+
+---
+
+#### singa.tensor.sign(t)
+
+**参数：**
+- **t (Tensor)** – 输入tensor
+
+**返回值：** tensor，其中元素为 y = sign(x)，x为t中元素
+
+---
+
+#### singa.tensor.sizeof(dtype)
+
+**返回值：** 
依据core.proto中定义的SINGA数据类型，返回给定类型所占
Byte数目
+
+---
+
+#### singa.tensor.softmax(t, out=None)
+
+对tensor每行做SoftMax。
+
+**参数：**
+- **t (Tensor)** – 输入1维或2维tensor
+- **out (Tensor, 可选)** – 如果非空，将存入结果
+
+**返回值：** 保存操作结果的tensor
+
+---
+
+#### singa.tensor.sqrt(t)
+
+**参数：**
+- **t (Tensor)** – 输入tensor
+
+**返回值：** tensor，其中元素为 y = sqrt(x)，x为t中元素
+
+---
+
+#### singa.tensor.square(t)
+
+**参数：** 
+- **t (Tensor)** – 输入tensor
+
+**返回值：** tensor，其中元素为 y = x * x，x为t中元素
+
+---
+
+#### singa.tensor.sub(lhs, rhs, ret=None)
+
+元素级别的减法。
+
+**参数：**
+- **lhs (Tensor)** – 左操作tensor
+- **rhs (Tensor)** – 右操作tensor
+- **ret (Tensor, 可选)** – 如果非空，将存å…
¥ç»“果；否则，将创建一个新tensor保存
+
+**返回值：** 存放结果的tensor
+
+---
+
+#### singa.tensor.sum(t, axis=None)
+
+在给定的维度上求和。
+
+**参数：**
+- **t (Tensor)** – 输入Tensor
+- **axis (int, 可选)** – 如果为空，将对所有元素
求和；如果给定数值，将沿给定维度求和，比如：0 - 
按列求和；1 - 按行求和。
+
+**返回值：** 
如果是对整体求和，返回一个浮点数；否则返回tensor
+
+---
+
+#### singa.tensor.sum_columns(M)
+
+按列求和。
+
+**参数：**
+- **M (Tensor)** – 输入的2维tensor
+
+**返回值：** 产生求和结果的tensor
+
+---
+
+#### singa.tensor.sum_rows(M)
+
+按行求和。
+
+**参数：**
+- **M (Tensor)** – 输入的2维tensor
+
+**返回值：** 产生求和结果的tensor
+
+---
+
+#### singa.tensor.tanh(t)
+
+**参数：**
+- **t (Tensor)** – 输入tensor
+
+**返回值：**tensor，其中元素为 y = tanh(x)，x为t中元素
+
+---
+
+#### singa.tensor.to_host(t)
+
+将数据拷贝到host设备上。
+
+---
+
+#### singa.tensor.to_numpy(t)
+
+拷贝tensor数据到numpy数组。
+
+**参数：**
+- **t (Tensor)** – 输入tensor
+
+**返回值：** numpy数组
+
+---
+
+#### singa.tensor.uniform(low, high, t)
+
+按照均匀分布生成数值。
+
+**参数：**
+- **low (float)** – 下界
+- **hight (float)** – 上届
+- **t (Tensor)** – 结果存入t
+
+**返回值：** t
+
+---

http://git-wip-us.apache.org/repos/asf/incubator-singa/blob/c343ff95/doc/zh/docs/utils.md
----------------------------------------------------------------------
diff --git a/doc/zh/docs/utils.md b/doc/zh/docs/utils.md
new file mode 100644
index 0000000..41a60d1
--- /dev/null
+++ b/doc/zh/docs/utils.md
@@ -0,0 +1,13 @@
+# Utils
+
+---
+
+#### singa.utils.update_progress(progress, info)
+
+显示完成进程条和用户信息。
+
+**参数：**
+- **progress (float)** – 完成度[0, 
1]，负数表示被中断，>=1表示以完成
+- **info (str)** – 待展示信息的字符串
+
+---