Erstellen keras Rückruf speichern von modellvorhersagen und Ziele für jede charge während der Ausbildung

Ich bin eine einfache Sequentielle Modell in Keras (tensorflow backend). Während der Ausbildung möchte ich untersuchen Sie die individuellen Trainings-Chargen und modellvorhersagen. Also, ich bin versuchen, um eine benutzerdefinierte Callback das spart die modellvorhersagen und die Ziele für die einzelnen batch-training. Aber das Modell ist nicht mit der aktuellen charge, die für die Vorhersage, sondern die gesamten Trainingsdaten.

Wie kann ich die hand nur über das aktuelle Trainings-batch-der Callback?

Und wie kann ich den Zugriff auf die Chargen und die Ziele, die Callback speichert in sich selbst.predhis und selbst.Ziele?

Meine aktuelle version sieht wie folgt aus:

callback_list = [prediction_history((self.x_train, self.y_train))]

self.model.fit(self.x_train, self.y_train, batch_size=self.batch_size, epochs=self.n_epochs, validation_data=(self.x_val, self.y_val), callbacks=callback_list)

class prediction_history(keras.callbacks.Callback):
    def __init__(self, train_data):
        self.train_data = train_data
        self.predhis = []
        self.targets = []

    def on_batch_end(self, epoch, logs={}):
        x_train, y_train = self.train_data
        self.targets.append(y_train)
        prediction = self.model.predict(x_train)
        self.predhis.append(prediction)
        tf.logging.info("Prediction shape: {}".format(prediction.shape))
        tf.logging.info("Targets shape: {}".format(y_train.shape))

InformationsquelleAutor Lemon | 2017-11-02

19

HINWEIS: die ursprüngliche akzeptierte Antwort war falsch, wie darauf hingewiesen wird in dem Kommentar. Da es akzeptiert und nicht gelöscht werden kann, habe ich umgeschrieben es eine gute Antwort.

Nach der Modell-Zusammenstellung, die den Platzhalter tensor für y_true ist in model.targets und y_pred ist in model.outputs.

Speichern die Werte dieser Platzhalter bei jeder charge können Sie:
1. Zunächst kopieren Sie die Werte dieser Tensoren in Variablen.
2. Bewerten diese Variablen in on_batch_end, und speichern des resultierenden arrays.
Nun Schritt 1 ist ein bisschen betroffen, denn Sie müssen zum hinzufügen einer tf.assign op, um die Trainings-Funktion model.train_function. Mit aktuellen Keras API, diese kann getan werden, indem eine fetches argument K.function() wenn die Trainings-Funktion aufgebaut ist.

In model._make_train_function() gibt es eine Zeile:
```
self.train_function = K.function(inputs,
                                 [self.total_loss] + self.metrics_tensors,
                                 updates=updates,
                                 name='train_function',
                                 **self._function_kwargs)
```
Den fetches argument mit den tf.assign ops kann durch model._function_kwargs (funktioniert nur nach Keras 2.1.0).

Als Beispiel:
```
from keras.callbacks import Callback
from keras import backend as K
import tensorflow as tf

class CollectOutputAndTarget(Callback):
    def __init__(self):
        super(CollectOutputAndTarget, self).__init__()
        self.targets = []  # collect y_true batches
        self.outputs = []  # collect y_pred batches

        # the shape of these 2 variables will change according to batch shape
        # to handle the "last batch", specify `validate_shape=False`
        self.var_y_true = tf.Variable(0., validate_shape=False)
        self.var_y_pred = tf.Variable(0., validate_shape=False)

    def on_batch_end(self, batch, logs=None):
        # evaluate the variables and save them into lists
        self.targets.append(K.eval(self.var_y_true))
        self.outputs.append(K.eval(self.var_y_pred))

# build a simple model
# have to compile first for model.targets and model.outputs to be prepared
model = Sequential([Dense(5, input_shape=(10,))])
model.compile(loss='mse', optimizer='adam')

# initialize the variables and the `tf.assign` ops
cbk = CollectOutputAndTarget()
fetches = [tf.assign(cbk.var_y_true, model.targets[0], validate_shape=False),
           tf.assign(cbk.var_y_pred, model.outputs[0], validate_shape=False)]
model._function_kwargs = {'fetches': fetches}  # use `model._function_kwargs` if using `Model` instead of `Sequential`

# fit the model and check results
X = np.random.rand(10, 10)
Y = np.random.rand(10, 5)
model.fit(X, Y, batch_size=8, callbacks=[cbk])
```
Sofern die Anzahl der samples dividiert durch die Losgröße, die Letzte charge wird eine andere Größe als die anderen Chargen. So K.variable() und K.update() können nicht verwendet werden, in diesem Fall. Du wirst tf.Variable(..., validate_shape=False) und tf.assign(..., validate_shape=False) statt.

Überprüfen Sie die Richtigkeit der gespeicherten arrays, können Sie fügen Sie eine Zeile in training.py drucken aus dem gemischten index array:
```
if shuffle == 'batch':
    index_array = _batch_shuffle(index_array, batch_size)
elif shuffle:
    np.random.shuffle(index_array)

print('Index array:', repr(index_array))  # Add this line

batches = _make_batches(num_train_samples, batch_size)
```
Dem gemischten index-array ausgedruckt werden soll, während der Montage:
```
Epoche 1/1 
Index array: array([8, 9, 3, 5, 4, 7, 1, 0, 6, 2]) 
10/10 [==============================] - 0s 23ms/Schritt - Verlust: 0.5670 
```
Und Sie können überprüfen, ob cbk.targets ist das gleiche wie Y[index_array]:
```
index_array = np.array([8, 9, 3, 5, 4, 7, 1, 0, 6, 2])
print(Y[index_array])
[[ 0.75325592  0.64857277  0.1926653   0.7642865   0.38901153]
 [ 0.77567689  0.13573623  0.4902501   0.42897559  0.55825652]
 [ 0.33760938  0.68195038  0.12303088  0.83509441  0.20991668]
 [ 0.98367778  0.61325065  0.28973401  0.28734073  0.93399794]
 [ 0.26097574  0.88219054  0.87951941  0.64887846  0.41996446]
 [ 0.97794604  0.91307569  0.93816428  0.2125808   0.94381495]
 [ 0.74813435  0.08036688  0.38094272  0.83178364  0.16713736]
 [ 0.52609421  0.39218962  0.21022047  0.58569125  0.08012982]
 [ 0.61276627  0.20679494  0.24124858  0.01262245  0.0994412 ]
 [ 0.6026137   0.25620512  0.7398164   0.52558182  0.09955769]]

print(cbk.targets)
[array([[ 0.7532559 ,  0.64857274,  0.19266529,  0.76428652,  0.38901153],
        [ 0.77567691,  0.13573623,  0.49025011,  0.42897558,  0.55825651],
        [ 0.33760938,  0.68195039,  0.12303089,  0.83509439,  0.20991668],
        [ 0.9836778 ,  0.61325067,  0.28973401,  0.28734073,  0.93399793],
        [ 0.26097575,  0.88219053,  0.8795194 ,  0.64887846,  0.41996446],
        [ 0.97794604,  0.91307569,  0.93816429,  0.2125808 ,  0.94381493],
        [ 0.74813437,  0.08036689,  0.38094273,  0.83178365,  0.16713737],
        [ 0.5260942 ,  0.39218962,  0.21022047,  0.58569127,  0.08012982]], dtype=float32),
 array([[ 0.61276627,  0.20679495,  0.24124858,  0.01262245,  0.0994412 ],
        [ 0.60261369,  0.25620511,  0.73981643,  0.52558184,  0.09955769]], dtype=float32)]
```
Wie Sie sehen können, gibt es zwei Chargen in cbk.targets (ein "full charge" Größe 8 und die Letzte charge von Größe 2), und die Reihenfolge ist die gleiche wie Y[index_array].
- Aber sind das wirklich die Ziele und die Ausbildung der Chargen, die intern verwendet werden, die während der Ausbildung? Wenn Sie es wie diese, die y_train charge hat die Form (20,). Allerdings, wenn Sie die model.fit() Funktion von Keras und suchen im inneren einige Metrik wie Genauigkeit, y_true Form (TensorShape([Dimension(None), Dimension(None)])
- Sie vergleichen zwei verschiedene Dinge. y_train ist ein numpy-array, aber y_true ist ein TF-Platzhalter. Der Wert der numpy-array zugeführt wird y_true während passende Modell.
- Aber wenn y_train eingespeist wird in die Platzhalter, deren Maße sollten Stimmen
- Sie werden. Du bist wahrscheinlich die Prüfung in einem falschen Weg. Siehe mein edit nach einem Weg, um zu testen, ob die Werte gleich sind.
- Sie haben vollkommen Recht. Da die Antwort nicht gelöscht werden kann, habe ich neu geschrieben die Antworten bieten einen anderen Weg, es zu tun.
- Sorry für die schlechte Antwort. Bitte sehen, wenn die neue Antwort funktioniert.
- Funktioniert diese Lösung funktioniert mit fit_generator? Und, um Zugang zu Validierung von Daten in benutzerdefinierten callback?
- Ja, Sie sind im Grunde die gleichen. Die Validierung von Daten ist nur self.validation_data im Rückrufe.
- Ist es möglich, auch Informationen über die Eingänge?
- ist es möglich, den Zugriff auf die gesamte inputs und outputs zimmerreserviereung, ohne das Sie angeben, z.B. outputs[0]. So etwas wie tf.assign(cbk.outputs, model.outputs, validate_shape=False) ?
- Ich bin mir nicht bewusst ein. Vielleicht eine for-Schleife kann verwendet werden, um den Aufbau der fetches Liste und die tf.Variables zu reduzieren doppelten code?
- Diese Methode scheint nicht zu funktionieren nach dem laden eines ModelCheckpoint. K.eval(self.var_y_pred) und K.eval(self.var_y_true) bewertet von 0.0. Irgendwelche Ideen?
- Für diejenigen, die laufen in das gleiche problem wie mein Kommentar oben, die Sie festlegen möchten model.train_function = None nach dem laden des Modells, und nach der Einstellung model._function_kwargs = {'fetches': fetches}, aber vor model.fit(), weil model._function_kwargs Werte werden nicht gespeichert, in den checkpoint. model.fit() "lädt" diese, wenn model.train_function = None. Für mehr details, schauen Sie sich die _make_train_function Funktion in training.py
- Auch model.train_function = None im compile Methode der class Model im training.py unten handle_metrics im keras/keras/engine/training.py. Also, Einstellung-Methode model.train_function=None , nach dem kompilieren, ändert sich nichts.
- Ich habe versucht, diese Lösung; allerdings habe ich ein problem in der Fütterung der Werte " c_api.TF_GetCode(selbst.status.status)) tensorflow.python.Rahmen.errors_impl.InvalidArgumentError: Sie müssen Futter ein Wert für den Platzhalter tensor 'dense_1_target' mit dtype float und Form [?,?] [[{{node dense_1_target}}]]". Meine Letzte Schicht ist softmax und ich bin mit der Passform nicht fit_generator, keine Ahnung ?
InformationsquelleAutor Yu-Yang

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.