Как измерить время до решения в повторных испытаниях с Keras + Tensorflow

Question

Обучение Tensorflow имеет начальную стоимость, которая амортизируется при повторных испытаниях. Я хочу измерить время на обучение модели проблемы (XOR) без этой стоимости запуска, и я хочу провести много испытаний. Каждое испытание должно начинаться с новых начальных условий, в противном случае оно просто находит одно и то же решение повторно.

Я думаю, что мне нужно сбрасывать веса для каждого испытания и использовать обратный вызов EarlyStopping, чтобы обучение прекратилось, когда решение больше не может быть улучшено. Затем я сообщаю об истекшем времени и потере.

import keras
import numpy
import math
import sys
from keras.initializers import glorot_uniform
import keras.backend as K

if len(sys.argv) < 2:
  print('tell me how many samples to generate')
  sys.exit(-1)

numSamples = int(sys.argv[1])


learningRate = 0.1

model = keras.models.Sequential()
model.add(keras.layers.Dense(2, activation='sigmoid', input_dim=2))
model.add(keras.layers.Dense(1, activation='sigmoid'))
model.compile(loss=keras.losses.binary_crossentropy, optimizer=keras.optimizers.Adam(lr=learningRate), metrics=['accuracy'])

initial_weights = model.get_weights()

backend_name = K.backend()
if backend_name == 'tensorflow': 
    k_eval = lambda placeholder: placeholder.eval(session=K.get_session())
elif backend_name == 'theano': 
    k_eval = lambda placeholder: placeholder.eval()
else: 
    raise ValueError("Unsupported backend")


X = [ [ 0, 0 ], [ 0, 1 ], [ 1, 0 ], [ 1, 1 ] ]
Y = [ [ 1 ], [ 0 ], [ 0 ], [ 1 ] ]

XX = numpy.array(X)
YY = numpy.array(Y)

lastModel = None

earlyStopping = keras.callbacks.EarlyStopping(monitor='loss', min_delta=0, patience=10, verbose=1)

from timeit import default_timer as timer

for i in range(numSamples):
  new_weights = [k_eval(glorot_uniform()(w.shape)) for w in initial_weights]
  model.set_weights(new_weights)

  start = timer()

  model.fit(XX, YY, verbose=0, epochs=1000000, callbacks=[earlyStopping], validation_data=(XX, YY))

  end = timer()
  elapsed = end - start
  print("Elapsed seconds to fit new solution:", elapsed)

  score = model.evaluate(XX, YY, verbose=0)
  print()
  print('loss', score)

  layer0 = model.layers[0].get_weights()
  layer1 = model.layers[1].get_weights()

  weight0 = layer0[0]
  bias0 = layer0[1]
  w1 = weight0[0][0]
  w2 = weight0[0][1]
  w3 = weight0[1][0]
  w4 = weight0[1][1]
  b1 = bias0[0]
  b2 = bias0[1]

  weight1 = layer1[0]
  bias1 = layer1[1]
  w5 = weight1[0][0]
  w6 = weight1[1][0]
  b3 = bias1[0]

  w = [w1, w2, w3, w4, w5, w6, b1, b2, b3]
  print(w)

  if lastModel is not None:
    sum = 0
    for i in range(len(w)):
      sum = sum + (w[i] - lastModel[i]) * (w[i] - lastModel[i])
    rms = math.sqrt(sum) / len(w)
    print("rms from last solution = ", rms)
  lastModel = w
  for i in range(len(X)):
    z01 = X[i][0] * w1 + X[i][1] * w3 + b1
    z11 = X[i][0] * w2 + X[i][1] * w4 + b2
    a01 = 1.0 / (1.0 + math.exp(-z01))
    a11 = 1.0 / (1.0 + math.exp(-z11))

    z2 = a01 * w5 + a11 * w6 + b3
    yHat = 1.0 / (1.0 + math.exp(-z2))
    print(X[i], Y[i], yHat)

Я удивлен, что некоторые времена в нескольких секундах, в то время как другие в долях секунды. Я бы не ожидал, что XOR потребуется несколько секунд для тренировки. Кто-нибудь видит что-то не так с этой программой или методологией?