a = [[1.,2.],[3.,4.]]
b = torch.tensor(a)
# c = torch.tensor(b,dtype=torch.int)
c = b.clone().type(torch.int)

print(b)
print(c)

更多函数的使用：http://blog.csdn.net/lenbow/article/details/52152766
 
参考博客：http://www.mamicode.com/info-detail-1823840.html
 
生成全0和全1的矩阵
 
tf.ones(shape,type=tf.float32,name=None)
 tf.zeros(shape, type=tf.float32,name=None)
 
 
 
>>> x = tf.zeros([2, 3])
>>> sess.run(x)
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]], dtype=float32)
>>> y = tf.ones([2, 3])
>>> sess.run(y)
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)

 
  
 
tf.ones_like(tensor,dype=None,name=None) 
 
tf.zeros_like(tensor,dype=None,name=None) 
 新建一个与给定的tensor类型大小一致的tensor，其所有元素为1和0
 
 
 
>>> xx = tf.ones_like(x)
>>> sess.run(xx)
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> yy = tf.zeros_like(y)
>>> sess.run(yy)
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]], dtype=float32)
 
 

 
 
tf.fill(shape,value,name=None) 
 创建一个形状大小为shape的tensor，其初始值为value
 
 
 
>>> z = tf.fill([2, 3], 2)
>>> sess.run(z)
array([[2, 2, 2],
       [2, 2, 2]])
 
 

 
 
生成随机数： 
（1）tf.random_normal(shape,mean=0.0,stddev=1.0,dtype=tf.float32,seed=None,name=None) 
 
random_normal: 正太分布随机数，均值mean,标准差stddev 
 
 
（2）tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None) 
 
truncated_normal:截断正态分布随机数，均值mean,标准差stddev,不过只保留[mean-2*stddev,mean+2*stddev]范围内的随机数 
 
 
（3）tf.random_uniform(shape,minval=0,maxval=None,dtype=tf.float32,seed=None,name=None) 
 
random_uniform:均匀分布随机数，范围为[minval,maxval]
 
 
（4）tf.random_shuffle(value,seed=None,name=None) 
 沿着value的第一维进行随机重新排列
 
 
 
>>> sess.run(tf.random_normal([2, 3], 0.0, 0.05))
array([[-0.09716501, -0.00082436,  0.00082046],
       [ 0.04063983,  0.06137555, -0.03889754]], dtype=float32)
>>> sess.run(tf.random_uniform([2, 3], 1, 6))
array([[ 1.53847492,  4.09809971,  2.94473267],
       [ 4.00791836,  3.95637321,  5.24030209]], dtype=float32)
 
 
>>> c = tf.constant([[1, 2, 3],[4, 5, 6]])
>>> sess.run(tf.random_shuffle(c))
array([[4, 5, 6],
       [1, 2, 3]])
 
 
 tf.constant
 
 
 
tf.constant(value,dtype=None,shape=None,name=’Const’) 
 
 
 
>>> sess = tf.InteractiveSession()
>>> a = tf.constant(2, tf.float32, [2, 3])
>>> a.eval()
array([[ 2.,  2.,  2.],
       [ 2.,  2.,  2.]], dtype=float32)
>>> a = tf.constant(2., shape=[2, 3])
>>> a.eval()
array([[ 2.,  2.,  2.],
       [ 2.,  2.,  2.]], dtype=float32)


 

 
 
tf.shape(Tensor)  
返回张量的形状，tf.shape函数本身也是返回一个张量
 
 
>>> sess.run(tf.shape(x))
array([2, 3])

 tf.expand_dims(Tensor, dim) 
  
 
为tensor增维和降维
 
 
>>> a = tf.zeros([3])
>>> sess.run(tf.shape(a))
array([3])
>>> sess.run(tf.shape(tf.expand_dims(a, 0)))
array([1, 3])
>>> sess.run(tf.shape(tf.expand_dims(a, 1)))
array([3, 1])
 

 
 

 
 
 基本算术运算
 
 
  
 
操作
描述
 tf.add(x, y, name=None)
 求和
 tf.sub(x, y, name=None)
 减法
 tf.mul(x, y, name=None)
 乘法
 tf.div(x, y, name=None)
 除法
 tf.mod(x, y, name=None)
 取模
 tf.abs(x, name=None)
 求绝对值
 tf.neg(x, name=None)
 取负 (y = -x).
 tf.sign(x, name=None)
 返回符号 y = sign(x) = -1 if x < 0; 0 if x == 0; 1 if x > 0.
 tf.inv(x, name=None)
 取反
 tf.square(x, name=None)
 计算平方 (y = x * x = x^2).
 tf.round(x, name=None)
 舍入最接近的整数
 # ‘a’ is [0.9, 2.5, 2.3, -4.4]
 tf.round(a) ==> [ 1.0, 3.0, 2.0, -4.0 ]
 tf.sqrt(x, name=None)
 开根号 (y = \sqrt{x} = x^{1/2}).
 tf.pow(x, y, name=None)
 幂次方 
 # tensor ‘x’ is [[2, 2], [3, 3]]
 # tensor ‘y’ is [[8, 16], [2, 3]]
 tf.pow(x, y) ==> [[256, 65536], [9, 27]]
 tf.exp(x, name=None)
 计算e的次方
 tf.log(x, name=None)
 计算log，一个输入计算e的ln，两输入以第二输入为底
 tf.maximum(x, y, name=None)
 返回最大值 (x > y ? x : y)
 tf.minimum(x, y, name=None)
 返回最小值 (x < y ? x : y)
 tf.cos(x, name=None)
 三角函数cosine
 tf.sin(x, name=None)
 三角函数sine
 tf.tan(x, name=None)
 三角函数tan
 tf.atan(x, name=None)
 三角函数ctan
 
 矩阵运算
 
  
 
操作
描述
 tf.diag(diagonal, name=None)
 返回一个给定对角值的对角tensor
 # ‘diagonal’ is [1, 2, 3, 4]
 tf.diag(diagonal) ==> 
 [[1, 0, 0, 0]
 [0, 2, 0, 0]
 [0, 0, 3, 0]
 [0, 0, 0, 4]]
 tf.diag_part(input, name=None)
 功能与上面相反
 tf.trace(x, name=None)
 求一个2维tensor足迹，即对角值diagonal之和
 tf.transpose(a, perm=None, name=’transpose’)
 调换tensor的维度顺序
 按照列表perm的维度排列调换tensor顺序，
 如为定义，则perm为(n-1…0)
 # ‘x’ is [[1 2 3],[4 5 6]]
 tf.transpose(x) ==> [[1 4], [2 5],[3 6]]
 # Equivalently
 tf.transpose(x, perm=[1, 0]) ==> [[1 4],[2 5], [3 6]]
 tf.matmul(a, b, transpose_a=False, 
 transpose_b=False, a_is_sparse=False, 
 b_is_sparse=False, name=None)
 矩阵相乘
 tf.matrix_determinant(input, name=None)
 返回方阵的行列式
 tf.matrix_inverse(input, adjoint=None, name=None)
 求方阵的逆矩阵，adjoint为True时，计算输入共轭矩阵的逆矩阵
 tf.cholesky(input, name=None)
 对输入方阵cholesky分解，
 即把一个对称正定的矩阵表示成一个下三角矩阵L和其转置的乘积的分解A=LL^T
 tf.matrix_solve(matrix, rhs, adjoint=None, name=None)
 求解tf.matrix_solve(matrix, rhs, adjoint=None, name=None)
 matrix为方阵shape为[M,M],rhs的shape为[M,K]，output为[M,K]
 
 复数操作
 
  
 
操作
描述
 tf.complex(real, imag, name=None)
 将两实数转换为复数形式
 # tensor ‘real’ is [2.25, 3.25]
 # tensor imag is [4.75, 5.75]
 tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
 tf.complex_abs(x, name=None)
 计算复数的绝对值，即长度。
 # tensor ‘x’ is [[-2.25 + 4.75j], [-3.25 + 5.75j]]
 tf.complex_abs(x) ==> [5.25594902, 6.60492229]
 tf.conj(input, name=None)
 计算共轭复数
 tf.imag(input, name=None)
 tf.real(input, name=None)
 提取复数的虚部和实部
 tf.fft(input, name=None)
 计算一维的离散傅里叶变换，输入数据类型为complex64
 
 归约计算(Reduction)
 
  
 
操作
描述
 tf.reduce_sum(input_tensor, reduction_indices=None, 
 keep_dims=False, name=None)
 计算输入tensor元素的和，或者安照reduction_indices指定的轴进行求和
 # ‘x’ is [[1, 1, 1]
 # [1, 1, 1]]
 tf.reduce_sum(x) ==> 6
 tf.reduce_sum(x, 0) ==> [2, 2, 2]
 tf.reduce_sum(x, 1) ==> [3, 3]
 tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]]
 tf.reduce_sum(x, [0, 1]) ==> 6
 tf.reduce_prod(input_tensor, 
 reduction_indices=None, 
 keep_dims=False, name=None)
 计算输入tensor元素的乘积，或者安照reduction_indices指定的轴进行求乘积
 tf.reduce_min(input_tensor, 
 reduction_indices=None, 
 keep_dims=False, name=None)
 求tensor中最小值
 tf.reduce_max(input_tensor, 
 reduction_indices=None, 
 keep_dims=False, name=None)
 求tensor中最大值
 tf.reduce_mean(input_tensor, 
 reduction_indices=None, 
 keep_dims=False, name=None)
 求tensor中平均值
 tf.reduce_all(input_tensor, 
 reduction_indices=None, 
 keep_dims=False, name=None)
 对tensor中各个元素求逻辑’与’
 # ‘x’ is 
 # [[True, True]
 # [False, False]]
 tf.reduce_all(x) ==> False
 tf.reduce_all(x, 0) ==> [False, False]
 tf.reduce_all(x, 1) ==> [True, False]
 tf.reduce_any(input_tensor, 
 reduction_indices=None, 
 keep_dims=False, name=None)
 对tensor中各个元素求逻辑’或’
 tf.accumulate_n(inputs, shape=None, 
 tensor_dtype=None, name=None)
 计算一系列tensor的和
 # tensor ‘a’ is [[1, 2], [3, 4]]
 # tensor b is [[5, 0], [0, 6]]
 tf.accumulate_n([a, b, a]) ==> [[7, 4], [6, 14]]
 tf.cumsum(x, axis=0, exclusive=False, 
 reverse=False, name=None)
 求累积和
 tf.cumsum([a, b, c]) ==> [a, a + b, a + b + c]
 tf.cumsum([a, b, c], exclusive=True) ==> [0, a, a + b]
 tf.cumsum([a, b, c], reverse=True) ==> [a + b + c, b + c, c]
 tf.cumsum([a, b, c], exclusive=True, reverse=True) ==> [b + c, c, 0]
 
 序列比较与索引提取(Sequence Comparison and Indexing)
 
  
 
操作
描述
 tf.argmin(input, dimension, name=None)
 返回input最小值的索引index
 tf.argmax(input, dimension, name=None)
 返回input最大值的索引index
 tf.listdiff(x, y, name=None)
 返回x，y中不同值的索引
 tf.where(input, name=None)
 返回bool型tensor中为True的位置
 # ‘input’ tensor is 
 #[[True, False]
 #[True, False]]
 # ‘input’ 有两个’True’,那么输出两个坐标值.
 # ‘input’的rank为2, 所以每个坐标为具有两个维度.
 where(input) ==>
 [[0, 0],
 [1, 0]]
 tf.unique(x, name=None)
 返回一个元组tuple(y,idx)，y为x的列表的唯一化数据列表，
 idx为x数据对应y元素的index
 # tensor ‘x’ is [1, 1, 2, 4, 4, 4, 7, 8, 8]
 y, idx = unique(x)
 y ==> [1, 2, 4, 7, 8]
 idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
 tf.invert_permutation(x, name=None)
 置换x数据与索引的关系
 # tensor x is [3, 4, 0, 2, 1]
 invert_permutation(x) ==> [2, 4, 3, 0, 1]
 

 

开始学习pytorch 看到rand randn 函数感觉奇怪 所以找了下面文章区分
 
 
 
https://zhuanlan.zhihu.com/p/31231210
 
 
 
均匀分布
 
torch.rand(*sizes, out=None) → Tensor
 
返回一个张量，包含了从区间[0, 1)的均匀分布中抽取的一组随机数。张量的形状由参数sizes定义。
 
参数:
 
sizes (int...) - 整数序列，定义了输出张量的形状
out (Tensor, optinal) - 结果张量
例子：
 

 torch.rand(2, 3)
 
 0.0836 0.6151 0.6958
 
 0.6998 0.2560 0.0139
 
 [torch.FloatTensor of size 2x3]
 
 
 
标准正态分布
 
torch.randn(*sizes, out=None) → Tensor
 
返回一个张量，包含了从标准正态分布（均值为0，方差为1，即高斯白噪声）中抽取的一组随机数。张量的形状由参数sizes定义。
 
参数:
 
sizes (int...) - 整数序列，定义了输出张量的形状
out (Tensor, optinal) - 结果张量
例子：
 

 torch.randn(2, 3)
 
 0.5419 0.1594 -0.0413
 
 -2.7937 0.9534 0.4561
 
 [torch.FloatTensor of size 2x3]
 
 
 
离散正态分布
 
torch.normal(means, std, out=None) → → Tensor
 
返回一个张量，包含了从指定均值means和标准差std的离散正态分布中抽取的一组随机数。
 
标准差std是一个张量，包含每个输出元素相关的正态分布标准差。
 
参数:
 
means (float, optional) - 均值
std (Tensor) - 标准差
out (Tensor) - 输出张量
例子：
 

 torch.normal(mean=0.5, std=torch.arange(1, 6))
 
 -0.1505
 
 -1.2949
 
 -4.4880
 
 -0.5697
 
 -0.8996
 
 [torch.FloatTensor of size 5]
 
 
 
线性间距向量
 
torch.linspace(start, end, steps=100, out=None) → Tensor
 
返回一个1维张量，包含在区间start和end上均匀间隔的step个点。
 
输出张量的长度由steps决定。
 
参数：
 
start (float) - 区间的起始点
end (float) - 区间的终点
steps (int) - 在start和end间生成的样本数
out (Tensor, optional) - 结果张量
例子：
 

 torch.linspace(3, 10, steps=5)
 
 3.0000
 
 4.7500
 
 6.5000
 
 8.2500
 
 10.0000
 
 [torch.FloatTensor of size 5]

通过使用Math.round() 和 Math.random()获取指定范围内的随机整数
 
/**
 * 获取指定范围内的随机整数
 * @param  { Number } n 开始数字
 * @param  { Number } m 结束数字
 * @return { Number } 获取的随机数字
 */
const random = function (n,m) {
    if(!Number(n))
        throw new Error(`${n} is not Number`)
    if(!Number(m))
        throw new Error(`${m} is not Number`)
    return Math.round(Math.random() * (m - n) + n)
}