Некоторые аспекты качества обучающих последовательностей

 На Хабре появился ряд статей о качестве образования и как процесса и как результата (уровень выпускников).

Тема заинтересовала и руки зачесались проверить, а как это устроено у пчелок роботов искусственного интеллекта, влияет ли качество обучающей последовательности на результат.

Была выбрана простая сеть из примеров keras  в которую добавил одну строку. Нас интересует насколько упорядоченность входной обучающей последовательности mnist влияет на результат обучения MLP.

Результат получился неожиданным и странным, пришлось перепроверять многократно, но перейдем к делу и конкретике.

Идея эксперимента проста и обычна — обучаем MLP из keras на общедоступном mnist и получаем ориентир, после обучаем на последовательностях 01234567890123..7890123. Как студентов учат — немного бейсик, немного ассемблер, немного fortran, и т.д. и сравним с исходным обучением. Результат вполне ожидаем, исходная последовательность учит лучше, но порядок такой же. Вот график 64 испытаний

А теперь будем учить сеть так, подаем все картинки с «0», потом все «1», потом все «2» и так до «9» и результат получается никакой!, сеть просто не учится. Интуитивно ожидаешь результат сопоставимый, хуже или лучше — это уже детали, но вот таблица одного из результатов обучения 

('Test accuracy:', 0.97240000000000004)
('Test accuracy:', 0.96809999999999996)
('Test accuracy:', 0.1135)

Первая строка оригинальый mnist, вторая строка mnist упорядоченный вот так 01234567890123..7890123, а третья строка это mnist упорядоченный так 0..01..12..23..34..45..56..67..78..89..9

Не знаю как у людей, но тут чисто только и получается, что обучать MLP можно не абы как, не на всех последовательностях.

Обучать ИИ так, как обучают в некоторых местах: сначала только бейсик, потом только фортран, потом только ассемблер и т.д. не приведет к успеху. / :-) / Если выявленная особенность присуща всем процессам обучения, как людям так и роботам, то все программы вузов нужно тщательно исследовать.

from keras import backend as K_B
from keras.datasets import mnist
from keras.layers import Input, Dense, Dropout
from keras.models import Sequential
from keras.optimizers import RMSprop
from keras.utils import np_utils
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

def MLP(ind): 

    model = Sequential()
    model.add(Dense(512, activation='relu', input_shape=(width * height,)))
    model.add(Dropout(0.2))
    model.add(Dense(512, activation='relu'))
    model.add(Dropout(0.2))
    model.add(Dense(num_classes, activation='softmax'))

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

    if (ind == 0):  # начальные веса в каждой тройке испытаний должны быть одинаковыми
        model.save_weights('weights.h5') # натив, сохраняем веса
    else:
        model.load_weights('weights.h5', by_name = False) # эксперимент, восстанавливаем веса

    history = model.fit(X_train, Y_train,
                        shuffle = False,     # добавлена эта строка что бы запретить keras перемешивать батч
                        batch_size=batch_size,
                        epochs=epochs,
                        verbose=0,
                        validation_data=(X_test, Y_test))
    score = model.evaluate(X_test, Y_test, verbose=0)
    print('Test accuracy:', score[1])
    K_B.clear_session() 
# сессию уничтожаем и возрождаем, что бы начальные веса отличались 

    return(score[1])

batch_size = 12
epochs = 12
hidden_size = 512

(X_train, y_train), (X_test, y_test) = mnist.load_data()

num_train, width, height = X_train.shape
num_test = X_test.shape[0]
num_classes = np.unique(y_train).shape[0]

X_train = X_train.astype('float32') 
X_test = X_test.astype('float32')
X_train /= 255.
X_test /= 255.
X_train = X_train.reshape(num_train, height * width)
X_test = X_test.reshape(num_test, height * width)

XX_train = np.copy(X_train)
yy_train = np.copy(y_train)

Y_train = np_utils.to_categorical(y_train, num_classes)
Y_test = np_utils.to_categorical(y_test, num_classes)

steps = 64
st = np.arange(steps, dtype='int')
res_N = np.arange((steps), dtype='float')
res_1 = np.arange((steps), dtype='float')
res_2 = np.arange((steps), dtype='float')

for n in xrange(steps):    
# __  натив

    X_train = np.copy(XX_train)
    y_train = np.copy(yy_train)
    Y_train = np_utils.to_categorical(y_train, num_classes)
    print ' step ', n
    res_N[n] = MLP(0)

# __ 00..0011..1122..2233.. .. 8899..99
    perm = np.arange(num_train, dtype='int')
    cl = np.zeros(num_classes, dtype='int')

    for k in xrange(num_train):
        if (cl[yy_train[k]] * num_classes + yy_train[k] < num_train):
            perm[ cl[yy_train[k]] * num_classes + yy_train[k] ] = k
            cl[yy_train[k]] += 1

    for k in xrange(num_train):
        X_train[k,...] = XX_train[perm[k],...]
    for k in xrange(num_train):
        y_train[k] = yy_train[perm[k]]
    Y_train = np_utils.to_categorical(y_train, num_classes)
    res_2[n] = MLP(2)
# __ 0123..78901..7890123..789
    perm = np.arange(num_train, dtype='int')
    j = 0
    for k in xrange(num_classes):
        for i in xrange(num_train):
            if (yy_train[i] == k):
                perm[j] = i
                j += 1
    for k in xrange(num_train):
        X_train[k,...] = XX_train[perm[k],...]
        y_train[k] = yy_train[perm[k]]
    Y_train = np_utils.to_categorical(y_train, num_classes) 
    res_1[n] = MLP(1)

Другие типы сетей не проверял и эта проверка занимает на моей не очень теслистой тесле много часов.