Google ColaboratoryとJupyter上での深層学習の結果の違いについて

Question

初めて質問させていただきます。
私はPythonで画像に関する深層学習を勉強も兼ねて初心者なりに行っている者なのですが、その実行結果についてわからないことがあり、今回こちらで質問いたしました。
ご教授頂けますと幸いです、どうぞよろしくお願いいたします。

私は現在、画面一番下のソースコードを使用し、Google ColaboratoryとJupyter上で深層学習を動かしているのですが、
それぞれの環境で学習した2つのモデルが、恐らく全く異なったものになっているといった問題が起きています。

具体的には、ealry stoppingも使用し、各々モデルの学習を進めた際の抜粋した段階的な結果が、以下のようになっております。

Google Colaboratoryの場合：

Epoch 1/100
3/3 [===========] - 23s 6s/step - loss: 3.8230 - accuracy: 0.4375 - val_loss: 2.6128 - val_accuracy: 0.5000
Epoch 2/100
3/3 [===========] - 17s 5s/step - loss: 2.6188 - accuracy: 0.4741 - val_loss: 1.0412 - val_accuracy: 0.5000
...
Epoch 69/100
3/3 [===========] - 17s 5s/step - loss: 0.2823 - accuracy: 0.9120 - val_loss: 0.4176 - val_accuracy: 0.7833
Epoch 70/100
3/3 [===========] - 17s 5s/step - loss: 0.2613 - accuracy: 0.9159 - val_loss: 0.5028 - val_accuracy: 0.8000
Epoch 71/100
3/3 [===========] - 17s 5s/step - loss: 0.2283 - accuracy: 0.9517 - val_loss: 0.4454 - val_accuracy: 0.7333
Epoch 00071: early stopping

Jupyterの場合：

Epoch 1/100
4/3 [===========] - 28s 7s/step - loss: 1.5470 - accuracy: 0.5333 - val_loss: 0.7188 - val_accuracy: 0.4667
Epoch 2/100
4/3 [===========] - 17s 4s/step - loss: 0.6885 - accuracy: 0.5750 - val_loss: 0.7233 - val_accuracy: 0.5167
...
Epoch 16/100
4/3 [===========] - 18s 5s/step - loss: 0.3899 - accuracy: 0.8833 - val_loss: 1.0496 - val_accuracy: 0.5167
Epoch 17/100
4/3 [===========] - 18s 5s/step - loss: 0.4316 - accuracy: 0.8083 - val_loss: 0.7981 - val_accuracy: 0.5033
Epoch 18/100
4/3 [===========] - 17s 4s/step - loss: 0.4079 - accuracy: 0.8083 - val_loss: 1.3481 - val_accuracy: 0.5167
Epoch 00018: early stopping

このように特にJupyter上で深層学習を実行した際に、恐らく検証データについて学習が進んでいないのではという問題が生じております。
実際にテストデータを用いて実装モデルの実験を行ったのですが、Jupyterの場合、2クラスに分類したいにも関わらず、学習ができていないためか、一方のクラスにしか予測できないといった結果になりました。

使用しているJupyterの実行環境は、
Google Colaboratoryを動作させている同じCent OS7上で、Python3とJupyterをインストールしたものになっております。
その他の基本的な設定としましては、起動に当たっての最低限のもの以外は特に変更しておりません。

ここまで読んでいただきありがとうございます。
もし上記の問題について、原因や設定の改善点等、お気づきの方がいらっしゃいましたら、お手数おかけいたしますがアドバイス頂けると幸いです。
どうぞよろしくお願いいたします。

使用しているソースコード：（データの参照方法以外は、Google Colaboratory・Jupyter共に以下の同じコードを使用しております。）

import keras
from keras.layers import Dense, Dropout, InputLayer
from keras.optimizers import Adam
import glob
import argparse
from PIL import Image
import numpy as np
from keras.utils import np_utils
import os
import json
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import ModelCheckpoint
from keras.callbacks import EarlyStopping


#データのロード
 
import numpy as np
import glob 
from PIL import Image
from keras.utils import np_utils

def loaddata(datadir,phase,size,c):
    if phase == "train":
        traindir = datadir + "/train/*"
        valdir   = datadir + "/val/*"
        trainlists = glob.glob(traindir)
        vallists   = glob.glob(valdir)
        Xtrain = []
        Ytrain = []
        Xval   = []
        Yval   = []
        print(trainlists)
        
        for i, trainlist in enumerate(trainlists):
            picturelists = glob.glob(trainlist + "/*")
            for picturelist in picturelists:
                img = Image.open(picturelist)
                data = np.asarray(img)
                Xtrain.append(data)
                Ytrain.append(i)
        Xtrain = np.array(Xtrain)
        Ytrain = np.array(Ytrain)
        Xtrain = Xtrain.astype("float32")
        Xtrain = Xtrain / 255.0
        Ytrain = np_utils.to_categorical(Ytrain, len(trainlists))
        
        for i, vallist in enumerate(vallists):
            picturelists = glob.glob(vallist + "/*")
            for picturelist in picturelists:
                img = Image.open(picturelist)
                data = np.asarray(img)
                Xval.append(data)
                Yval.append(i)
        Xval = np.array(Xval)
        Yval = np.array(Yval)
        Xval = Xval.astype("float32")
        Xval = Xval / 255.0
        Yval = np_utils.to_categorical(Yval,len(vallists))
        return Xtrain, Ytrain, Xval, Yval 
    else:
        testdir = datadir + "/test/*"
        testlists = glob.glob(testdir)
        Xtest = []
        Ytest = []
        for i, testlist in enumerate(testlists):
            picturelists = glob.glob(testlist + "/*")
            for picturelist in picturelists:
                img = Image.open(picturelist)
                data = np.asarray(img)
                Xtest.append(data)
                Ytest.append(i)
        Xtest = np.array(Xtest)
        Ytest = np.array(Ytest)
        Xtest = Xtest.astype("float32")
        Xtest = Xtest / 255.0
        Ytest = np_utils.to_categorical(Ytest, len(testlists))
        return Xtest, Ytest


#lossとAccを描画する関数

import matplotlib.pyplot as plt

def plot_history_loss(fit, modelname):
    plt.plot(fit.history['loss'],label="loss for training")
    plt.plot(fit.history['val_loss'],label="loss for validation")
    plt.title('model loss')
    plt.xlabel('epoch')
    plt.ylabel('loss')
    plt.legend(loc='upper right')
    plt.grid(which="both")
    plt.close()

def plot_history_acc(fit, modelname):
    plt.plot(fit.history['acc'],label="accuracy for training")
    plt.plot(fit.history['val_acc'],label="accuracy for validation")
    plt.title('model accuracy')
    plt.xlabel('epoch')
    plt.ylabel('accuracy')
    plt.legend(loc='lower right')
    plt.grid(which="both")
    plt.close()


# モデルを定義する関数（今回はInceptionV3モデルを使用）

from keras.models import Sequential
from keras.layers.convolutional import Conv2D
from keras.layers.pooling import MaxPool2D
from keras.layers.core import Dense, Activation, Dropout, Flatten
from keras.layers import GlobalAveragePooling2D
from keras.applications import VGG16, InceptionV3
from keras import models

def modelInceptionV3(inputh, inputw, c, nb_classes):
    vgg = InceptionV3(weights="imagenet",include_top=False, 
                input_shape=(inputh, inputw, c))
    last = vgg.output
    model = GlobalAveragePooling2D()(last)
    #model = Flatten()(last)
    model = Dense(1024, activation="relu")(model)
    #model = Dropout(0.5)(model)
    preds = Dense(nb_classes, activation="softmax")(model)
    
    returnmodel = models.Model(vgg.input, preds)
    for layer in vgg.layers:
        layer.trainable = False
    #print(returnmodel.summary())
    return returnmodel


# main関数

if __name__ == '__main__':
    dirname = "face1"
    phase   = "train"
    picsize = 256
    chanel  = 3
    numcategory = 2
    epoch   = 100
    batch   = 32
    opt     = "Adam"
    name    = "train"
    rotation = 3
    width_shift = 0.01
    height_shift = 0.01

    if phase == "train":
        #os.mkdir("./"+name)
        Xtrain, Ytrain, Xval, Yval = loaddata(dirname, phase, picsize, chanel)
        early_stopping = EarlyStopping(monitor='val_loss', patience=10, verbose=1)
        datagen = ImageDataGenerator(rescale=1.0 / 255, rotation_range=rotation,
                                     width_shift_range=width_shift,
                                     height_shift_range=height_shift,
                                     horizontal_flip=True)
        test_datagen = ImageDataGenerator(rescale=1.0 / 255)
        datagen.fit(Xtrain)
        print(len(Xtrain))
        train_generator = datagen.flow_from_directory(dirname+'/train',
                                                      target_size=(picsize, picsize),
                                                      batch_size=batch,
                                                      class_mode='categorical',classes=['0', '1'], 
                                                      shuffle=True, color_mode='rgb')
        val_generator = test_datagen.flow_from_directory(dirname+'/val',
                                                      target_size=(picsize, picsize),
                                                      batch_size=batch,
                                                      class_mode='categorical',classes=['0', '1'],
                                                      shuffle=True, color_mode='rgb')
        model = modelInceptionV3(picsize, picsize, chanel, numcategory)
        model.compile(loss="categorical_crossentropy",
                      optimizer='adam',
                      metrics=['accuracy'])
        cp = ModelCheckpoint(filepath=name+"/weights{epoch:04d}.h5",
                             monitor='val_loss',
                             verbose=1,
                             save_best_only=True,
                             save_weights_only=True,
                             mode="min",
                             period=1)
        modelhistory = model.fit_generator(train_generator, steps_per_epoch=len(Xtrain)/batch, epochs=epoch, verbose=1, 
                                           validation_data=val_generator, validation_steps=len(Xval)/batch, callbacks=[early_stopping],)
        plot_history_loss(modelhistory, name)
        with open(name+"/history.json","w") as f:
            json.dump(modelhistory.history, f)
        model.save_weights('param.hdf5')
    else:
        Xtest, Ytest = loaddata(dirname, phase)
        print(Xtest[0])


# ~ モデルの学習後 〜
# モデルのテスト：

import glob
p = glob.glob(dirname + "/test/1/*.png")
#print(p)
cnt = 0
for i in p:
    img = Image.open(i)
    data = np.asarray(img)
    data = np.resize(data, (1, 256, 256, 3)).astype("float32")
    data = data / 255.0
    predictions = model.predict(data)
    #print(predictions)
    print(str(np.argmax(max(predictions)))+":"+str(max(max(predictions))))
    if np.argmax(max(predictions)) == 1:
        cnt += 1
print(str(cnt)+"/"+str(len(p)))

Comments

[toast-uz]

Pythonおよびインポートしている各種ライブラリのバージョンを確認しましょう。
Ptyhon3です、ではなく、3.xのxが重要です。各種ライブラリはできればマイナーバージョンまであわせてみましょう。さらに互換性を気にされるなら生kerasは使わない方が良いです。