keras搭建图像处理神经网络相关API学习

weightOneMillion

已于 2022-11-12 11:35:45 修改

阅读量218

点赞数

分类专栏：深度学习图像处理文章标签： keras 图像处理神经网络

于 2022-10-23 20:17:12 首次发布

本文链接：https://blog.csdn.net/littleyy666/article/details/127478592

版权

图像处理同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

深度学习

3 篇文章 0 订阅

订阅专栏

keras图像处理相关模块的API

学习背景：图像处理

from keras.models import *
from keras.layers import *
from keras.optimizers import *

model

在 Keras 中有两类主要的模型：Sequential 顺序模型和使用函数式 API 的 Model 类模型。
这些模型有许多共同的方法和属性：

model.layers 是包含模型网络层的展平列表。
model.inputs 是模型输入张量的列表。
model.outputs 是模型输出张量的列表。
model.summary() 打印出模型概述信息。 它是 utils.print_summary 的简捷调用。
model.get_config() 返回包含模型配置信息的字典。
model.get_weights() 返回模型中所有权重张量的列表，类型为 Numpy 数组。
model.set_weights(weights) 从 Numpy 数组中为模型设置权重。列表中的数组必须与 get_weights() 返回的权重具有相同的尺寸。
model.to_json() 以 JSON 字符串的形式返回模型的表示。请注意，该表示不包括权重，仅包含结构。
model.to_yaml() 以 YAML 字符串的形式返回模型的表示。请注意，该表示不包括权重，只包含结构。
model.save_weights(filepath) 将模型权重存储为 HDF5 文件。
model.load_weights(filepath, by_name=False): 从 HDF5 文件（由 save_weights 创建）中加载权重。默认情况下，模型的结构应该是不变的。 如果想将权重载入不同的模型（部分层相同）， 设置 by_name=True 来载入那些名字相同的层的权重。

除了这两类模型之外，你还可以通过继承 Model 类并在 call 方法中实现你自己的前向传播，以创建你自己的完全定制化的模型，（Model 类继承 API 引入于 Keras 2.2.0）。

Sequential 模型 API

# 用于配置训练模型。
compile(optimizer, loss=None, metrics=None, loss_weights=None, sample_weight_mode=None, weighted_metrics=None, target_tensors=None)
# 以给定数量的轮次（数据集上的迭代）训练模型。
fit(x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None)
#在测试模式下返回模型的误差值和评估标准值。
evaluate(x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None)
# 为输入样本生成输出预测。
predict(x, batch_size=None, verbose=0, steps=None)

train_on_batch(x, y, sample_weight=None, class_weight=None)

test_on_batch(x, y, sample_weight=None)

predict_on_batch(x)

fit_generator(generator, steps_per_epoch=None, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, class_weight=None, max_queue_size=10, workers=1, use_multiprocessing=False, shuffle=True, initial_epoch=0)

evaluate_generator(generator, steps=None, max_queue_size=10, workers=1, use_multiprocessing=False, verbose=0)

predict_generator(generator, steps=None, max_queue_size=10, workers=1, use_multiprocessing=False, verbose=0)

get_layer(name=None, index=None)

Model 类（函数式 API）

在函数式 API 中，给定一些输入张量和输出张量，可以通过以下方式实例化一个 Model：

from keras.models import Model
from keras.layers import Input, Dense

a = Input(shape=(32,))
b = Dense(32)(a)
model = Model(inputs=a, outputs=b)

这个模型将包含从 a 到 b 的计算的所有网络层。
在多输入或多输出模型的情况下，你也可以使用列表：

model = Model(inputs=[a1, a2], outputs=[b1, b3, b3])

API同Squential差不多

layers

所有 Keras 网络层都有很多共同的函数：

layer.get_weights(): 以含有Numpy矩阵的列表形式返回层的权重。
layer.set_weights(weights): 从含有Numpy矩阵的列表中设置层的权重（与get_weights的输出形状相同）。
layer.get_config(): 返回包含层配置的字典。
如果一个层具有单个节点 (i.e. 如果它不是共享层), 你可以得到它的输入张量、输出张量、输入尺寸和输出尺寸:

    layer.input
    layer.output
    layer.input_shape
    layer.output_shape

如果层有多个节点 (参见: 层节点和共享层的概念), 您可以使用以下函数:

    layer.get_input_at(node_index)
    layer.get_output_at(node_index)
    layer.get_input_shape_at(node_index)
    layer.get_output_shape_at(node_index)

核心网络层

# 全连接层
keras.layers.Dense(units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)
# Activation
keras.layers.Activation(activation)
# Dropout 随机drop掉一些，防止过拟合
keras.layers.Dropout(rate, noise_shape=None, seed=None)
# Flatten 将输入展平。不影响批量大小。
keras.layers.Flatten(data_format=None)
# Input用于实例化 Keras 张量。
keras.engine.input_layer.Input()
# Reshape 将输入重新调整为特定的尺寸。
keras.layers.Reshape(target_shape)

卷积层 Convolutional

# Conv1D   1D 卷积层 (例如时序卷积)。
keras.layers.Conv1D(filters, kernel_size, strides=1, padding='valid', data_format='channels_last', dilation_rate=1, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

# Conv2D   2D 卷积层 (例如对图像的空间卷积)。
keras.layers.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)
# filters: 整数，输出空间的维度 （即卷积中滤波器的输出数量）。
# kernel_size: 一个整数，或者 2 个整数表示的元组或列表， 指明 2D 卷积窗口的宽度和高度。 可以是一个整数，为所有空间维度指定相同的值。
# strides: 一个整数，或者 2 个整数表示的元组或列表， 指明卷积沿宽度和高度方向的步长。 可以是一个整数，为所有空间维度指定相同的值。 指定任何stride 值 != 1 与指定 dilation_rate 值 != 1 两者不兼容。
# padding: "valid" 或 "same" (大小写敏感)。
# activation: 要使用的激活函数。 如果你不指定，则不使用激活函数 (即线性激活： a(x) = x)。

# Conv2DTranspose   转置卷积层 (有时被成为反卷积)。
keras.layers.Conv2DTranspose(filters, kernel_size, strides=(1, 1), padding='valid', output_padding=None, data_format=None, dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

# UpSampling2D   2D 输入的上采样层。沿着数据的行和列分别重复 size[0] 和 size[1] 次。
keras.layers.UpSampling2D(size=(2, 2), data_format=None, interpolation='nearest')
# size: 整数，或 2 个整数的元组。 行和列的上采样因子。
# data_format: 字符串， channels_last (默认) 或 channels_first 之一， 表示输入中维度的顺序。channels_last 对应输入尺寸为 (batch, height, width, channels)， channels_first 对应输入尺寸为 (batch, channels, height, width)。 它默认为从 Keras 配置文件 ~/.keras/keras.json 中 找到的 image_data_format 值。 如果你从未设置它，将使用 "channels_last"。
# interpolation: 字符串，nearest 或 bilinear 之一。 注意 CNTK 暂不支持 bilinear upscaling， 以及对于 Theano，只可以使用 size=(2, 2)。

# ZeroPadding2D2D 输入的零填充层（例如图像）。该图层可以在图像张量的顶部、底部、左侧和右侧添加零表示的行和列。
keras.layers.ZeroPadding2D(padding=(1, 1), data_format=None)

池化层 Pooling

# MaxPooling2D   对于空间数据的最大池化。
keras.layers.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)
# pool_size: 整数，或者 2 个整数表示的元组， 沿（垂直，水平）方向缩小比例的因数。 （2，2）会把输入张量的两个维度都缩小一半。 如果只使用一个整数，那么两个维度都会使用同样的窗口长度。

#  AveragePooling2D 对于空间数据的平均池化。
keras.layers.AveragePooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)

局部连接层 Locally-connected

# LocallyConnected2D  2D 输入的局部连接层。
keras.layers.LocallyConnected2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

循环层 Recurrent

嵌入层 Embedding

融合层 Merge

# concatenate   Concatenate 层的函数式接口。
keras.layers.concatenate(inputs, axis=-1)

高级激活层 Advanced Activations

# PReLU 参数化的 ReLU。
keras.layers.PReLU(alpha_initializer='zeros', alpha_regularizer=None, alpha_constraint=None, shared_axes=None)
# 形式： f(x) = alpha * x for x < 0, f(x) = x for x >= 0, 其中 alpha 是一个可学习的数组，尺寸与 x 相同。

# Softmax Softmax 激活函数。
keras.layers.Softmax(axis=-1)

# ReLU 激活函数。
keras.layers.ReLU(max_value=None, negative_slope=0.0, threshold=0.0)

标准化层 Normalization\

# BatchNormalization 批量标准化层 (Ioffe and Szegedy, 2014)
keras.layers.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None)

噪声层 Noise

层封装器 wrappers

数据预处理

序列预处理

文本预处理

图像预处理

# ImageDataGenerator 类  通过实时数据增强生成张量图像数据批次。数据将不断循环（按批次）。
keras.preprocessing.image.ImageDataGenerator(featurewise_center=False,  
                                             samplewise_center=False, 
                                             featurewise_std_normalization=False, 
                                             samplewise_std_normalization=False, 
                                             zca_whitening=False, 
                                             zca_epsilon=1e-06, 
                                             rotation_range=0, 
                                             width_shift_range=0.0, 
                                             height_shift_range=0.0, 
                                             brightness_range=None, 
                                             shear_range=0.0, 
                                             zoom_range=0.0, 
                                             channel_shift_range=0.0, 
                                             fill_mode='nearest', 
                                             cval=0.0, 
                                             horizontal_flip=False, 
                                             vertical_flip=False, 
                                             rescale=None, 
                                             preprocessing_function=None, 
                                             data_format=None, 
                                             validation_split=0.0, 
                                             dtype=None)

ImageDataGenerator 类方法

# apply_transform 根据给定的参数将变换应用于图像。
apply_transform(x, transform_parameters)
# fit 将数据生成器用于某些示例数据。
fit(x, augment=False, rounds=1, seed=None)
# flow 采集数据和标签数组，生成批量增强数据。
flow(x, y=None, batch_size=32, shuffle=True, sample_weight=None, seed=None, save_to_dir=None, save_prefix='', save_format='png', subset=None)

# flow_from_directory
flow_from_directory(directory, target_size=(256, 256), color_mode='rgb', classes=None, class_mode='categorical', batch_size=32, shuffle=True, seed=None, save_to_dir=None, save_prefix='', save_format='png', follow_links=False, subset=None, interpolation='nearest')
# directory: 目标目录的路径。每个类应该包含一个子目录。任何在子目录树下的 PNG, JPG, BMP, PPM 或 TIF 图像，都将被包含在生成器中。

损失函数losses

优化器 (optimizer) 是编译 Keras 模型的所需的两个参数之一：

# 传入优化器名称: 默认参数将被采用
model.compile(loss='mean_squared_error', optimizer='sgd')

优化器optimizers

优化器 (optimizer) 是编译 Keras 模型的所需的两个参数之一：

# 传入优化器名称: 默认参数将被采用
model.compile(loss='mean_squared_error', optimizer='sgd')

Keras 优化器的公共参数

参数 clipnorm 和 clipvalue 能在所有的优化器中使用，用于控制梯度裁剪（Gradient Clipping）：

# SGD 随机梯度下降优化器。
keras.optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0, nesterov=False)
# lr: float >= 0. 学习率。
# momentum: float >= 0. 参数，用于加速 SGD 在相关方向上前进，并抑制震荡。
# decay: float >= 0. 每次参数更新后学习率衰减值。
# nesterov: boolean. 是否使用 Nesterov 动量。

# RMSprop
keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0)

# Adagrad
keras.optimizers.Adagrad(lr=0.01, epsilon=None, decay=0.0)

# Adadelta
keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=None, decay=0.0)

# Adam
keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)