[PYTHON] Hard-Swish mit Keras implementiert

Überblick

Ich denke, dass mobilet V3 im vergangenen Jahr unter mehreren leichten Modellen des Deep Learning berühmt war (V2 ist auch in Keras implementiert).

H-Swish (Hard-Swish) spielt eine Rolle bei der Gewichtsreduktion.

Da normaler Swish unter Verwendung von Sigmoid schwer ist, ist die Verarbeitung gering und der Fehler bei der Approximation + Quantisierung ist gering.

Es scheint, dass. Eine ausführliche Erklärung des Japanischen finden Sie im folgenden Artikel. Referenz: [[Artikel lesen] Nach Mobilenet V3 suchen](https://woodyzootopia.github.io/2019/09/%E8%AB%96%E6%96%87%E8%AA%AD%E3%81%BFsearching -für-mobileetv3)

In diesem Artikel geht es um die Implementierung von Hard-Swish in Keras. Die Funktion selbst ist jedoch nicht so schwierig, sodass sie im Backend schnell implementiert werden kann. Da es eine große Sache ist, möchte ich swish implementieren und in einem Diagramm vergleichen. Verwenden Sie auch das Backend als Implementierungsmethode

1. Definition als Aktivierungsfunktion
2. Definition als Ebene Es gibt zwei Implementierungen.

Annahme

tensorflow 1.15.0 keras 2.3.1

Bestätigung der Definition

Überprüfen Sie vorerst die Definition.

h-swish [x] = x\frac{ReLU6(x+3)}{6}

swish[x] = x×Sigmoid(x)

[Muster 1] Als Aktivierungsfunktion definiert

1. Funktionsdefinition

Ich habe es unter Bezugnahme auf das offizielle Dokument von Keras implementiert. Verwendung der Aktivierungsfunktion

h-swish.py

from keras import backend as K

#hard_Definition von swish
def hard_swish(x):
    return x * (K.relu(x + 3., max_value = 6.) / 6.)

#Definition von swish
def swish(x):
    return x * K.sigmoid(x)

Das Backend-Relu hat ein Argument "max_value", mit dem Sie eine Obergrenze festlegen können. Nachdem Sie ReLU6 definiert haben, implementieren Sie es einfach gemäß der Formel.

2. Bestätigung der Ergebnisse

Überprüfen Sie, ob die definierte Funktion der Definition entspricht. Berechnen wir erneut mit einem Numpy-Array über das Backend.

backend_result.py

from keras import backend as K

import numpy as np
import matplotlib.pyplot as plt

#-10 bis 10 0.Definieren Sie ein Array in 2 Schritten
inputs = np.arange(-10, 10.2, 0.2)
#Ändern Sie das Numpy-Array in Tensor
inputs_v = K.variable(inputs)
#Definieren Sie einen arithmetischen Graphen mit der definierten Funktion
outputs_hs = hard_swish(inputs_v)
outputs_s = swish(inputs_v)
#Berechnen und Ausgabe erhalten
outputs_hs = K.get_value(outputs_hs)
outputs_s = K.get_value(outputs_s)
#Ergebnisse anzeigen
plt.figure(figsize=(14,7))
plt.yticks(range(0, 9, 1))
plt.xticks(range(-8, 9, 1))
plt.grid(True)
plt.plot(inputs, outputs_hs, label="hard_swish")
plt.plot(inputs, outputs_s, label="swish")
plt.legend(bbox_to_anchor=(1, 1), loc='lower right', borderaxespad=0, fontsize=18)

** Ergebnisse der Implementierung dieses Artikels ** ** Papierergebnisse ** Artikel-URL: Suche nach MobileNetV3

Hört sich gut an.

3. Verwendung

Wenden Sie einfach die zuvor definierte Funktion auf die Aktivierung an.

conv.py

from keras.layers import Conv2D
Conv2D(16,(3,3),padding = "SAME", activation = hard_swish)

Oder

conv.py

from keras.layers import Activation
Activation(hard_swish)

[Muster 2] Definition als Ebene

Ich bezog mich auf die Implementierung von Keras 'Advanced Activations', die auf github veröffentlicht wurden. Papier-URL: advanced_activations.py

h-swish_layer.py

from keras import backend as K
from keras.engine.topology import Layer

#hard_Definition von swish
class Hard_swish(Layer):
    def __init__(self):
        super(Hard_swish, self).__init__()

    def call(self, inputs):
        return inputs * (K.relu(inputs + 3., max_value=6.) / 6.)

    def compute_output_shape(self, input_shape):
        return input_shape

Dies ist ein Beispiel für die Verwendung. Ich gehe von cifar10 aus.

h-swish_use.py

inputs = Input(shape = (32,32,3))
x = Conv2D(64,(3,3),padding = "SAME")(inputs)
x = Hard_swish()(x)
x = Conv2D(64,(3,3),padding = "SAME")(x)
x = Hard_swish()(x)
x = MaxPooling2D()(x)

x = Conv2D(128,(3,3),padding = "SAME")(x)
x = Hard_swish()(x)
x = Conv2D(128,(3,3),padding = "SAME")(x)
x = Hard_swish()(x)
x = MaxPooling2D()(x)

x = Conv2D(256,(3,3),padding = "SAME")(x)
x = Hard_swish()(x)
x = Conv2D(256,(3,3),padding = "SAME")(x)
x = Hard_swish()(x)
x = GlobalAveragePooling2D()(x)

x = Dense(1024)(x)
x = Hard_swish()(x)
prediction = Dense(10,activation = "softmax")(x)

model = Model(inputs, prediction )
model.summary()

model_output

Model: "model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         [(None, 32, 32, 3)]       0         
_________________________________________________________________
conv2d (Conv2D)              (None, 32, 32, 64)        1792      
_________________________________________________________________
hard_swish (Hard_swish)      (None, 32, 32, 64)        0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 32, 32, 64)        36928     
_________________________________________________________________
hard_swish_1 (Hard_swish)    (None, 32, 32, 64)        0         
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 16, 16, 64)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 16, 16, 128)       73856     
_________________________________________________________________
hard_swish_2 (Hard_swish)    (None, 16, 16, 128)       0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 16, 16, 128)       147584    
_________________________________________________________________
hard_swish_3 (Hard_swish)    (None, 16, 16, 128)       0         
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 8, 8, 128)         0         
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 8, 8, 256)         295168    
_________________________________________________________________
hard_swish_4 (Hard_swish)    (None, 8, 8, 256)         0         
_________________________________________________________________
conv2d_5 (Conv2D)            (None, 8, 8, 256)         590080    
_________________________________________________________________
hard_swish_5 (Hard_swish)    (None, 8, 8, 256)         0         
_________________________________________________________________
global_average_pooling2d (Gl (None, 256)               0         
_________________________________________________________________
dense (Dense)                (None, 1024)              263168    
_________________________________________________________________
hard_swish_6 (Hard_swish)    (None, 1024)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 10)                10250     
=================================================================
Total params: 1,418,826
Trainable params: 1,418,826
Non-trainable params: 0
_________________________________________________________________

Der Vorteil (?) Im Vergleich zur Definition der Aktivierungsfunktion besteht darin, dass Sie sehen können, dass "hard-swish" verwendet wird, wenn es mit "summary" (about) visualisiert wird.

abschließend

Dieses Mal konnte ich die Hard-Swish-Keras-Implementierung nicht finden, selbst wenn ich sie gegoogelt habe, also habe ich versucht, sie zu implementieren. Es war eine gute Gelegenheit herauszufinden, dass die ReLU-Funktion, die ich oft verwendet habe, das Argument max_value hat. Wenn Sie Fragen oder Bedenken haben, hinterlassen Sie bitte einen Kommentar.