tensorflow中用到的一些代码含义总结

---

os.environ 打印输出信息

这是设置log输出信息的，也就是程序运行时系统打印的信息。数字不同，打印报错的等级不同。
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

with open（） as 读取文件

with open('parameters/xxx.json') as json_file: # 括号里面是文件的位置
hp = json.load(json_file)

读取xxx文件，xxx文件作为（as） json_file, Load加载里面的参数给hp

for name,value in xxx.items(): 遍历（键，值）

    for name,value in in_hp.items():
        hp[name] = value

items返回可遍历的(键, 值) 元组数组,这里XXX={}，如下图

namedtuple 转换类型

在前json.load后，得到的是一个字典类型的变量，可以将其转换成namedtuple类型，使用更方便。

	hp = namedtuple('hp', hp.keys())(**hp)
    evaluation = namedtuple('evaluation', evaluation.keys())(**evaluation)
    run = namedtuple('run', run.keys())(**run)
    env = namedtuple('env', env.keys())(**env)
    design = namedtuple('design', design.keys())(**design)

• (**hp) 是将字典hp的值传入namedtuple的hp,后面类似
  namedtuple类位于collections模块,有了namedtuple后通过属性访问数据能够让我们的代码更加的直观更好维护。
  namedtuple能够用来创建类似于元组的数据类型，除了能够用索引来访问数据，能够迭代，还能够方便的通过属性名来访问数据。

tf.placeholder 设定占位符

• Tensorflow中的palceholder，中文翻译为占位符

• 在Tensoflow2.0以前，还是静态图的设计思想，整个设计理念是计算流图，在编写程序时，首先构筑整个系统的graph，代码并不会直接生效，这一点和python的其他数值计算库（如Numpy等）不同，graph为静态的，在实际的运行时，启动一个session，程序才会真正的运行。

• 这样做的好处就是：避免反复地切换底层程序实际运行的上下文，tensorflow帮你优化整个系统的代码。我们知道，很多python程序的底层为C语言或者其他语言，执行一行脚本，就要切换一次，是有成本的，tensorflow通过计算流图的方式，可以帮你优化整个session需要执行的代码。

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

• dtype：数据类型。常用的是tf.float32,tf.float64等数值类型
• shape：数据形状。默认是None，就是一维值，也可以是多维（比如[2,3], [None, 3]表示列是3，行不定）
• name：名称

tf.read_file 读取文件

image_file = tf.read_file(filename) 读取文件

tf.read_file(
    filename,
    name=None
)
读取并输出输入文件名的全部内容。
filename：	string类型的Tensor。
name：		操作的名称（可选）。
返回string类型的Tensor。

tf.image.resize 改变图片大小，这一部分好像坑很多，使用小心

Tensorflow使用教训：被tf.image.resize浪费的60天
小心使用tf.image.resize_images，填坑经验分享给你
不要用tf.image.resize改变大小

tf.image.resize_images(image， （w， h）， method)
image表示需要改变此存的图像，
第二个参数改变之后图像的大小，
method用于表示改变图像过程用的差值方法。
0：双线性差值。1：最近邻居法。2：双三次插值法。3：面积插值法。

上面两种插值方法都不会造成像素值越界
如果需要确保返回结果是在正常范围内的，那就在上面两个方法中选一个。此外，最邻近插值会带来比较明显的“不连续感”，因此推荐选择双线性插值，同时它也是默认参数。

tf.image.decode_jpeg 图像解码

image = tf.image.decode_jpeg(image_file) 将图像解码为JPEG文件，这将使其成为张量

tf.image.decode_image(
    contents,
    channels=None,
    name=None
)
类似的还有解码BMP,GIF,JPEG,PNG
decode_bmp,decode_gif,decode_jpeg和decode_png的方便函数.
检测图像是否为BMP,GIF,JPEG或PNG,并执行相应的操作将输入字节string转换为类型uint8的Tensor.

注意: decode_gif返回一个4维数组[num_frames、高度、宽度、3],而不是decode_bmp、decode_jpeg和decode_png,后者返回3维数组[height, width, num_channels].如果使用BMP、JPEG或PNG文件混合GIF文件,请确保在构造图表时考虑到这一点.

contents：0-D string,编码的图像字节.
channels：可选的int,默认为0,解码图像的颜色通道数量.
name：操作的名称(可选)
返回值：

对于BMP、JPEG和PNG图像,形状为[height, width, num_channels]或者对于GIF图像,形状为[num_frames, height, width, 3]的类型为uint8的Tensor.
可能引发的异常：
ValueError：通道数量不正确.

tf.image.convert_image_dtype 转换图片格式

这里要注意下 tf.image.convert_image_dtype(image, tf.float32)，转换图片格式，其他格式转换成float32会进行归一化，所以如果是float32，那么需要自己保证输入值在0-1之间。

tf.shape 获得矩阵维度

tf.shape(
    input,
    name=None,
    out_type=tf.int32 （默认）
)

将矩阵的维度输出为一个维度矩阵 例如：

import tensorflow as tf
import numpy as np

A = np.array([[[1, 1, 1],
               [2, 2, 2]],
              [[3, 3, 3],
               [4, 4, 4]],
              [[5, 5, 5],
               [6, 6, 6]]])

t = tf.shape(A)
with tf.Session() as sess:
    print(sess.run(t))

# 输出
[3 2 3] 这里 [3   第一个3指的3个矩阵
		      2   第二个2指的2个横
		      3   第三个3指的3个列]

tf.reduce_mean 求（降低）平均值

函数用于计算张量tensor沿着指定的数轴（tensor的某一维度）上的的平均值，主要用作降维或者计算tensor（图像）的平均值。

reduce_mean(input_tensor,
            axis=None,
            keep_dims=False,
         	name=None,
            reduction_indices=None)
input_tensor： 输入的待降维的tensor;
axis： 指定的轴，如果不指定，则计算所有元素的均值;
keep_dims：是否降维度，设置为True，输出的结果保持输入tensor的形状，设置为False，输出结果会降低维度;
name： 操作的名称;
reduction_indices：在以前版本中用来指定轴，已弃用;

axis=0 ，axis =1 的理解

轴用来为超过一维的数组定义的属性，二维数据拥有两个轴：第0轴沿着行的垂直往下，第1轴沿着列的方向水平延伸。

注意看，官方对于0和1的解释是轴，也就是坐标轴。而坐标轴是有方向的，所以千万不要用行和列的思维去想axis，因为行和列是没有方向的，这样想会在遇到不同的例子时感到困惑。

根据官方的说法，1表示横轴，方向从左到右；0表示纵轴，方向从上到下。当axis=1时，数组的变化是横向的，而体现出来的是列的增加或者减少。

其实axis的重点在于方向，而不是行和列。具体到各种用法而言也是如此。当axis=1时，如果是求平均，那么是从左到右横向求平均；如果是拼接，那么也是左右横向拼接；如果是drop，那么也是横向发生变化，体现为列的减少。

当考虑了方向，即axis=1为横向，axis=0为纵向，而不是行和列，那么所有的例子就都统一了。

tf.round （） 四舍六入五取偶

import tensorflow as tf
from keras import backend as K

x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])
with tf.Session() as sess:
    sess.run(tf.round(x))
# array([ 1.,  2.,  2.,  2., -4.], dtype=float32)

tf.cast（） 张量（tensor）数据类型转换

a=tf.cast(x, dtype, name=None)
 x:   待转换的数据（张量）
 dtype： 目标数据类型
 name： 可选参数，定义操作的名称

tf.maximum, tf.argmax, tf.reduce_max 几个最大值的对比

tf.maximum(a,b) 返回a,b之间的最大值
tf.argmax(a,b) 返回在b维上a的最大值
tf.reduce_max(a) 返回在张量a上的最大值

tf.pad() 对张量进行扩展

函数主要是用来对tensor的大小进行扩展，包括水平、垂直、深度(通道)等。

pad(tensor, paddings, mode="CONSTANT", name=None, constant_values=0)
ensor:输入的tensor
paddings:设置填充的大小
mode:填充方式，默认是CONSTANT,还有REFLECT和SYMMETRIC
name:名称
constant_values：CONSTANT填充方式的填充值

tf.image.crop_to_bounding_box 将图像裁剪到指定的边界框

 tf.image.crop_to_bounding_box(
    image,
    offset_height,
    offset_width,
    target_height,
    target_width
)

这个操作从image中裁剪一个矩形部分.返回图像的左上角位于image的offset_height, offset_width,右下角处于offset_height + target_height, offset_width + target_width.

参数：

image：形状为[batch, height, width, channels]的4-D张量,或形状为[height, width, channels]的3-D张量.
offset_height：输入中结果左上角的垂直坐标.
offset_width：输入中结果左上角的水平坐标.
target_height：结果的高度.
target_width：结果的宽度.

返回值：
如果image是四维,则返回形状为[batch, target_height, target_width, channels]的四维浮动张量；如果image是三维的,则返回形状为[target_height, target_width, channels]的三维浮动张量.

tf.expand_dims 扩展维数

在指定轴为输入数据增加一维

tf.expand_dims(input, axis=None, name=None, dim=None)
　　input: 即输入张量
　　axis:指定在哪一维为输入张量添加维数
　　name:操作的名字
　　dim:等同于轴，一般不推荐使用。

axis 是索引

#'t' is a tensor of shape [2]
tf.shape(tf.expand_dims(t, 0))  # [1, 2]
tf.shape(tf.expand_dims(t, 1))  # [2, 1]
tf.shape(tf.expand_dims(t, -1))  # [2, 1]
 
#'t2' is a tensor of shape [2, 3, 5]
tf.shape(tf.expand_dims(t2, 0))  # [1, 2, 3, 5]
tf.shape(tf.expand_dims(t2, 2))  # [2, 3, 1, 5]
tf.shape(tf.expand_dims(t2, 3))  # [2, 3, 5, 1]

tf.stack() 矩阵拼接

tf.stack([A, B] axis=0)

A，B，输入张量
axis，指定拼接维度，默认为0。

os.path.join() 连接两个或更多的路径名

1.如果各组件名首字母不包含’/’，则函数会自动加上

2.第一个以”/”开头的参数开始拼接，之前的参数全部丢弃,当有多个时，从最后一个开始

3.如果最后一个组件为空，则生成的路径以一个’/’分隔符结尾

import os
 
Path1 = 'home'
Path2 = 'develop'
Path3 = 'code'
 
Path10 = Path1 + Path2 + Path3
Path20 = os.path.join(Path1,Path2,Path3)
print ('Path10 = ',Path10)
print ('Path20 = ',Path20)
 
输出
Path10 = homedevelopcode
Path20 = home\develop\code

scipy.io.loadmat（） 读取.mat文件的数据

scipy.io.loadmat(xxx)   
xxx为路径

Python使用Scipy库中的io.loadmat读取.mat文件，并获取数据部分

array[0][0] 提取位置元素

import numpy as np
a = np.array([np.arange(12),np.arange(12,24)])
>>>print a
[[ 0  1  2  3  4  5  6  7  8  9 10 11]
 [12 13 14 15 16 17 18 19 20 21 22 23]]

>>>print a[0][6]
6

python \r \t \n 各种转义字符

\(在行尾需换行时)     续行符
\\    		 反斜杠符号
\'    		 单引号
\"    		 双引号
\a   		 响铃
\b   		 退格(Backspace)
\e   		 转义
\000  		 一个空格
\n    		 换行
\v    		 纵向制表符
\t    		 横向制表符
\r   		 回车
\f   		 换页
\oyy   		 八进制数yy代表的字符，例如：\o12代表换行
\xyy   		 十进制数yy代表的字符，例如：\x0a代表换行
\other		 其它的字符以普通格式输出

Python List index() 查找索引

list.index(x[, start[, end]]) 用于从列表中找出某个值第一个匹配项的索引位置。
x-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。

np.swapaxes(a,x,y) 维度互换

ndarray对象的操作函数之np.swapaxes(a,x,y)
等价于 a.swapaxes(x,y)

a.swapaxes(x,y)，是将n维数组中两个维度进行调换，其中x，y的值为a.shape值（2，3，4）元组中的索引值（下标）。

tf.nn.max_pool 池化

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'

返回一个Tensor，类型不变，shape仍然是[batch, height, width, channels]这种形式

tf.squeeze()

squeeze(
    input,
    axis=None,
    name=None,
    squeeze_dims=None
)
该函数返回一个张量，这个张量是将原始input中所有维度为1的那些维都删掉的结果
axis可以用来指定要删掉的为1的维度，此处要注意指定的维度必须确保其是1，否则会报错

#  't' 是一个维度是[1, 2, 1, 3, 1, 1]的张量
tf.shape(tf.squeeze(t))   # [2, 3]， 默认删除所有为1的维度
 
# 't' 是一个维度[1, 2, 1, 3, 1, 1]的张量
tf.shape(tf.squeeze(t, [2, 4]))  # [1, 2, 3, 1]，标号从零开始，只删掉了2和4维的1

tf.train.Coordinator() 创建一个线程协调器

tensorflow中协调器 tf.train.Coordinator 和入队线程启动器 tf.train.start_queue_runners

tf.train.start_queue_runners 入队线程启动器

tensorflow中协调器 tf.train.Coordinator 和入队线程启动器 tf.train.start_queue_runners

os.listdir() 获取文件夹下文件名字的列表

os.listdir()方法用于返回指定文件夹包含的文件或文件夹的名字的列表。这个列表以字母顺序，不包括‘.’和‘…’即使其在文件夹中。

path = ‘www/var/http/’
os.listdir(path)
注：如果目录下有中文，则需要转码处理。
cPath = os.getcwd()
uPath = unicode(cPath,‘utf-8’)
for filename in os.listdir(uPath):
print(filename)

endswith() 判断文件尾缀（什么类型文件）

Python endswith()

方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。

file.endswith(".py")

genfromtxt函数创建数组表格数据

gt = np.genfromtxt(gt_file, delimiter=',')
genfromtxt函数创建数组表格数据,在深度学习里面是读取已经标注好的，真实地面位置坐标。

np.rint() 和 np.ceil() 和 np.linspace() 取整

np.rint()根据四舍五入取整

np.ceil()向上取整，与四舍五入无关

>>import numpy as np
>>n = np.array([-5.6, -4.2, -2.7, 2.7, 4.3, 5.5, 8.1])
>>print(np.ceil(n))
>>print(np.rint(n))
 
[-5. -4. -2.  3.  5.  6.  9.]
[-6. -4. -3.  3.  4.  6.  8.]

np.linspace(start, stop, num)

 返回：在[start, stop]区间内，选取均匀分布的num个点

​>>x = np.rint(np.linspace(64, 176, 6))
>>y = np.rint(np.linspace(64, 176, 6))
>>z = np.rint(np.linspace(64, 91, 4))
>>print(x)
>>print(y)
>>print(z)​
 
[  64.   86.  109.  131.  154.  176.]
[  64.   86.  109.  131.  154.  176.]
[ 64.  73.  82.  91.]

python中的[1:]、[::-1]、X[:,m:n]和X[1,:]

详细介绍

np.hanning 平滑数据

调用hanning函数计算权重，生成一个长度为N的窗口：

N = int(sys.argv[1])
weights = np.hanning(N)
print "Weights", weights

np.expand_dims() 扩展数组的形状

np.expand_dims(a, axis=0)表示在0位置添加数据,转换结果如下:

b=array([[[[1, 2, 3],
         [4, 5, 6]]]])
b.shape(1,2,3)
b = np.expand_dims(a, axis=0)

b.shape
(*1*, 1, 2, 3)

np.transpose 调换数组的行列值的索引值（类似矩阵的转置，但是维度可能更高）

x = np.arange(4).reshape((2,2)) //生成一个2x2的数组
print(x)
[[0 1]   
[2 3]]

x = np.transpose(x) 
print(x)
[[0 2]
 [1 3]]
 我们可以直观的看到，数组的行列索引值对换，1的位置从x(0,1)跑到了x(1,0)。

三维的数组：

x = np.arange(12).reshape((2,2,3))  //生成一个2x2x3的数组
print(x)
[[[ 0  1  2]
  [ 3  4  5]]
 [[ 6  7  8]
  [ 9 10 11]]]
假设三维数组当中的索引值为x，y，z

transpose()函数的作用就是调换x，y，z的位置，也就是数组的索引值。

所以我们正常的数组索引值为（0，1，2），等于（x，y，z）
 
x = np.transpose(x,(1,0,2))  //transpose()函数的第二个参数就是改变索引值的地方
print(x)
[[[ 0  1  2]
  [ 6  7  8]]
 [[ 3  4  5]
  [ 9 10 11]]]
通过transpose()函数改变了x的索引值为（1，0，2），对应（y，x，z）

索引改变后原本y的值和x的值对换了。

上面代码的数字7为例，原本的7的位置索引为（1,0,1），通过transpose（x，（1，0，2））索引改变为（0，1，1）

np.sum() 求和

直接看这里更清楚
python 中 np.sum()函数 通俗易懂理解！

np.prod 返回给定轴上的数组元素的乘积。

numpy.prod(a, axis=None, dtype=None, out=None, 
				keepdims=<class 'numpy._globals._NoValue'>)

Examples:

默认情况下，计算所有元素的乘积:

In [1]: import numpy as np

In [2]: np.prod([1.,2.])
Out[2]: 2.0

即使输入数组是二维的:

In [3]: np.prod([[1.,2.],[3.,4.]])
Out[3]: 24.0

但是我们也可以指定要乘以的轴:

In [4]: np.prod([[1.,2.],[3.,4.]], axis=1)
Out[4]: array([ 2., 12.])

numpy.unravel_index(indices, dims) 返回indices中的元素在维度为dims的数组中的索引值，默认按元组的形式返回。

numpy.unravel_index()函数的用法，构建一个shape为（6，7，8）的矩阵，并找到第100个元素的索引值

np.size 统计矩阵元素个数

size()函数主要是用来统计矩阵元素个数，或矩阵某一维上的元素个数的函数。

numpy.size(a, axis=None)
a：输入的矩阵
axis：int型的可选参数，指定返回哪一维的元素个数。当没有指定时，返回整个矩阵的元素个数。

>>> a = np.array([[1,2,3],[4,5,6]])
>>> np.size(a)
6
>>> np.size(a,1)
3
>>> np.size(a,0)
2
axis的值没有设定，返回矩阵的元素个数
axis = 0，返回该二维矩阵的行数
axis = 1，返回该二维矩阵的列数

np.linalg.norm 矩阵或向量范数

linalg = linear（线性）+ algebra（代数），norm则表示范数。

首先需要注意的是范数是对向量（或者矩阵）的度量，是一个标量（scalar）：

2、函数参数

x_norm=np.linalg.norm(x, ord=None, axis=None, keepdims=False)
x: 表示矩阵（也可以是一维）
ord：范数类型

参数 说明 计算方法

>>> x = np.array([3, 4])
>>> np.linalg.norm(x)
5.
>>> np.linalg.norm(x, ord=2)
5.
>>> np.linalg.norm(x, ord=1)
7.
>>> np.linalg.norm(x, ord=np.inf)
4

float(‘Inf’), float(’-Inf’) 正负无穷

Python中可以用如下方式表示正负无穷：

float("inf"), float("-inf")

Python 关于正负无穷float(‘inf’)的一些用法

np.trapz 求积分

numpy.trapz简介

np.trapz()的生动解释