Keras学习笔记I-Sequential

深度学习 , 评论

1. Keras简介

Keras是集成的神经网络的框架，它的后端是基于Tensorflow、Theano和CNTK的。

  • Keras的架构

  • 使用Keras的一般流程

2. 基本概念

  • 符号计算

    可以理解为计算图，计算图主要有两个元素组成：节点和边。节点通常来代表变量（scalar、vector、tensor等）；边代表的是操作，即一些函数。

  • 张量（tensor）

    直接看作向量即可。

  • 模型

    Keras有两种模型：Sequential和函数式模型（Model），Sequential是函数式模型的特殊形式。

    1. Sequential：将多个网络层线性叠加，存入栈中的。单输入单输出，一条路通到底，层与层之间只是相邻关系，没有跨层连接。这么做的好处是：编译快，操作简单
    2. 函数式模型（Model）：多输入多输出，层与层之间任意连接，但编译慢。

  • batch

    以batch大小的数据集为梯度计算的基本单位。

3. Sequential模型

  • 构造网络层

    1. 利用layer的list来构造该模型：

      1
      2
      3
      4
      5
      6
      from keras.models import Sequential
      from keras.layers import Dense, Activation

      model = Sequential([Dense(32, units=784), Activation('relu'),
                         Dense(10), Activation('softmax'),])
      # Sequential的第一层需要接受一个关于输入数据shape的参数，后面的各层则可以自动的推导出中间数据的shape。

    2. 利用.add()方法加入layer：

      1
      2
      3
      4
      5
      6
      7
      model = Sequential()
      model.add(Dense(32, input_shape(784,)))
      model.add(Activation('relu'))
      # input_shape是一个tuple类型的数据，传递给第一层
      # 有些2D层，支持通过指定其输入维度input_dim来隐含的指定输入数据shape；
      # 一些3D层，支持通过参数input_dim和input_length来指定输入shape；
      # 如果你需要为输入指定一个固定大小的batch_size（常用于stateful RNN网络），可以传递batch_size参数到一个层中，例如你想指定输入张量的batch大小是32，数据shape是（6，8），则你需要传递batch_size=32和input_shape=(6,8)

  • 编译

    我们需要通过compile来对学习过程进行配置，compile接收三个参数：

    1. 优化器optimizer

    2. 损失函数loss

    3. 指标列表metrics

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      # 对于多分类问题
      model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])

      # 对于二分类问题
      model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])

      # 对于回归问题
      model.compile(optimizer='rmsprop', loss='mse')

      # 用户自定义metrics
      import keras.backend as K

      def mean_pred(y_true, y_pred):
          return K.mean(y_pred)

      model.compile(optimizer='rmsprop',
                    loss='binary_crossentropy',
                    metrics=['accuracy', mean_pred])

  • 训练

    一般使用fit函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    # For a single-input model with 2 classes (binary classification):

    model = Sequential()
    model.add(Dense(32, activation='relu', input_dim=100))
    model.add(Dense(1, activation='sigmoid'))
    model.compile(optimizer='rmsprop',
                  loss='binary_crossentropy',
                  metrics=['accuracy'])

    # Generate dummy data
    import numpy as np
    data = np.random.random((1000, 100))
    labels = np.random.randint(2, size=(1000, 1))

    # Train the model, iterating on the data in batches of 32 samples
    model.fit(data, labels, epochs=10, batch_size=32)

  • 例子

    1. 卷积神经网络

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      import numpy as np
      import keras
      from keras.models import Sequential
      from keras.layers import Dense, Dropout, Flatten
      from keras.layers import Conv2D, MaxPooling2D
      from keras.optimizers import SGD

      # Generate dummy data
      x_train = np.random.random((100, 100, 100, 3))
      y_train = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)
      x_test = np.random.random((20, 100, 100, 3))
      y_test = keras.utils.to_categorical(np.random.randint(10, size=(20, 1)), num_classes=10)

      model = Sequential()
      # input: 100x100 images with 3 channels -> (100, 100, 3) tensors.
      # this applies 32 convolution filters of size 3x3 each.
      model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))
      # 参数
      # filters：卷积核的数目（即输出的维度）
      # kernel_size：单个整数或由两个整数构成的list/tuple，卷积核的宽度和长度。如为单个整数，则表示在各个空间维度的相同长度。
      # strides：单个整数或由两个整数构成的list/tuple，为卷积的步长。如为单个整数，则表示在各个空间维度的相同步长。任何不为1的strides均与任何不为1的dilation_rata均不兼容
      # padding：补0策略，为“valid”, “same” 。“valid”代表只进行有效的卷积，即对边界数据不处理。“same”代表保留边界处的卷积结果，通常会导致输出shape与输入shape相同，因为卷积核移动时在边缘会出现大小不够的情况。
      # activation：激活函数，为预定义的激活函数名（参考激活函数），或逐元素（element-wise）的Theano函数。如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）
      # use_bias:布尔值，是否使用偏置项
      # kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
      # bias_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
      # kernel_regularizer：施加在权重上的正则项，为Regularizer对象
      # bias_regularizer：施加在偏置向量上的正则项，为Regularizer对象
      # activity_regularizer：施加在输出上的正则项，为Regularizer对象
      # kernel_constraints：施加在权重上的约束项，为Constraints对象
      # bias_constraints：施加在偏置上的约束项，为Constraints对象
      model.add(Conv2D(32, (3, 3), activation='relu'))
      model.add(MaxPooling2D(pool_size=(2, 2)))
      model.add(Dropout(0.25))

      model.add(Conv2D(64, (3, 3), activation='relu'))
      model.add(Conv2D(64, (3, 3), activation='relu'))
      model.add(MaxPooling2D(pool_size=(2, 2)))
      model.add(Dropout(0.25))

      # Flatten层用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。Flatten不影响batch的大小。
      model.add(Flatten())
      model.add(Dense(256, activation='relu'))
      model.add(Dropout(0.5))
      model.add(Dense(10, activation='softmax'))

      sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
      # 参数：
      # lr：大于0的浮点数，学习率
      # momentum：大于0的浮点数，动量参数
      # decay：大于0的浮点数，每次更新后的学习率衰减值
      # nesterov：布尔值，确定是否使用Nesterov动量
      model.compile(loss='categorical_crossentropy', optimizer=sgd)

      model.fit(x_train, y_train, batch_size=32, epochs=10)
      score = model.evaluate(x_test, y_test, batch_size=32)

      ​

ciicA BOCer

个人简介