[PYTHON] Apprentissage parallèle du deep learning par Keras et Kubernetes

Apprentissage parallèle du deep learning par Keras et Kubernetes

J'ai écrit plus tôt que Keras prend en charge CNTK.

Exécutez Keras avec le backend CNTK à partir de CentOS

Keras peut désormais utiliser Theano, TensorFlow et CNTK comme backends pour utiliser différents frameworks dans le même programme. Je pense que l'avantage d'augmenter le backend de Keras est que vous pouvez changer le cadre et apprendre en changeant simplement les variables d'environnement. Changer le cadre ne changera (probablement) pas le modèle de réseau neuronal lui-même si le programme est le même, mais la précision et la vitesse changeront légèrement. Vous pouvez également regrouper et déduire les modèles entraînés dans chaque cadre. Je suis venu avec un ensemble de cadres multiples, donc je l'ai essayé.

Le programme et le yml de Kubernetes se trouvent ci-dessous. https://github.com/shibuiwilliam/keras_multibackend

Apprenez plusieurs backends Keras en parallèle

C'est ennuyeux d'essayer plusieurs frameworks d'apprentissage profond séquentiellement à partir de Keras avec le même programme, j'ai donc essayé de former chaque framework en parallèle à l'aide de Kubernetes. L'image est la suivante.

C'est ennuyeux d'apprendre séquentiellement.

Apprenons en parallèle.

Vue d'ensemble

Laissez Kubernetes apprendre l'apprentissage en profondeur en parallèle sur un conteneur Docker. L'image globale est la suivante.

Des configurations de plate-forme et de programme sont requises.

Plate-forme

Préparez trois machines virtuelles. Cette fois, il s'agit de CentOS 7.3. Faites de VM1 un serveur NFS et montez le répertoire partagé sur VM2 et VM3. Placez les programmes d'apprentissage et d'inférence Keras dans le répertoire partagé. Les VM 1, 2 et 3 pourront toutes accéder aux programmes d'apprentissage et d'inférence Keras.

Formez un cluster Kubernetes avec VM1,2,3. Générez VM1,2,3 avec Keras, Theano, TensorFlow, CNTK et d'autres images Docker installées.

Le Dockerfile utilisé cette fois est ci-dessous.

https://github.com/shibuiwilliam/keras_multibackend

Kubernetes effectue une formation CNN Cifar 10 par chaque framework en tant que travail. Nous préparerons 3 types de yml pour Job. Définissez les valeurs de chaque variable d'environnement KERAS_BACKEND comme Theano, TensorFlow et CNTK.

La définition de Job yml de Kubernetes est la suivante. Tout d'abord, c'est pour apprendre. Bien que CNTK soit illustré, Tensorflow et Theano ne modifient que la valeur de Keras_Backend.

apiVersion: batch/v1
kind: Job
metadata:
  name: kerascntk
spec:
  template:
    spec:
      restartPolicy: Never
      volumes:
        - name: nfstest
          nfs:
            server: 10.249.20.65
            path: "/tmp/nfstest/"
      containers:
        - name: kerascntk
          image: jupyter:1.52
          volumeMounts:
              - name: nfstest
                mountPath: "/tmp/nfstest/"
          env:
              - name: KERAS_BACKEND
                value: "cntk"
          command: ["python"]
          args: ["/tmp/nfstest/cifar_train.py"]

Pour inférence. L'inférence est additionnée avec 3 inférences backend en Python, vous n'en avez donc besoin que d'une ci-dessous.

apiVersion: batch/v1
kind: Job
metadata:
  name: pred
spec:
  template:
    spec:
      restartPolicy: Never
      volumes:
        - name: nfstest
          nfs:
            server: 10.249.20.65
            path: "/tmp/nfstest/"
      containers:
        - name: pred
          image: jupyter:1.52
          volumeMounts:
              - name: nfstest
                mountPath: "/tmp/nfstest/"
          command: ["python"]
          args: ["/tmp/nfstest/cifar_pred.py"]

programme

Préparez un programme d'apprentissage Keras et un programme d'inférence. Il n'est pas nécessaire de créer chaque cadre séparément. Étant donné que la variable d'environnement KERAS_BACKEND est définie et divisée en yml de Kubernetes Job, il existe un programme pour l'apprentissage et un pour l'inférence.

Chaque programme est le suivant. Tout d'abord, c'est pour apprendre. Je n'ai fait aucun effort particulier. C'est un CNN ordinaire de type VGG. Le nombre d'époques est de 50, mais comme l'arrêt anticipé est également défini, il est censé se terminer dans environ 20 époques. En outre, 100 images de données de test sont exclues de l'évaluation pour une utilisation en inférence.

#Pour apprendre

# see its environment variable
import os
kerasBKED = os.environ["KERAS_BACKEND"]
print(kerasBKED)

# imports
import keras
from keras.models import load_model
from keras.datasets import cifar10
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.callbacks import EarlyStopping, ModelCheckpoint
import pickle
import numpy as np

# variables
batch_size = 32
num_classes = 10
epochs = 50

# loading and reshaping cifar10 data
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255

# leave out 100 images for prediction
x_test1 = x_test[100:,:]
x_test2 = x_test[:100,:]
y_test1 = y_test[100:,:]
y_test2 = y_test[:100,:]
print(x_test1.shape, x_test2.shape, y_test1.shape, y_test2.shape)
# only test1 data is used for validation

# VGG-like neural network model
model = Sequential()
model.add(Conv2D(32, (3, 3), padding='same',
                 input_shape=x_train.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

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

model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes))
model.add(Activation('softmax'))

opt = keras.optimizers.adam()

model.compile(loss='categorical_crossentropy',
              optimizer=opt,
              metrics=['accuracy'])


# Add checkpoint and earlystopping
chkpt = '/tmp/nfstest/cifar_weights/' + kerasBKED + '_weights.{epoch:02d}-{loss:.2f}-{val_loss:.2f}.hdf5'
cp_cb = ModelCheckpoint(filepath = chkpt, monitor='val_loss', verbose=1, save_best_only=True, mode='auto')
es_cb = EarlyStopping(monitor='val_loss', patience=1, verbose=1, mode='auto')

# fit the model
history = model.fit(x_train, y_train,
                    batch_size=batch_size,
                    epochs=epochs,
                    verbose=1,
                    validation_data=(x_test1, y_test1),
                    callbacks=[cp_cb, es_cb],
                    shuffle=True)

# score and save the model
score = model.evaluate(x_test1, y_test1, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

saveDir = "/tmp/nfstest/cifar_model/"
if not os.path.isdir(saveDir):
    os.makedirs(saveDir)
modelName = "{0}_{1}_model.hdf5".format(kerasBKED, score[1])
model_path = os.path.join(saveDir, modelName)
model.save(model_path)

À la fin de la formation, enregistrez le modèle dans le répertoire NFS. Par conséquent, trois types de modèles sont stockés dans le répertoire NFS. L'inférence utilise ces trois modèles. Pour l'inférence, utilisez 100 images extraites des données de test. Inférer en appelant les trois types de fichiers de modèle (Theano, Tensorflow, CNTK) créés par apprentissage. Puisqu'il y a une différence dans la précision de l'entraînement dans chaque modèle, l'inférence est multipliée par la précision et finalement divisée par la somme de la précision. Cela ressemble à un modèle d'ensemble, mais il n'a aucun support théorique.

#Pour raisonner

# import
import keras
from keras.models import load_model
from keras.datasets import cifar10
import os

# variables
batch_size = 32
num_classes = 10

# load and reshape data
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255

x_test1 = x_test[100:,:]
x_test2 = x_test[:100,:]
y_test1 = y_test[100:,:]
y_test2 = y_test[:100,:]
# test2 data is used for prediction

# get a list of model files
backList = ["cntk", "tensorflow", "theano"]
saveDir = "/tmp/nfstest/cifar_model/"
files = os.listdir(saveDir)
filesList = [f for f in files if os.path.isfile(os.path.join(saveDir, f))]
filesList

# predict using each model
prediction = 0
sumAcc = 0
for bk in backList:
    os.environ["KERAS_BACKEND"] = bk
    kerasBKED = os.environ["KERAS_BACKEND"]
    modelName = [m for m in filesList if bk in m][0]
    modelAcc = float(modelName.split("_")[1])
    print("MODELNAME {0} \t for BACKEND {1} \t with ACCURACY {2}".format(modelName, kerasBKED, modelAcc))
    model = load_model(os.path.join(saveDir, modelName))
    prediction += model.predict(x_test2, batch_size=batch_size, verbose=0) * modelAcc
    sumAcc += modelAcc
prediction = prediction / sumAcc
print(prediction)

# output predictions to csv
import csv
with open("/tmp/nfstest/cifar_model/preds.csv", 'w') as f:
    writer = csv.writer(f, lineterminator='\n')
    writer.writerows(prediction)


predlist = []
for i in prediction:
    pred = max(enumerate(i), key=lambda x: x[1])[0]
    predlist.append([pred, i[pred]])
print(predlist)


# output overall summary to csv
import csv
with open("/tmp/nfstest/cifar_model/pred.csv", 'w') as f:
    writer = csv.writer(f, lineterminator='\n')
    writer.writerow(predlist)

Le résultat d'essayer

Lors de l'apprentissage, les trois cadres se sont installés sur presque la même précision.

C'est naturel parce que nous apprenons avec le même réseau neuronal.

Cependant, en ce qui concerne le raisonnement, il y a une légère différence dans le back-end. Vous trouverez ci-dessous une liste de 10 données de test déduites par chaque backend. (Dans le programme ci-dessus, nous déduisons à partir de 100 données d'image, mais comme c'est trop, nous le limiterons à 10.) Pour les premières données d'image, CNTK en déduit 4 à 49,498%, tandis que Tensorflow et Theano en déduisent 3 à 55,225% et 67,820%, respectivement. En multipliant l'inférence et la précision de chaque backend et en les divisant par le total de la précision, on en déduit que 3 est 57,855%. La réponse correcte pour chaque donnée d'image est répertoriée comme réponse à gauche de l'ensemble.

\frac{0.49498 * 0.771 + 0.55225 * 0.772 + 0.67820 * 0.785}{0.771 + 0.772 + 0.785} \\
= 0.57855

Les secondes données d'image sont 8 pour CNTK, Tensorflow et Theano. Cependant, dans les troisièmes données, CNTK est de 0 à 41,421%, Tensorflow de 8 à 72,917% et Theano de 1 à 52,288%.

Ce qui est intéressant à regarder, c'est que même si les backends individuels sont incorrects, l'ensemble sera correct. Par exemple, dans l'image 3, CNTK, Tensorflow et Theano font des inférences séparées, mais Tensorflow déduit 8 avec la probabilité la plus élevée, donc l'ensemble est également 8.

Résumé

Dans la phase d'apprentissage, les deux backends étaient tout aussi précis. Cependant, si vous essayez de déduire, chacun peut donner des résultats différents. Un autre ensemble semble donner la bonne réponse avec une plus grande précision que l'inférence avec un seul backend.

Nous avons réussi un apprentissage parallèle avec Kubernetes. Kubernetes Job exécute le programme spécifié dans le cluster, ce qui est très pratique. Kubernetes dispose également d'un Cron Job, qui semble être capable d'exécuter des Jobs de manière chronométrée. Lors de la planification d'une étude d'apprentissage en profondeur, je trouve utile de l'automatiser avec Cron Job de Kubernetes. Donc, la prochaine fois, je vérifierai l'exécution automatique de l'apprentissage profond par Kubernetes Cron Job.