Keras入门简介

最新推荐文章于 2024-07-14 23:44:42 发布

vivian_ll

最新推荐文章于 2024-07-14 23:44:42 发布

阅读量4.2k

点赞数 8

分类专栏：深度学习机器学习

本文链接：https://blog.csdn.net/vivian_ll/article/details/80795139

版权

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

71 篇文章 24 订阅

订阅专栏

深度学习

15 篇文章 3 订阅

订阅专栏

一、使用Keras搭建模型

Keras是一个高层神经网络API，Keras由纯Python编写而成并基Tensorflow、Theano以及CNTK后端。
Keras的核心数据结构是“模型”，模型是一种组织网络层的方式。
Keras里有两种搭建模型的方式，一种是序贯模型（Sequential），一种是函数式模型（Model）。

1.1 序贯模型

序贯模型是多个网络层的线性堆叠，也就是“一条路走到黑”。使用序列模型，首先我们要实例化Sequential类，之后就是使用该类的add函数加入我们想要的每一层，从而实现我们的模型。或者通过向Sequential模型传递一个layer的list来构造该模型。
例：

model = Sequential()
model.add(Dense(32, input_shape=(784,)))
model.add(Activation('relu'))

Sequential的第一层需要接受一个关于输入数据shape的参数，后面的各个层则可以自动的推导出中间数据的shape，因此不需要为每个层都指定这个参数。

1.2 函数式模型

Keras函数式模型接口是用户定义多输出模型、非循环有向模型或具有共享层的模型等复杂模型的途径。一句话，只要你的模型不是类似VGG一样一条路走到黑的模型，或者你的模型需要多于一个的输出，那么你总应该选择函数式模型。
函数式模型是最广泛的一类模型，序贯模型（Sequential）只是它的一种特殊情况。使用通用模型，首先要使用Input函数将输入转化为一个tensor，然后将每一层用变量存储后，作为下一层的参数，最后使用Model类将输入和输出作为参数即可搭建模型。
例：

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

# This returns a tensor
inputs = Input(shape=(784,))

# a layer instance is callable on a tensor, and returns a tensor
x = Dense(64, activation='relu')(inputs)
x = Dense(64, activation='relu')(x)
predictions = Dense(10, activation='softmax')(x)

# This creates a model that includes
# the Input layer and three Dense layers
model = Model(inputs=inputs, outputs=predictions)
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(data, labels)  # starts training

1.3 常用模型方法

序贯模型：

add 向模型中添加一个层
pop 弹出模型最后的一层，无返回值

序贯模型和函数式模型：

compile 编译用来配置模型的学习过程，参数有优化器，损失函数，评估模型在训练和测试时的网络性能的指标等。

compile(optimizer, loss, metrics=None)

参数说明：
optimizer：优化器，如：’SGD‘，’Adam‘等。
loss：定义模型的损失函数，如：’mse’，’mae‘等。
metric：模型的评价指标，如：’accuracy‘等。

fit 将模型训练nb_epoch轮

fit(x=None, y=None, batch_size=None, epochs=1, verbose=1, validation_split=0.0)

参数说明：
x：输入数据。
y：标签。
batch_size：梯度下降时每个batch包含的样本数。
epochs：整数，所有样本的训练次数。
verbose：日志显示，0为不显示，1为显示进度条记录，2为每个epochs输出一行记录。
validation_split：0-1的浮点数，切割输入数据的一定比例作为验证集。
evaluate 按batch计算在某些输入数据上模型的误差
predict 按batch获得输入数据对应的输出

其他还有train_on_batch，test_on_batch，predict_on_batch，fit_generator，evaluate_generator，predict_generator等。

二、核心层常用函数

2.1 全连接层

神经网络中最常用到的，实现对神经网络里的神经元激活。

Dense（units, activation=’relu’, use_bias=True）

参数说明：
units: 全连接层输出的维度，即下一层神经元的个数。
activation：激活函数，默认使用Relu。
use_bias：是否使用bias偏置项。

2.2 激活层

对上一层的输出应用激活函数。

Activation(activation)

参数说明：
Activation：想要使用的激活函数，如：’relu’、’tanh’、‘sigmoid’等。

2.3 Dropout层

对上一层的神经元随机选取一定比例的失活，不更新，但是权重仍然保留，防止过拟合。

Dropout(rate)

参数说明:

rate：失活的比例，0-1的浮点数。

2.4 Flatten层

将一个维度大于或等于3的高维矩阵，“压扁”为一个二维矩阵。即保留第一个维度（如：batch的个数），然后将剩下维度的值相乘作为“压扁”矩阵的第二个维度。

Flatten()

2.5 Reshape层

该层的作用和reshape一样，就是将输入的维度重构成特定的shape。

Reshape(target_shape)

参数说明：

target_shape：目标矩阵的维度，不包含batch样本数。

如我们想要一个9个元素的输入向量重构成一个(None, 3, 3)的二维矩阵：

Reshape((3,3), input_length=(16, ))

2.6 卷积层

卷积操作分为一维、二维、三维，分别为Conv1D、Conv2D、Conv3D。一维卷积主要应用于以时间序列数据或文本数据，二维卷积通常应用于图像数据。由于这三种的使用和参数都基本相同，所以主要以处理图像数据的Conv2D进行说明。

Conv2D(filters, kernel_size, strides=(1, 1), padding=’valid’)

参数说明：

filters：卷积核的个数。

kernel_size：卷积核的大小。

strdes：步长，二维中默认为(1, 1)，一维默认为1。

Padding：补“0”策略，’valid‘指卷积后的大小与原来的大小可以不同，’same‘则卷积后大小与原来大小一致。

2.7 池化层

与卷积层一样，最大统计量池化和平均统计量池化也有三种，分别为MaxPooling1D、MaxPooling2D、MaxPooling3D和AveragePooling1D、AveragePooling2D、AveragePooling3D，由于使用和参数基本相同，所以主要以MaxPooling2D进行说明。

MaxPooling(pool_size=(2,2), strides=None, padding=’valid’)

参数说明：

pool_size：长度为2的整数tuple，表示在横向和纵向的下采样样子，一维则为纵向的下采样因子。

padding：和卷积层的padding一样。

2.8 循环层

循环神经网络中的RNN、LSTM和GRU都继承本层，所以该父类的参数同样使用于对应的子类SimpleRNN、LSTM和GRU。

Recurrent(return_sequences=False)

return_sequences：控制返回的类型，“False”返回输出序列的最后一个输出，“True”则返回整个序列。当我们要搭建多层神经网络（如深层LSTM）时，若不是最后一层，则需要将该参数设为True。

2.9 嵌入层

该层只能用在模型的第一层，是将所有索引标号的稀疏矩阵映射到致密的低维矩阵。如我们对文本数据进行处理时，我们对每个词编号后，我们希望将词编号变成词向量就可以使用嵌入层。

Embedding(input_dim, output_dim, input_length)

参数说明：
Input_dim：大于或等于0的整数，字典的长度即输入数据的个数。
output_dim：输出的维度，如词向量的维度。
input_length：当输入序列的长度为固定时为该长度，然后要在该层后加上Flatten层，然后再加上Dense层，则必须指定该参数，否则Dense层无法自动推断输出的维度。

该层可能有点费解，举个例子，当我们有一个文本，该文本有100句话，我们已经通过一系列操作，使得文本变成一个(100,32)矩阵，每行代表一句话，每个元素代表一个词，我们希望将该词变为64维的词向量：
Embedding(100, 64, input_length=32)
则输出的矩阵的shape变为(100, 32, 64)：即每个词已经变成一个64维的词向量。
可以发现Keras在搭建模型比起Tensorflow等简单太多了，如Tensorflow需要定义每一层的权重矩阵，输入用占位符等，这些在Keras中都不需要，我们只要在第一层定义输入维度，其他层定义输出维度就可以搭建起模型，通俗易懂，方便高效，这是Keras的一个显著的优势。

三、数据预处理

3.1 序列预处理

填充序列pad_sequences

keras.preprocessing.sequence.pad_sequences(sequences, maxlen=None, dtype='int32',
    padding='pre', truncating='pre', value=0.)

将长为nb_samples的序列（标量序列）转化为形如(nb_samples,nb_timesteps)2D numpy array。如果提供了参数maxlen，nb_timesteps=maxlen，否则其值为最长序列的长度。其他短于该长度的序列都会在后部填充0以达到该长度。长于nb_timesteps的序列将会被截断，以使其匹配目标长度。padding和截断发生的位置分别取决于padding和truncating.
返回形如(nb_samples,nb_timesteps)的2D张量
跳字skipgrams
获取采样表make_sampling_table

3.2 文本预处理

句子分割text_to_word_sequence

keras.preprocessing.text.text_to_word_sequence(text,
                                               filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n',
                                               lower=True,
                                               split=" ")

将一个句子拆分成单词构成的列表

参数：
text：字符串，待处理的文本
filters：需要滤除的字符的列表或连接形成的字符串，例如标点符号。默认值为 '!"#$%&()*+,-./:;<=>?@[]^_`{|}~\t\n'，包含标点符号，制表符和换行符等
lower：布尔值，是否将序列设为小写形式
split：字符串，单词的分隔符，如空格
返回值：
字符串列表
one-hot编码

keras.preprocessing.text.one_hot(text,
                                 n,
                                 filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n',
                                 lower=True,
                                 split=" ")

本函数将一段文本编码为one-hot形式的码，即仅记录词在词典中的下标。
【Tips】从定义上，当字典长为n时，每个单词应形成一个长为n的向量，其中仅有单词本身在字典中下标的位置为1，其余均为0，这称为one-hot。
为方便起见，函数在这里仅把“1”的位置，即字典中词的下标记录下来。
参数：
n：整数，字典长度
返回值：
整数列表，每个整数是[1,n]之间的值，代表一个单词（不保证唯一性，即如果词典长度不够，不同的单词可能会被编为同一个码）。
特征哈希hashing_trick
分词器Tokenizer

keras.preprocessing.text.Tokenizer(num_words=None,
                                   filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~\t\n',
                                   lower=True,
                                   split=" ",
                                   char_level=False)

Tokenizer是一个用于向量化文本，或将文本转换为序列（即单词在字典中的下标构成的列表，从1算起）的类。

构造参数：
与text_to_word_sequence同名参数含义相同
num_words：None或整数，处理的最大单词数量。若被设置为整数，则分词器将被限制为待处理数据集中最常见的num_words个单词
char_level: 如果为 True, 每个字符将被视为一个标记

类方法:

fit_on_texts(texts)
texts：要用以训练的文本列表
texts_to_sequences(texts)
texts：待转为序列的文本列表
返回值：序列的列表，列表中每个序列对应于一段输入文本
texts_to_sequences_generator(texts)
本函数是texts_to_sequences的生成器函数版
texts：待转为序列的文本列表
返回值：每次调用返回对应于一段输入文本的序列
texts_to_matrix(texts, mode)：
texts：待向量化的文本列表
mode：‘binary’，‘count’，‘tfidf’，‘freq’之一，默认为‘binary’
返回值：形如(len(texts), nb_words)的numpy array
fit_on_sequences(sequences):
sequences：要用以训练的序列列表
sequences_to_matrix(sequences):
sequences：待向量化的序列列表
mode：‘binary’，‘count’，‘tfidf’，‘freq’之一，默认为‘binary’
返回值：形如(len(sequences), nb_words)的numpy array

属性：

word_counts:字典，将单词（字符串）映射为它们在训练期间出现的次数。仅在调用fit_on_texts之后设置。
word_docs: 字典，将单词（字符串）映射为它们在训练期间所出现的文档或文本的数量。仅在调用fit_on_texts之后设置。
word_index: 字典，将单词（字符串）映射为它们的排名或者索引。仅在调用fit_on_texts之后设置。
document_count: 整数。分词器被训练的文档（文本或者序列）数量。仅在调用fit_on_texts或fit_on_sequences之后设置。

一个示例：

import keras.preprocessing.text as T
from keras.preprocessing.text import Tokenizer

text1='some thing to eat'
text2='some thing to drink'
texts=[text1,text2]

print T.text_to_word_sequence(text1)  #['some', 'thing', 'to', 'eat']
print T.one_hot(text1,10)  #[7, 9, 3, 4]
print T.one_hot(text2,10)  #[7, 9, 3, 1]

tokenizer = Tokenizer(num_words=10)
tokenzier.fit_on_text(texts)
print tokenizer.word_count #[('some', 2), ('thing', 2), ('to', 2), ('eat', 1), ('drink', 1)]
print tokenizer.word_index #{'some': 1, 'thing': 2,'to': 3 ','eat': 4, drink': 5}
print tokenizer.word_docs #{'some': 2, 'thing': 2, 'to': 2, 'drink': 1,  'eat': 1}
print tokenizer.index_docs #{1: 2, 2: 2, 3: 2, 4: 1, 5: 1}

print tokenizer.text_to_sequences(texts) #[[1, 2, 3, 4], [1, 2, 3, 5]]
print tokenizer.text_to_matrix(texts) #
[[ 0.,  1.,  1.,  1.,  1.,  0.,  0.,  0.,  0.,  0.],
 [ 0.,  1.,  1.,  1.,  0.,  1.,  0.,  0.,  0.,  0.]]

import keras.preprocessing.sequence as S
S.pad_sequences([[1,2,3]],10,padding='post')
# [[1, 2, 3, 0, 0, 0, 0, 0, 0, 0]]