keras入门与基础

最新推荐文章于 2025-07-11 10:25:04 发布

蕉叉熵

最新推荐文章于 2025-07-11 10:25:04 发布

阅读量643

点赞数

CC 4.0 BY-SA版权

分类专栏：深度学习机器学习文章标签： Keras 基础

本文链接：https://blog.youkuaiyun.com/songbinxu/article/details/80146665

机器学习同时被 2 个专栏收录

54 篇文章

订阅专栏

深度学习

22 篇文章

订阅专栏

Keras入门与基础

Keras是基于tensorflow或theano实现的高层次封装库，他实现了很多常用的层，包括全连接、卷积、LSTM等等，可以很方便地调用实现各种各样的网络结构。如果网络不太复杂，不怎么需要自己魔改一些细节（例如实现一个带padding的meanpooling之类的），用keras能让你很快地实现一个模型。
本文给出了keras的基本使用方法，方便以后用keras实现一些网络。个人对keras的印象有三点，首先是简单，代码可以非常地简洁；其次是固化，很多层虽然已经定义好，但如果想做一些魔改就得重新自己写个层，比较不方便；第三点是查看输出比较不方便，这应该是tensorflow和theano决定的，想要方便地查看还是用PyTroch吧。
以下的全部内容，都可以在这里和这里（中文版）找到。

一、如何构建网络

实现一个简单的LSTM，以下两种方式等价。

方法一序贯模型（Sequential）

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

model = Sequential()
model.add(Dense(6, input_shape=(None, 6)))
model.add(LSTM(128))
model.add(Dense(10, activation='softmax'))

方法二函数模型（Functional）

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

input_tensor = Input((None,6))
dense_1 = Dense(6)(input_tensor)
lstm = LSTM(128)(dense_1)
output = Dense(10, activation='softmax')(lstm)
model = Model(inputs=[input_tensor], outputs=[output])

二、如何编译网络

网络结构定义好之后，仍需进行编译，指定loss和optimizer

# 使用keras定义好的loss和optimizer
model.compile(loss='categorical_crossentropy', optimizer='adam')

当然，你也可以自定义loss

# 自定义loss function (该loss函数在功能上与keras的mse一样)
def my_mse(y_true, y_pred):
    return K.mean(K.square(y_pred - y_true), axis=-1)

model.compile(loss=my_mse, optimizer='adadelta')

loss函数的本质是y_true与y_pred对比，至于y_pred如何生成，可以自定义

from keras import backend as K

def ctc_lambda_func(args):
    y_pred, labels, input_length, label_length = args
    y_pred = y_pred[:, 2:, :]
    return K.ctc_batch_cost(labels, y_pred, input_length, label_length)

labels = Input(name='the_labels', shape=[n_len], dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
loss_out = Lambda(ctc_lambda_func, output_shape=(1,), name='ctc')([output, labels, input_length, label_length])

model = Model(input=[input_tensor, labels, input_length, label_length], output=[loss_out])
model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer='adadelta')

三、如何让网络训练跑起来

模型在编译完成后，准备好相应符合格式的训练数据和label，即可调用fit训练，设定要跑的epoch，还有batch_size。

# x_train 和 y_train 可以是 Numpy 数组
model.fit(x_train, y_train, epochs=50, batch_size=32)

四、如何保存和读取模型

1. h5格式

model.save 保存

model.save('model.h5')

将会保存如下内容：

模型的结构，以便重构该模型
模型的权重
训练配置（损失函数，优化器等）
优化器的状态，以便于从上次训练中断的地方开始

load_model 读取

from keras.models import load_model

model = load_model('model.h5')

2. json格式

model.to_json() 保存

# save as JSON
json_string = model.to_json()

这样只是保存模型的结构，而不包含其权重或配置信息

model_from_json 保存

# load from JSON
from keras.models import model_from_json

model = model_from_json(json_string)

3. 模型权重

仅保存模型参数

model.save_weights('my_model_weights.h5')

读取

model.load_weights('my_model_weights.h5')

如果只想给某几层赋予权重，可以设置 by_name=True

"""
假如原模型为：
    model = Sequential()
    model.add(Dense(2, input_dim=3, name="dense_1"))
    model.add(Dense(3, name="dense_2"))
    ...
    model.save_weights(fname)
"""
# new model
model = Sequential()
model.add(Dense(2, input_dim=3, name="dense_1"))  # will be loaded
model.add(Dense(10, name="new_dense"))  # will not be loaded

# load weights from first model; will only affect the first layer, dense_1.
model.load_weights(fname, by_name=True)

五、如何可视化模型

有时候我们定义为一个网络模型，会希望看看它每一个部分的结构（shape）以及模块之间的连接情况，即我们需要模型可视化。这里提供三种方法。

model.summary()

使用model.summary()可以看到每一层的名字、参数个数。

print model.summary()

Keras的plot方法

使用keras.utils.visualize_util.plot可以画出网络结构图。

from keras.utils.visualize_util import plot
from IPython.display import Image

plot(model, to_file="model.png", show_shapes=True) # remember to set show_shapes
Image('model.png')

要使用plot，需要依赖库 pydot 以及 graphviz 。

Keras结合Tensorboard

只要在训练阶段，在model.fit中加入callbacks=[TensorBoard(log_dir='./tmp/log')]字段，就能把训练记录保存到log文件。

# etc...
model.fit(x_train, x_train,
                epochs=50,
                batch_size=128,
                shuffle=True,
                validation_data=(x_test, x_test),
                callbacks=[TensorBoard(log_dir='./tmp/log')])

在终端Terminal中输入tensorboard --logdir=./temp/log，会得到一个ip和端口号，复制粘贴到浏览器中就能使用TensorBoard暗中观察。

$ tensorboard --logdir=./temp/log

六、如何准备训练数据

训练模型的时候，我们可以选择两种方式来生成我们的训练数据，一种是一次性读入全部数据，调用model.fit训练，另一种是定义一个数据生成器（generator），然后调用model.fit_generator函数来训练。
第一种方法的好处在于GPU利用率高，一次性读入，减少IO操作时间，缺点在于内存占用过多，毕竟要一次性全部读入，当然如果你有256G内存的工作站当我没说。当然也有一些说法任务GPU使用率高并不好。
第二种方法的好处在于不需要生成大量数据，内存占用相对较少，例如generator每次只生成一个batch的数据，则内存占用量最多为一个batch，并且你可以无限生成数据，缺点是训练过程中需要利用 CPU 生成数据，所以每训练一个batch，GPU会有一段时间什么都不做（等待CPU生成数据），降低效率。

直接输入

model.fit(train_x, train_y)

数据生成器

从Numpy中生成

从读入内存了的ndarray中生成每个batch的数据。这种方法并不会减少内存消耗，只能减少显存的占用。
下面这个生成器，接收完整的data和label为输入，每次从中取出一个batch的数据量，很明显，完整的data和label已经占据了相当的内存了，只是显存占用量明显降低了。

# data & label are both numpy ndarray
def gen(data, label, batch_size=32):
    indexes = np.array_split(range(len(data)), len(data) / batch_size)
    i = 0
    while True:
        yield data[indexes[i]], label[indexes[i]]
        i = (i+1) % len(indexes)

# data preparation
train_x = ...
train_y = ...
valid_x = ...
valid_y = ...

然后调用model.fit_generator训练，其函数原型为：

def fit_generator(self, 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)

以下为几个重要参数的解释：

generator : 一个生成器，应该生成一个 (inputs, targets) 元组，每个元组应该包含同样数量的样本。生成器将无限地在数据集上循环。当运行到第 steps_per_epoch 时，记一个 epoch 结束。
steps_per_epoch : 一个epoch包含多少个batch，通常应该等于数据集的样本数量除以batch_size。如果未指定，将使用 len(generator) 作为步数。
epochs : 与 initial_epoch 一起，参数 epochs 应被理解为「最终轮数」，不是训练了 epochs 轮，而是到第epochs轮停止训练。
validation_data : 同generator，用于验证。
validation_steps : 同steps_per_epoch，即一个epoch包含多少个batch，只有在validation_data非空时有意义。
workers : 使用的最大进程数量。

实际调用进行训练

# 训练集与验证集的batch_size都取32
model.fit_generator(generator=gen(train_x, train_y, 32), 
                    steps_per_epoch=len(train_y)/32, 
                    validation_data=gen(valid_x, valid_y, 32), 
                    validation_steps=len(valid_y)/32, 
                    verbose=1, callbacks=[earlystoping], workers=16, 
                    )

从文件中读取生成

比较建议这种方法，生成器每次从已经保存好的数据文件中读取一个batch的数据，这样不仅能无限生成数据，节省显存，还能节省内存。

# 数据处理函数
def processing_line(line):
    line = line.split(" ")
    return [float(s) for s in line[1:]], int(line[0])

# 从文件读取数据的生成器
def generate_arrays_from_file(path, batch_size=32):
    while True:
        with open(path) as f:
            batch_x, batch_y = [], []
            for line in f:
                # 读取每一行并处理
                x, y = processing_line(line)
                batch_x.append(x)
                batch_y.append(y)
                # 当batch_x的大小达到要求的batch_size时清空并输出
                if len(batch_y) == batch_size:
                    yield (batch_x, batch_y)
                    batch_x, batch_y = [], []
# training
model.fit_generator(generate_arrays_from_file('/my_file.txt'),
                    steps_per_epoch=1000, epochs=10)

其他

如何查看Keras版本

import keras
print keras.__version__ # 我当前的版本是 2.1.6

如何更改Keras的Backend

作为一个高层次的封装库，Keras不会去管底层的操作（类似张量加法、乘法之类的运算），而是基于某种Backend定义的。Keras支持三种Backend：TensorFlow、Theano和CNTK，默认情况下使用TensorFlow。输入sudo vim ~/.keras/keras.json，可以看到如下内容，只需要把backend字段改成theano或者cntk即可实现切换。

{
    "image_data_format": "channels_last",
    "epsilon": 1e-07,
    "floatx": "float32",
    "backend": "tensorflow"
}

以上参数详解：

image_data_format: String, either “channels_last” or “channels_first”. It specifies which data format convention Keras will follow. (keras.backend.image_data_format() returns it.)
- For 2D data (e.g. image), “channels_last” assumes (rows, cols, channels) while “channels_first” assumes (channels, rows, cols).
- For 3D data, “channels_last” assumes (conv_dim1, conv_dim2, conv_dim3, channels) while “channels_first” assumes (channels, conv_dim1, conv_dim2, conv_dim3).
epsilon: Float, a numeric fuzzing constant used to avoid dividing by zero in some operations.
floatx: String, “float16”, “float32”, or “float64”. Default float precision.
backend: String, “tensorflow”, “theano”, or “cntk”.

有关于Keras的Backend的更多详细信息可以参考这里。

参考资料

Keras文档
 Keras文档（中文版）
使用深度学习来破解 captcha 验证码
 使用深度学习来破解 captcha 验证码（代码）