tensorflow常用函数

1.keras.preprocessing.image

def preprocess_image(img):
    img = image.load_img(img, target_size=(299, 299))
    img = image.img_to_array(img)
    img = img / 255.0
    return img

2.tf.io.read_file

def preprocess_image(image):
    image = tf.io.read_file(image)
    image = tf.image.decode_jpeg(image, channels=3)
    image = tf.image.resize_with_pad(image, 227, 227)
    image = image / 255.0
    return image

3.tf.keras.utils.image_dataset_from_directory

tf.keras.utils.image_dataset_from_directory(
    directory,
    labels='inferred',
    label_mode='int',
    class_names=None,
    color_mode='rgb',
    batch_size=32,
    image_size=(256, 256),
    shuffle=True,
    seed=None,
    validation_split=None,
    subset=None,
    interpolation='bilinear',
    follow_links=False,
    crop_to_aspect_ratio=False,
    **kwargs
)

如果你的目录结构是：

main_directory/
...class_a/
......a_image_1.jpg
......a_image_2.jpg
...class_b/
......b_image_1.jpg
......b_image_2.jpg

然后调用image_dataset_from_directory(main_directory, labels='inferred') 将返回 a ，它会tf.data.Dataset从子目录class_a和中生成批量图像class_b，以及标签 0 和 1（0 对应于class_a1，1 对应于class_b）。

支持的图像格式：jpeg、png、bmp、gif。动画 gif 被截断到第一帧。

directory	数据所在的目录。如果labels是“推断”，它应该包含子目录，每个子目录都包含一个类的图像。否则，目录结构将被忽略。
labels	“推断”（从目录结构生成标签）、无（无标签）或与目录中找到的图像文件数量相同大小的整数标签的列表/元组。标签应根据图像文件路径的字母数字顺序排序（通过Python 获得）。 os.walk(directory)
label_mode	- 'int': means that the labels are encoded as integers (e.g. for `sparse_categorical_crossentropy` loss). “分类”意味着标签被编码为分类向量（例如，用于categorical_crossentropy损失）。 “二进制”表示标签（只能有 2 个）被编码为float32值为 0 或 1 的标量（例如 for binary_crossentropy）。 无（无标签）。
class_names	仅当“标签”是“推断”时才有效。这是类名的显式列表（必须与子目录的名称匹配）。用于控制类的顺序（否则使用字母数字顺序）。
color_mode	“灰度”、“rgb”、“rgba”之一。默认值：“RGB”。图像是否将转换为具有 1、3 或 4 个通道。
batch_size	数据批次的大小。默认值：32。如果None，则不会对数据进行批处理（数据集将产生单个样本）。
image_size	从磁盘读取图像后调整图像大小的大小。默认为. 由于管道处理必须具有相同大小的批量图像，因此必须提供这一点。 (256, 256)
shuffle	是否打乱数据。默认值：真。如果设置为 False，则按字母数字顺序对数据进行排序。
seed	用于洗牌和转换的可选随机种子。
validation_split	0 到 1 之间的可选浮点数，保留用于验证的数据的一部分。
subset	“培训”或“验证”之一。仅在设置时使用。 validation_split
interpolation	字符串，调整图像大小时使用的插值方法。默认为bilinear. 支持bilinear, nearest, bicubic, area, lanczos3, lanczos5, gaussian, mitchellcubic.
follow_links	是否访问符号链接指向的子目录。默认为假。
crop_to_aspect_ratio	如果为 True，则调整图像大小而不会出现纵横比失真。当原始纵横比与目标纵横比不同时，将裁剪输出图像，以返回与目标纵横比匹配的图像中（大小为 ）的最大可能窗口。默认情况下 ( )，可能不会保留纵横比。 image_sizecrop_to_aspect_ratio=False
**kwargs	旧版关键字参数。

Returns

一种tf.data.Dataset对象。 如果label_mode为无，则产生float32形状张量 (batch_size, image_size[0], image_size[1], num_channels)，对图像进行编码（有关 的规则，请参见下文num_channels）。 否则，它会产生一个 tuple (images, labels)，其中images 有 shape (batch_size, image_size[0], image_size[1], num_channels)，并labels遵循下面描述的格式。

关于标签格式的规则：

• 如果label_mode是int，则标签是int32形状张量 (batch_size,)。
• 如果label_mode是binary，标签是float32形状为 1 和 0 的张量(batch_size, 1)。
• 如果label_mode是categorial，标签是一个float32形状张量(batch_size, num_classes)，表示类索引的 one-hot 编码。

关于生成图像中通道数的规则：

• 如果color_mode是grayscale，则图像张量中有 1 个通道。
• 如果color_mode是rgb，则图像张量中有 3 个通道。
• 如果color_mode是rgba，则图像张量中有 4 个通道。

4.tf.image.non_max_suppression 

贪婪地按分数的降序选择边界框的子集。

tf.image.non_max_suppression(
    boxes,
    scores,
    max_output_size,
    iou_threshold=0.5,
    score_threshold=float('-inf'),
    name=None
)

修剪掉与先前选定的框在联合上具有高交集（IOU）重叠的框。边界框以[y1，x1，y2，x2]的形式提供，其中（y1，x1）和（y2，x2）是框角的任何对角线对的坐标，坐标可以提供为标准化（即位于间隔[0，1]）或绝对坐标。请注意，此算法与原点在坐标系中的位置无关。该算法对坐标系的正交变换和平移是不变的；因此，坐标系的平移或反射会导致算法选择相同的框。此操作的输出是一组整数，索引到表示选定框的边界框的输入集合中。然后，可以使用tf获得与所选索引相对应的边界框坐标。收集操作。例如：

selected_indices = tf.image.non_max_suppression(
      boxes, scores, max_output_size, iou_threshold)
  selected_boxes = tf.gather(boxes, selected_indices)

参数
boxes	Tensor形状 为 的二维浮点数。 [num_boxes, 4]
scores	一个 1-DTensor形状的浮点数，表示对应于每个框（每行框）的单个分数。 [num_boxes]
max_output_size	一个标量整数Tensor，表示要通过非最大抑制选择的最大框数。
iou_threshold	一个 0-D 浮点张量，表示用于决定框相对于 IOU 是否重叠过多的阈值。
score_threshold	一个 0-D 浮点张量，表示根据分数决定何时移除框的阈值。
name	操作的名称（可选）。

return
selected_indices	一个 1-D 整数Tensor形状，[M]表示从框张量中选择的索引，其中. M <= max_output_size

5.tf.gather()函数

tf.gather（）
该接口的作用：就是抽取出params的第axis维度上在indices里面所有的index
 
tf.gather(
    params,
    indices,
    validate_indices=None,
    name=None,
    axis=0
)

数说明：

params: A Tensor.
indices: A Tensor. types必须是: int32, int64. 里面的每一个元素大小必须在 [0, params.shape[axis])范围内.
axis: 维度。沿着params的哪一个维度进行抽取indices
返回的是一个tensor

tf.gather和tf.gather_nd都是从tensor中取出index标注的部分，不同之处在于，gather一般只使用一个index来标注，而gather_nd可以使用多个index。

6.tf.image.crop_and_resize

tf.image.crop_and_resize(
    image,
    boxes,
    box_indices,
    crop_size,
    method='bilinear',
    extrapolation_value=0.0,
    name=None
)

从输入图像张量中提取裁剪，并使用双线性采样或最近邻采样（可能随着纵横比变化）将它们调整为由 指定的常见输出大小crop_size。crop_to_bounding_box这比从输入图像中提取固定大小切片并且不允许调整大小或纵横比更改的操作更通用 。

crops从输入image中的边界框位置定义的位置返回张量boxes。裁剪后的框都被调整大小（使用双线性或最近邻插值）到一个固定的 size = [crop_height, crop_width]. 结果是一个 4-D 张量 [num_boxes, crop_height, crop_width, depth]。调整大小是角对齐的。特别是，如果boxes = [[0, 0, 1, 1]]，该方法将给出与使用tf.compat.v1.image.resize_bilinear()或 tf.compat.v1.image.resize_nearest_neighbor()（取决于method 参数）与 相同的结果align_corners=True。

参数
image	一个 4-D 张量 shape 。两者都需要积极。 [batch, image_height, image_width, depth]image_heightimage_width
boxes	一个二维张量 shape 。张量的第 - 行指定图像中框的坐标，并以归一化坐标指定。的归一化坐标值映射到 处的图像坐标，因此归一化图像高度的区间映射到图像高度坐标中。我们确实允许> ，在这种情况下，采样裁剪是原始图像的上下翻转版本。宽度尺寸的处理方式类似。允许超出范围的归一化坐标，在这种情况下，我们使用外推输入图像值。 [num_boxes, 4]ibox_ind[i][y1, x1, y2, x2]yy * (image_height - 1)[0, 1][0, image_height - 1]y1y2[0, 1]extrapolation_value
box_indices	具有 int32 值 的一维形状张量。的值指定第 -th 框引用的图像。 [num_boxes][0,batch)box_ind[i]i
crop_size	2 个元素的一维张量，. 所有裁剪的图像块都将调整为此大小。不保留图像内容的纵横比。两者都需要 积极。 size = [crop_height, crop_width]crop_heightcrop_width
method	一个可选字符串，指定调整大小的采样方法。它可以是"bilinear"或"nearest"并且默认为"bilinear"。目前支持两种采样方法：双线性和最近邻。
extrapolation_value	一个可选的float. 默认为. 适用时用于外推的值。 0.0
name	操作的名称（可选）。

recall
一个 4-D 张量 shape 。 [num_boxes, crop_height, crop_width, depth]

 int_shape

keras.backend.int_shape(x)

返回张量或变量的尺寸，作为 int 或 None 项的元组。

参数

• x: 张量或变量。

返回

整数元组（或 None 项）。

例子

>>> from keras import backend as K
>>> inputs = K.placeholder(shape=(2, 4, 5))
>>> K.int_shape(inputs)
(2, 4, 5)
>>> K.int_shape(inputs)[2]
5
>>> val = np.array([[1, 2], [3, 4]])
>>> kvar = K.variable(value=val)
>>> K.int_shape(kvar)
(2, 2)

image_data_format

keras.backend.image_data_format()

返回默认图像数据格式约定 ('channels_first' 或 'channels_last')。

返回

一个字符串，'channels_first' 或 'channels_last'

• channels_first表示图片数据的通道在第一维度[channel,28,28,3]
• channels_last表示图片数据的通道在最后一个维度[28,28,3,channel]

例子

>>> keras.backend.image_data_format()
'channels_first'

tf.keras.applications.imagenet_utils.preprocess_input(
    x, data_format=None, mode='caffe'
)

 tf.keras.applications.imagenet_utils.preprocess_input

预处理编码一批图像的张量或 Numpy 数组。 

tf.keras.applications.imagenet_utils.preprocess_input(
    x, data_format=None, mode='caffe'
)

使用示例applications.MobileNet：

tf.keras.applications.imagenet_utils.preprocess_input(
    x, data_format=None, mode='caffe'
)

i = tf.keras.layers.Input([None, None, 3], dtype = tf.uint8)
x = tf.cast(i, tf.float32)
x = tf.keras.applications.mobilenet.preprocess_input(x)
core = tf.keras.applications.MobileNet()
x = core(x)
model = tf.keras.Model(inputs=[i], outputs=[x])

image = tf.image.decode_png(tf.io.read_file('file.png'))
result = model(image)

参数
x	具有 3 个颜色通道的浮点或 a 、3D 或 4D，其值在 [0, 255] 范围内。如果数据类型兼容，则预处理数据将覆盖输入数据。为了避免这种行为，可以使用。 numpy.arraytf.Tensornumpy.copy(x)
data_format	图像张量/数组的可选数据格式。默认为无，在这种情况下使用全局设置 tf.keras.backend.image_data_format()（除非您更改它，否则默认为“channels_last”）。
mode	“caffe”、“tf”或“torch”之一。默认为“caffe”。 caffe：将图像从 RGB 转换为 BGR，然后将相对于 ImageNet 数据集的每个颜色通道归零，而不进行缩放。 tf: 将在 -1 和 1 之间缩放像素，采样方式。 torch：将在 0 和 1 之间缩放像素，然后根据 ImageNet 数据集对每个通道进行归一化。

return:

numpy.arrayh或者tf.Tensor（）r类型为float32

keras.utils.Sequence

        在使用keras的时候，一般使用model.fit（）来传入训练数据，fit（）接受多种类型的数据：
1.数组类型（如numpy等）。
2.dataset类型
3.python generator，但是限制比较多，一般要在编写python generator的平 台下运行模型
4.tensorflow.keras.utils.Sequence，和python generator差不多，但是限制较少，可迁移性更好
 

 from skimage.io import imread
    from skimage.transform import resize
    import numpy as np
    import math

    # Here, `x_set` is list of path to the images
    # and `y_set` are the associated classes.

    class CIFAR10Sequence(Sequence):

        def __init__(self, x_set, y_set, batch_size):
            self.x, self.y = x_set, y_set
            self.batch_size = batch_size

        def __len__(self):
            return math.ceil(len(self.x) / self.batch_size)

        def __getitem__(self, idx):
            batch_x = self.x[idx * self.batch_size:(idx + 1) *
            self.batch_size]
            batch_y = self.y[idx * self.batch_size:(idx + 1) *
            self.batch_size]

            return np.array([
                resize(imread(file_name), (200, 200))
                   for file_name in batch_x]), np.array(batch_y)

 init()：初始化类。
len()：返回batch_size的个数，也就是完整跑一遍数据要运行运行模型多少次。
getitem（）：返回一个batch_size的数据（data，label)

on_epoch_end（）：每个epoch结束后如何执行

tf.keras.utils.OrderedEnqueuer

tf.keras.utils.OrderedEnqueuer(
    sequence, use_multiprocessing=False, shuffle=False
)

参数： 

sequence	一个tf.keras.utils.data_utils.Sequence对象。
use_multiprocessing	如果为 True，则使用多处理，否则使用线程
shuffle	是否在每个 epoch 开始时打乱数据

方法：

• get()  创建一个生成器以从队列中提取数据

• 如果是None 则跳过数据。

• 队列中的下一个元素组成为 (inputs, targets)或(inputs, targets, sample_weights)

  is_running()

  start(
      workers=1, max_queue_size=10
  )

  启动线程处理程序

• workers	线程数
  max_queue_size	队列大小（满时，线程可以使用阻塞put()）

  stop(
      timeout=None
  )

  如有必要，停止运行线程并等待它们退出。

  应该由调用start().

• timeout

  等待的最长时间thread.join()