numpy计算函数和tf计算函数

numpy计算函数

1、np.random.choice()

参数意思分别 是从a 中以概率P，随机选择3个, p没有指定的时候相当于是一致的分布
a1 = np.random.choice(a=5, size=3, replace=False, p=None)
非一致的分布，会以多少的概率提出来
a2 = np.random.choice(a=5, size=3, replace=False, p=[0.2, 0.1, 0.3, 0.4, 0.0])

2、np.roll()

np.roll(a, shift, axis=None)
沿着给定轴滚动数组元素。超出最后位置的元素将会滚动到第一个位置。
#将a沿着axis的方向滚动shfit长度

3、np.reshape()

在不改变矩阵的数值前提下修改矩阵的形状。
新数组的shape属性应该要与原来数组的一致，即新数组元素数量与原数组元素数量要相等。一个参数为-1时，那么reshape函数会根据另一个参数的维度计算出数组的另外一个shape属性值。
例子：

# z: 
array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])
# z.reshape(-1,2): 
array([[1, 2],
		[3, 4],
		[5, 6],
		[7, 8],
		[9, 10],
		[11, 12],
		[13, 14],
		[16,16]])

tf计算函数

1、tf.placeholder(dtype, shape=None, name=None)

placeholder，占位符，在tensorflow中类似于函数参数，运行时必须传入值。
dtype：数据类型。常用的是tf.float32,tf.float64等数值类型。
shape：数据形状。默认是None，就是一维值，也可以是多维，比如[2,3], [None, 3]表示列是3，行不定。
name：名称。

2、tf.unstack(value, num=None, axis=0, name=‘unstack’ )

value：代表需要分解的矩阵变量（其实就是一个多维数组，一般为二维）；
axis：指明对矩阵的哪个维度进行分解。axis=0按行分解，axis=1按列分解
例子：

c = tf.constant([[1,2,3], [4,5,6]])
d = tf.unstack(c, axis=0)
e = tf.unstack(c, axis=1)
d: array[[1,2,3], [4,5,6]]
e: array[[1,4], [2,5], [3,6]]

3、tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

用于从“服从指定正态分布的序列”中随机取出指定个数的值。
shape: 输出张量的形状，必选
mean: 正态分布的均值，默认为0
stddev: 正态分布的标准差，默认为1.0
dtype: 输出的类型，默认为tf.float32
seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样
name: 操作的名称
例子：

import tensorflow as tf 
w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1)) 
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(w1))
# 结果：
[[-0.81131822  1.48459876  0.06532937]
 [-2.4427042   0.0992484   0.59122431]]

4、tf.reduce_sum(input_tensor, axis=None, keepdims=None,name=None,reduction_indices=None, keep_dims=None)

input_tensor：待求和的tensor;
axis：指定的维，如果不指定，则计算所有元素的总和;
keepdims：是否保持原有张量的维度，设置为True，结果保持输入tensor的形状，设置为False，结果会降低维度，如果不传入这个参数，则系统默认为False;
name：操作的名称;
reduction_indices：在以前版本中用来指定轴，已弃用;
keep_dims：在以前版本中用来设置是否保持原张量的维度，已弃用;
例子：

tensor:
[[[ 1   2   3   4]
  [ 5   6   7   8]
  [ 9   10 11 12]],
 [[ 13  14 15 16]
  [ 17  18 19 20]
  [ 21  22 23 24]]]

tf.reduce_sum(tensor, axis=0) axis=0 说明是按第一个维度进行求和。那么求和结果shape是3*4

[[1+13   2+14   3+15 4+16]
 [5+17   6+18   7+19 8+20]
 [9+21 10+22 11+23 12+24]]

依次类推，如果axis=1，那么求和结果shape是2*4，即：

[[ 1 + 5 + 9   2 + 6+10   3 + 7+11   4 + 8+12]
 [13+17+21     14+18+22   15+19+23   16+20+24]]

如果axis=2，那么求和结果shape是2*3，即：

[[1+2+3+4          5+6+7+8          9+10+11+12]
 [13+14+15+16      17+18+19+20      1+22+23+24]]

5、tf.nn.relu()

tf.nn.relu()函数是将大于0的数保持不变，小于0的数置为0

import tensorflow as tf 
a = tf.constant([[-2,-4],[4,-2]])
with tf.Session() as sess:
 	print(sess.run(tf.nn.relu(a)))
# 结果：
[[0,0],
[4,0]]

6、tf.add( x,y, name=None)：

矩阵x与矩阵y的每个数相加

import tensorflow as tf      
x=tf.constant([[1,2],[1,2]])    
y=tf.constant([[1,1],[1,2]])  
z=tf.add(x,y)  
# 结果：
[[2,3],
[2,4]]

7、tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)

tf.nn.conv2d是TensorFlow里面实现卷积的函数。
input：指需要做卷积的输入图像，它要求是一个Tensor，具有[batch, in_height, in_width, in_channels]这样的shape，具体含义是[训练时一个batch的图片数量, 图片高度, 图片宽度, 图像通道数]，注意这是一个4维的Tensor，要求类型为float32和float64其中之一，in_channel 为图片的通道数，灰度图该值为1，彩色图为3。
filter：卷积核，它要求是一个Tensor，具有[filter_height, filter_width, in_channels, out_channels]这样的shape，具体含义是[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数]，要求类型与参数input相同，有一个地方需要注意，第三维in_channels，就是参数input的第四维。
strides：卷积时在图像每一维的步长，这是一个一维的向量，长度4，[ 1, strides, strides, 1]，第一位和最后一位固定必须是1。
padding：string类型的量，只能是"SAME","VALID"其中之一，这个值决定了不同的卷积方式，是否考虑边界。"SAME"是考虑边界，不足的时候用0去填充周围，"VALID"则不考虑。
use_cudnn_on_gpu：bool类型，是否使用cudnn加速，默认为true。
结果返回一个Tensor，这个输出，就是feature map，shape仍然是[batch, height, width, channels]这种形式。

8、tf.nn.max_pool(value, ksize, strides, padding, name=None)

value：需要池化的输入，一般池化层接在卷积层后面，所以输入通常是feature map，依然是[batch, height, width, channels]这样的shape。
ksize：池化窗口的大小，取一个四维向量，一般是[1, height, width, 1]，因为我们不想在batch和channels上做池化，所以这两个维度设为了1。
strides：和卷积类似，窗口在每一个维度上滑动的步长，一般也是[1, stride,stride, 1]。
padding：和卷积类似，可以取’VALID’ 或者’SAME’，是否考虑边界。"SAME"是考虑边界，不足的时候用0去填充周围，"VALID"则不考虑。
返回一个Tensor，类型不变，shape仍然是[batch, height, width, channels]这种形式

9、tf.nn.dropout(x, keep_prob, noise_shape=None, seed=None, name=None)

此函数是为了防止在训练中过拟合的操作，将训练输出按一定规则进行变换
Dropout原理简述：
tf.nn.dropout是TensorFlow里面为了防止或减轻过拟合而使用的函数，它一般用在全连接层。
Dropout就是在不同的训练过程中随机扔掉一部分神经元。也就是让某个神经元的激活值以一定的概率p，让其停止工作，这次训练过程中不更新权值，也不参加神经网络的计算。但是它的权重得保留下来（只是暂时不更新而已），因为下次样本输入时它可能又得工作了。
x：输入
keep_prob：设置神经元被选中的概率,在初始化时keep_prob是一个占位符, keep_prob = tf.placeholder(tf.float32) 。tensorflow在run时设置keep_prob具体的值，例如keep_prob: 0.5
noise_shape：干扰形状。 此字段默认是None，表示第一个元素的操作都是独立，但是也不一定。比例：数据的形状是shape(x)=[k, l, m, n]，而noise_shape=[k, 1, 1, n]，则第1和4列是独立保留或删除，第2和3列是要么全部保留，要么全部删除。
seed：整形变量，随机数种子。
name：指定该操作的名字

10、交叉熵函数

tf.nn.sigmoid_cross_entropy_with_logits(_sentinel=None,labels=None, logits=None, name=None)

_sentinel:本质上是不用的参数，不用填
logits:计算的输出，注意是为使用softmax或sigmoid的，维度一般是[batch_size, num_classes] ，单样本是[num_classes]。数据类型（type）是float32或float64;
labels:和logits具有相同的type(float)和shape的张量(tensor)，即数据类型和张量维度都一致。
name:操作的名字，可填可不填。
输出：loss，shape:[batch_size,num_classes]
注意:它对于输入的logits先通过sigmoid函数计算，再计算它们的交叉熵，但是它对交叉熵的计算方式进行了优化，使得结果不至于溢出。output不是一个数，而是一个batch中每个样本的loss,所以一般配合tf.reduce_mea(loss)使用。