基於CIFAR10（小批量圖片）資料集訓練簡單的膠囊（組神經元）深度卷積神經網路

程式碼註釋

"""Train a simple CNN-Capsule Network on the CIFAR10 small images dataset.
基於CIFAR10（小批量圖片）資料集訓練簡單的膠囊（組神經元）深度卷積神經網路
Without Data Augmentation:
It gets to 75% validation accuracy in 10 epochs,
and 79% after 15 epochs, and overfitting after 20 epochs.
不擴充套件資料集，10個週期後達到7%%的準確率，15個週期後達到79%的準確率，20個週期後過擬合。

With Data Augmentation:
It gets to 75% validation accuracy in 10 epochs,
and 79% after 15 epochs, and 83% after 30 epcohs.
In my test, highest validation accuracy is 83.79% after 50 epcohs.
不擴充套件資料集，10個週期後達到7%%的準確率，15個週期後達到79%的準確率，30個週期達到83%的準確率。
測試中，最好成績是50個週期達到83.79%的準確率

This is a fast Implement, just 20s/epcoh with a gtx 1070 gpu.
快速實現，基於一個gtx 1070 GPU（影象處理器，顯示卡）每個週期執行需要20秒
"""

from __future__ import print_function
from keras import backend as K
from keras.engine.topology import Layer
from keras import activations
from keras import utils
from keras.datasets import cifar10
from keras.models import Model
from keras.layers import *
from keras.preprocessing.image import ImageDataGenerator


# the squashing function.
# 壓平函式
# we use 0.5 in stead of 1 in hinton's paper.
# 在hinton的論文中，使用0.5代替1
# if 1, the norm of vector will be zoomed out.
# 如果是1，向量範數將縮小
# if 0.5, the norm will be zoomed in while original norm is less than 0.5
# 如果是1，原範數小於0.5，向量範數將放大
# and be zoomed out while original norm is greater than 0.5.
# 原範數大於0.5，向量範數將縮小
def squash(x, axis=-1):
    s_squared_norm = K.sum(K.square(x), axis, keepdims=True) + K.epsilon()
    scale = K.sqrt(s_squared_norm) / (0.5 + s_squared_norm)
    return scale * x


# define our own softmax function instead of K.softmax
# because K.softmax can not specify axis.
# 自定義softmax函式，替換K.softmax函式，因為K.softmax函式不能指定軸
def softmax(x, axis=-1):
    ex = K.exp(x - K.max(x, axis=axis, keepdims=True))
    return ex / K.sum(ex, axis=axis, keepdims=True)


# define the margin loss like hinge loss
# 定義利潤邊緣損失，如hinge損失
def margin_loss(y_true, y_pred):
    lamb, margin = 0.5, 0.1
    return y_true * K.square(K.relu(1 - margin - y_pred)) + lamb * (
        1 - y_true) * K.square(K.relu(y_pred - margin))


class Capsule(Layer):
    """A Capsule Implement with Pure Keras
    基於純Keras的膠囊（組神經元）實現
    There are two vesions of Capsule.
    以下是2個版本的膠囊（組神經元）
    One is like dense layer (for the fixed-shape input),
    一種類似與全連線層（對於固定形狀輸入），
    and the other is like timedistributed dense (for various length input).
    一種類似時間分佈的全連線層（對於變長輸入），

    The input shape of Capsule must be (batch_size,
                                        input_num_capsule,
                                        input_dim_capsule
                                       )
    膠囊（組神經元）輸入（資料）形狀為：

    and the output shape is (batch_size,
                             num_capsule,
                             dim_capsule
                            )
     輸出（資料）形狀為：

    Capsule Implement is from https://github.com/bojone/Capsule/
    膠囊（組神經元）實現見：https://github.com/bojone/Capsule/
    Capsule Paper: https://arxiv.org/abs/1710.09829
    膠囊（組神經元）論文：https://arxiv.org/abs/1710.09829
    """

    def __init__(self,
                 num_capsule,
                 dim_capsule,
                 routings=3,
                 share_weights=True,
                 activation='squash',
                 **kwargs):
        super(Capsule, self).__init__(**kwargs)
        self.num_capsule = num_capsule
        self.dim_capsule = dim_capsule
        self.routings = routings
        self.share_weights = share_weights
        if activation == 'squash':
            self.activation = squash
        else:
            self.activation = activations.get(activation)

    def build(self, input_shape):
        input_dim_capsule = input_shape[-1]
        if self.share_weights:
            self.kernel = self.add_weight(
                name='capsule_kernel',
                shape=(1, input_dim_capsule,
                       self.num_capsule * self.dim_capsule),
                initializer='glorot_uniform',
                trainable=True)
        else:
            input_num_capsule = input_shape[-2]
            self.kernel = self.add_weight(
                name='capsule_kernel',
                shape=(input_num_capsule, input_dim_capsule,
                       self.num_capsule * self.dim_capsule),
                initializer='glorot_uniform',
                trainable=True)

    def call(self, inputs):
        """Following the routing algorithm from Hinton's paper,
        根據Hinton論文的路由演算法，
        but replace b = b + <u,v> with b = <u,v>.
        但是 用b = <u,v>替換b = b + <u,v>

        This change can improve the feature representation of Capsule.
        這種改變可以改善膠囊（組神經元）的特徵表示。

        However, you can replace
        而且，可以把替換
            b = K.batch_dot(outputs, hat_inputs, [2, 3])
        with
        使用
            b += K.batch_dot(outputs, hat_inputs, [2, 3])
        to realize a standard routing.
        實現標準路由。
        """

        if self.share_weights:
            hat_inputs = K.conv1d(inputs, self.kernel)
        else:
            hat_inputs = K.local_conv1d(inputs, self.kernel, [1], [1])

        batch_size = K.shape(inputs)[0]
        input_num_capsule = K.shape(inputs)[1]
        hat_inputs = K.reshape(hat_inputs,
                               (batch_size, input_num_capsule,
                                self.num_capsule, self.dim_capsule))
        hat_inputs = K.permute_dimensions(hat_inputs, (0, 2, 1, 3))

        b = K.zeros_like(hat_inputs[:, :, :, 0])
        for i in range(self.routings):
            c = softmax(b, 1)
            if K.backend() == 'theano':
                o = K.sum(o, axis=1)
            o = self.activation(K.batch_dot(c, hat_inputs, [2, 2]))
            if i < self.routings - 1:
                b = K.batch_dot(o, hat_inputs, [2, 3])
                if K.backend() == 'theano':
                    o = K.sum(o, axis=1)

        return o

    def compute_output_shape(self, input_shape):
        return (None, self.num_capsule, self.dim_capsule)


batch_size = 128
num_classes = 10
epochs = 100
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = utils.to_categorical(y_train, num_classes)
y_test = utils.to_categorical(y_test, num_classes)

# A common Conv2D model
# 2維卷積模型
input_image = Input(shape=(None, None, 3))
x = Conv2D(64, (3, 3), activation='relu')(input_image)
x = Conv2D(64, (3, 3), activation='relu')(x)
x = AveragePooling2D((2, 2))(x)
x = Conv2D(128, (3, 3), activation='relu')(x)
x = Conv2D(128, (3, 3), activation='relu')(x)


"""now we reshape it as (batch_size, input_num_capsule, input_dim_capsule)
then connect a Capsule layer.
重塑（資料）形狀為 (batch_size, input_num_capsule, input_dim_capsule)
然後，連結一個膠囊（組神經元）層

the output of final model is the lengths of 10 Capsule, whose dim=16.
最終模型輸出為16維的10個膠囊（組神經元）

the length of Capsule is the proba,
膠囊（組神經元）的長度是proba
so the problem becomes a 10 two-classification problem.
因此問題成為10個兩分類問題。
"""

x = Reshape((-1, 128))(x)
capsule = Capsule(10, 16, 3, True)(x)
output = Lambda(lambda z: K.sqrt(K.sum(K.square(z), 2)))(capsule)
model = Model(inputs=input_image, outputs=output)

# we use a margin loss
# 使用邊緣損失（函式）
model.compile(loss=margin_loss, optimizer='adam', metrics=['accuracy'])
model.summary()

# we can compare the performance with or without data augmentation
# 比較效果，有和沒有資料集（擴大）
data_augmentation = True

if not data_augmentation:
    print('Not using data augmentation.')
    model.fit(
        x_train,
        y_train,
        batch_size=batch_size,
        epochs=epochs,
        validation_data=(x_test, y_test),
        shuffle=True)
else:
    print('Using real-time data augmentation.')
    # This will do preprocessing and realtime data augmentation:
    #  預處理和實時資料擴大（通過平移、翻轉等影象變換增加影象樣本數量）。
    datagen = ImageDataGenerator(
        featurewise_center=False,  # set input mean to 0 over the dataset  # 基於資料集，使輸入資料平均值為0
        samplewise_center=False,  # set each sample mean to 0 # 使樣本平均值為0
        featurewise_std_normalization=False,  # divide inputs by std of the dataset # 通過資料標準化劃分輸入資料
        samplewise_std_normalization=False,  # divide each input by its std # 通過標準化劃分輸入資料
        zca_whitening=False,  # apply ZCA（Zero-phase Component Analysis） whitening # 對輸入資料施加ZCA白化
        rotation_range=0,  # randomly rotate images in the range (degrees, 0 to 180) # 旋轉影象0-180度
        width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width) # 水平平移影象（基於影象寬度比例）
        height_shift_range=0.1,  # randomly shift images vertically (fraction of total height) # 垂直平移影象（基於影象高度比例）
        horizontal_flip=True,  # randomly flip images # 水平翻轉影象
        vertical_flip=False)  # randomly flip images # 垂直翻轉影象

    # Compute quantities required for feature-wise normalization
    # 特徵歸一化的計算量
    # (std, mean, and principal components if ZCA whitening is applied).
    # （如果ZCA白化（一種降維方法）會使用標準化、均值和主成分方法）
    datagen.fit(x_train)

    # Fit the model on the batches generated by datagen.flow().
    # 使用datagen.flow()生成的批次資料在模型訓練
    model.fit_generator(
        datagen.flow(x_train, y_train, batch_size=batch_size),
        epochs=epochs,
        validation_data=(x_test, y_test),
        workers=4)
 

程式碼執行

Keras詳細介紹

例項下載

完整專案下載

方便沒積分童鞋，請加企鵝452205574，共享資料夾。

包括：程式碼、資料集合（圖片）、已生成model、安裝庫檔案等。