model.fit(steps_per_epoch), mnist_tfrecord.py, progbar np.mean #7113

ahundt · 2017-06-24T04:10:02Z

Implements external loss based support for model.fit(steps_per_epoch) with tensor input and a corresponding tfrecord example.

# API 2

model = # on top of the tensor input
model.add_loss()  # involving y_tensor

model.fit(epochs=10, steps_per_epoch=1000)

Runtime results when running mnist_tfrecord.py from python tf tensors:

Test accuracy: 0.990999997973
python mnist_tfrecord.py  57.21s

The progbar change is needed for mnist_tfrecord.py where a step is a batch.

…#6928, keras-team#7046)

fchollet · 2017-06-24T23:26:42Z

keras/engine/training.py

-        if ins and hasattr(ins[0], 'shape'):
-            num_train_samples = ins[0].shape[0]
+        if steps_per_epoch is not None:
+            num_train_samples = steps_per_epoch


num_train_samples != steps_per_epoch, though. A step is a batch, not a single sample.

Ah yes forgot to divide but batch size. I'll do that when I'm at a computer

fchollet · 2017-06-25T17:32:17Z

I think what we should do is:

if the number of samples can be recovered from the data, use that. If steps_per_epoch is set, raise a warning that it's ignored. If batch_size is not set, raise a ValueError.
if it can't be recovered, raise a ValueError in case steps_per_epoch is not set. If batch_size is set, raise a warning that it's ignored.

There are serious issues with blending both step-based counting and sample-based counting (the last batch, variable batch sizes, etc). So we can't mix them without complications.

ahundt · 2017-06-26T19:29:56Z

if the number of samples can be recovered from the data, use that. If steps_per_epoch is set, raise a warning that it's ignored. If batch_size is not set, raise a ValueError.

I agree with your suggestion. I just made a small tweak since the steps_per_epoch default is None and this is a new parameter. I provide the warning you suggest but otherwise I assume the user meant to override defaults when they provide steps_per_epoch. I also added it to the other relevant functions.

ahundt · 2017-06-26T22:07:16Z

Seems it is necessary to allow both to be specified because batch_size is not ignored, it is used in some of the totals and other calculations so I'm not sure the warning is appropriate without more substantial internal changes. Example error:

___________________________ test_model_with_input_feed_tensor ___________________________
[gw0] darwin -- Python 2.7.13 /usr/local/opt/python/bin/python2.7
@pytest.mark.skipif(K.backend() != 'tensorflow', reason='Requires TF backend')
    @keras_test
    def test_model_with_input_feed_tensor():
        """We test building a model with a TF variable as input.
        We should be able to call fit, evaluate, predict,
        by only passing them data for the placeholder inputs
        in the model.
        """
        import tensorflow as tf

        input_a_np = np.random.random((10, 3))
        input_b_np = np.random.random((10, 3))

        output_a_np = np.random.random((10, 4))
        output_b_np = np.random.random((10, 3))

        a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
        b = Input(shape=(3,), name='input_b')

        a_2 = Dense(4, name='dense_1')(a)
        dp = Dropout(0.5, name='dropout')
        b_2 = dp(b)

        model = Model([a, b], [a_2, b_2])
        model.summary()

        optimizer = 'rmsprop'
        loss = 'mse'
        loss_weights = [1., 0.5]
        model.compile(optimizer, loss, metrics=['mean_squared_error'],
                      loss_weights=loss_weights,
                      sample_weight_mode=None)

        # test train_on_batch
        out = model.train_on_batch(input_b_np,
                                   [output_a_np, output_b_np])
        out = model.train_on_batch({'input_b': input_b_np},
                                   [output_a_np, output_b_np])
        out = model.test_on_batch({'input_b': input_b_np},
                                  [output_a_np, output_b_np])
        out = model.predict_on_batch({'input_b': input_b_np})

        # test fit
        out = model.fit({'input_b': input_b_np},
                        [output_a_np, output_b_np], epochs=1, batch_size=10)
        out = model.fit(input_b_np,
                        [output_a_np, output_b_np], epochs=1, batch_size=10)

        # test evaluate
        out = model.evaluate({'input_b': input_b_np},
                             [output_a_np, output_b_np], batch_size=10)
        out = model.evaluate(input_b_np,
                             [output_a_np, output_b_np], batch_size=10)

        # test predict
        out = model.predict({'input_b': input_b_np}, batch_size=10)
        out = model.predict(input_b_np, batch_size=10)
        assert len(out) == 2

        # Now test a model with a single input
        # i.e. we don't pass any data to fit the model.
        a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
        a_2 = Dense(4, name='dense_1')(a)
        a_2 = Dropout(0.5, name='dropout')(a_2)
        model = Model(a, a_2)
        model.summary()

        optimizer = 'rmsprop'
        loss = 'mse'
        model.compile(optimizer, loss, metrics=['mean_squared_error'])

        # test train_on_batch
        out = model.train_on_batch(None,
                                   output_a_np)
        out = model.train_on_batch(None,
                                   output_a_np)
        out = model.test_on_batch(None,
                                  output_a_np)
        out = model.predict_on_batch(None)
        out = model.train_on_batch([],
                                   output_a_np)
        out = model.train_on_batch({},
                                   output_a_np)

        # test fit
        out = model.fit(None,
                        output_a_np, epochs=1, batch_size=10)
        out = model.fit(None,
                        output_a_np, epochs=1, batch_size=10)

        # test evaluate
        out = model.evaluate(None,
                             output_a_np, batch_size=10)
        out = model.evaluate(None,
                             output_a_np, batch_size=10)

        # test predict
>       out = model.predict(None, batch_size=None, steps=1)

tests/keras/engine/test_training.py:519:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
keras/engine/training.py:1518: in predict
    verbose=verbose, steps=steps)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <keras.engine.training.Model object at 0x112d30f90>
f = <keras.backend.tensorflow_backend.Function object at 0x11306cd90>
ins = [0.0], batch_size = None, verbose = 0, steps = 1

    def _predict_loop(self, f, ins, batch_size=32, verbose=0, steps=None):
        """Abstract method to loop over some data in batches.

            # Arguments
                f: Keras function returning a list of tensors.
                ins: list of tensors to be fed to `f`.
                batch_size: integer batch size.
                verbose: verbosity mode.
                steps: Total number of steps (batches of samples)
                    before declaring _predict_loop finished.
                    Ignored with the default value of `None`.

            # Returns
                Array of predictions (if the model has a single output)
                or list of arrays of predictions
                (if the model has multiple outputs).
            """
        samples = self._check_num_samples(ins, batch_size, steps, 'steps')
        outs = []
        if verbose == 1:
            progbar = Progbar(target=samples)
        batches = _make_batches(samples, batch_size)
        index_array = np.arange(samples)
        for batch_index, (batch_start, batch_end) in enumerate(batches):
            batch_ids = index_array[batch_start:batch_end]
            if ins and isinstance(ins[-1], float):
                # Do not slice the training phase flag.
                ins_batch = _slice_arrays(ins[:-1], batch_ids) + [ins[-1]]
            else:
                ins_batch = _slice_arrays(ins, batch_ids)

            batch_outs = f(ins_batch)
            if not isinstance(batch_outs, list):
                batch_outs = [batch_outs]
            if batch_index == 0:
                for batch_out in batch_outs:
                    shape = (samples,) + batch_out.shape[1:]
                    outs.append(np.zeros(shape, dtype=batch_out.dtype))

            for i, batch_out in enumerate(batch_outs):
>               outs[i][batch_start:batch_end] = batch_out
E               ValueError: could not broadcast input array from shape (10,4) into shape (1,4)

fchollet · 2017-06-29T17:27:10Z

keras/engine/training.py

@@ -962,10 +962,21 @@ def _make_predict_function(self):
                                               name='predict_function',
                                               **kwargs)

+    def _check_num_samples(self, ins, batch_size=None, steps=None, steps_name='steps'):
+        if steps is not None:
+            num_samples = steps


That should be, on average, step * batch_size, not steps. However, since the data length may not be a multiple of batch_size, and because in the generator case there may be batches of different sizes, it is actually impossible to determine num_samples.

Perhaps something should be renamed in this case or documentation modified a bit for everything to be consistent?

Also, I wasn't sure if you're saying I should make it step*batch_size here or if you're saying that's also inaccurate and we need to do something else.

We need to separate two use cases cleanly:

training for a specific number of steps (if the data has no length), like in fit_generator.

training for a specific number of samples (if the data has a length), like in current fit.

We can't unify both because no reliable conversion exists between the two.

Would the best approach then be the creation of a second code path in fit() that works more like fit_generator()? Perhaps it would be best to create a new function like fit_tensor()?

Good question. Can we make the expanded API work with fit without refactoring or adding new methods?

It should be pretty simple to do with the same methods just by checking if either x or y is a Keras tensor in fit(x, y, ...), so long as steps_per_epoch and epochs from fit_generator() are added to fit(x, y, ..., steps_per_epoch=None, epochs=None).

Unless you have another suggestion, I propose checking for Keras tensors because it is the simplest mechanism by which multiple platforms, not just TF, could eventually support the API. This means wrapping TF tensors with Input(), as in #6928 or see the more atomic PR merge order outlined in #7072 (comment).

…s_per_epoch * commit '01e2148732e4083b4850345e5ce4dd499cb5999e': (98 commits) Fix common backend styles (keras-team#7476) Allow dynamic shape for repeat_elements (keras-team#7422) Fix test style (keras-team#7473) Crossentropy backend API consistency cleanup (keras-team#7199) Replace the reserved word `input` with `inputs` (keras-team#7474) Increase test coverage (keras-team#7264) Fix l2_normalize Add default value for `l2_normalize`. Remove legacy axis handling in TF backend. Update save_model function (keras-team#7455) Switch to pydot 1.2.x (keras-team#7448) Add save, evaluate and predict functionality for example (keras-team#7430) Docs fix: `pointwise` instead of `depthwise` for SeparableConv2D (keras-team#7444) Fix conv reccurent test Style fix in conv recurrent tests. Support return_state parameter in ConvRecurrent2D (keras-team#7407) Small simplification in ResNet50 architecture Update FAQ with info about custom object loading. add example for passing in custom objects in load_model (keras-team#7420) Update applications.md (keras-team#7428) ...

…it_loop

* mnist_tfrecord: mnist_tfrecord.py loss defaults to None in compile() lower batch size and epochs mnist_tfrecord.py indentation fix mnist_tfrecord.py add parallelism option mnist_tfrecord.py pep8 Fix mnist_tfrecord.py runtime errors mnist_tfrecord.py added (keras-team#7061, keras-team#7072, keras-team#6928, keras-team#7046)

…ror messages (keras-team#7113)

ahundt · 2017-08-08T02:03:33Z

Large batch sizes can run much in less wall clock time and still get better performance. For example batch_size=600, steps_per_epoch=300, epochs=6 ran in 30% less time and predicted 0.1% more accurately. Not really relevant to this PR so I just set it to approximately match mnist_cnn.py.

ahundt · 2017-08-08T07:18:32Z

@fchollet hopefully everything should be addressed now

* fit_steps_per_epoch: training.py fix unit test error for steps_per_epoch mnist_tfrecord.py and training.py fixed review comments, docs, and error messages (keras-team#7113) training.py fix test error mnist_tfrecord.py extended description mnist_tfrecord.py and training.py clean up based on review (keras-team#7113) # Conflicts: # examples/mnist_tfrecord.py

TimZaman · 2017-08-08T09:08:33Z

keras/engine/training.py

-                              initial_epoch=initial_epoch)
+                              initial_epoch=initial_epoch,
+                              steps_per_epoch=steps_per_epoch,
+                              validation_steps=validation_steps)

    def evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None):


Do you want to add the tensor-input support for evaluate immediately as well, or do that in another PR?

Good point. Let's add data tensor support to evaluate and predict in this CL.

I'd prefer to hold off and get these changes in. We can cherry pick changes from #6928 in a separate PR for that if you think it is a good idea.

Ah the most recent post didn't load, also I had changed my mind as well and added evaluate since it was only a couple lines. I'll look at predict too.

TimZaman · 2017-08-08T09:08:56Z

keras/engine/training.py

@@ -1513,8 +1611,8 @@ def predict(self, x, batch_size=32, verbose=0):
            ins = x
        self._make_predict_function()
        f = self.predict_function
-        return self._predict_loop(f, ins,
-                                  batch_size=batch_size, verbose=verbose)
+        return self._predict_loop(f, ins, batch_size=batch_size,


leave as-is?

TimZaman · 2017-08-08T09:36:58Z

tests/keras/engine/test_training.py

@@ -734,7 +739,7 @@ def test_model_with_external_loss():
        out = model.predict_on_batch(None)

        # test fit
-        out = model.fit(None, None, epochs=1, batch_size=10)
+        out = model.fit(None, None, epochs=1, batch_size=None, steps_per_epoch=1)


I verified. Looks great!

TimZaman · 2017-08-08T09:37:21Z

LGTM

Dref360 · 2017-08-08T12:55:39Z

keras/engine/training.py

@@ -1154,58 +1222,70 @@ def _predict_loop(self, f, ins, batch_size=32, verbose=0):
            return outs[0]
        return outs

-    def _test_loop(self, f, ins, batch_size=32, verbose=0):
+    def _test_loop(self, f, ins, batch_size=None, verbose=0, steps=None):
        """Abstract method to loop over some data in batches.

        # Arguments
            f: Keras function returning a list of tensors.
            ins: list of tensors to be fed to `f`.
            batch_size: integer batch size.


Dref360 · 2017-08-08T13:09:51Z

keras/engine/training.py

+                    for l, o in zip(out_labels, val_outs):
+                        epoch_logs['val_' + l] = o
+            else:
+                if shuffle == 'batch':


Maybe add a warning that if steps_per_epoch is not None, shuffle=True has no effect. (no test required since pytest is flaky when it catches warning)

adding a comment to the docs, I'd rather not see that warning all the time by default

…s-team#7113)

fchollet · 2017-08-08T19:30:58Z

tests/keras/engine/test_training.py

-                    epochs=1, batch_size=4, validation_split=0.5)
+                    epochs=1, batch_size=None, validation_split=0.5,
+                    steps_per_epoch=1)
+    out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},


predict and evaluate with data tensors should have unit tests as well.

see #7113 (comment)

fchollet · 2017-08-08T19:32:31Z

examples/mnist_tfrecord.py

+test_model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
+test_model.summary()
+
+loss, acc = test_model.evaluate(x_test, np_utils.to_categorical(y_test), classes)


Could we use evaluate with a data tensor in this example?

I just realized we've started along the path to reimplementing #6928, and would require changes that separate numpy arrays from tensors. That PR allows the labels y to be passed as a tensor. For that reason I think we should revert support for evaluate(steps) and predict(steps), fix the docstring issues, and limit this PR to fit().

Full support can be integrated with what we called API 3 via #6928.

We already have support for evaluate from data tensors. https://github.com/fchollet/keras/blob/master/tests/keras/engine/test_training.py#L740

(i.e. all we need is add steps to these methods)

The simplicity of the test hides the lack of underlying implementation.

In this test there is no label y to evaluate against. You'll see in the _test_loop() the output of f(ins) is not saved in the steps case, which is ok for this PR as it was originally conceived.

This seemingly simple missing component actually requires some implementation to work. I'm not sure if supplying a Tensor as the parameter y will give results in the format described by #Returns. Perhaps simply retaining a list of the outputs is OK like in _step_loop()? (the link is to the #6928 version of the changes I reverted here)

I'm not sure about indexing correctly to calculate the summaries for each output in this case, e.g. something equivalent to outs[i][batch_start:batch_end] = batch_out in _predict_loop() or in _test_loop there is outs[i] += batch_out * len(batch_ids) and then outs[i] /= samples.

ahundt · 2017-08-08T20:58:30Z

I merged the changes to predict(steps) and evaluate(steps) into #6928 and reverted them here.
That's because such a change will require adding support for an input tensor as a label, a change that is in the scope of #6928 and out of scope for this PR.

fchollet · 2017-08-08T21:00:14Z

I think it's preferable to have them here for API consistency. Like in fit, it just requires your model to be compiled with a None loss (and a call to add_loss before compilation).

ahundt

Discussing the requirements of predict(steps) and evaluate(steps) below. Perhaps I misunderstood and the accuracy is calculated somewhere in the mnist_tfrecord.py call to fit()?

I believe only loss is calculated and no accuracy data is available.

ahundt · 2017-08-08T21:07:45Z

keras/engine/training.py

+            if verbose == 1:
+                progbar = Progbar(target=steps)
+            for step_num in range(steps):
+                f(ins)


Nothing is saved out in this case. Can the results be collated in a predictable manner? I'm not yet sure if the answer may depend on the input tensor the user supplies, such as RecordInput vs tf.train.shuffle_batch.

ahundt · 2017-08-08T21:19:58Z

examples/mnist_tfrecord.py

+test_model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
+test_model.summary()
+
+loss, acc = test_model.evaluate(x_test, np_utils.to_categorical(y_test), classes)


The simplicity of the test hides the lack of underlying implementation.

In this test there is no label y to evaluate against. You'll see in the _test_loop() the output of f(ins) is not saved in the steps case, which is ok for this PR as it was originally conceived.

This seemingly simple missing component actually requires some implementation to work. I'm not sure if supplying a Tensor as the parameter y will give results in the format described by #Returns. Perhaps simply retaining a list of the outputs is OK like in _step_loop()? (the link is to the #6928 version of the changes I reverted here)

I'm not sure about indexing correctly to calculate the summaries for each output in this case, e.g. something equivalent to outs[i][batch_start:batch_end] = batch_out in _predict_loop() or in _test_loop there is outs[i] += batch_out * len(batch_ids) and then outs[i] /= samples.

ahundt · 2017-08-09T02:30:57Z

@fchollet @TimZaman @Dref360 Considering the need for predict & evaluate, which then requires labels from input tensors, could we simply continue the review over at #6928, or is there a better approach?

Everything from this PR #7113 is merged into #6928.
While I know #6928 is rather large but it is the only PR that can provide a smooth transition in a single merge with decent overall API consistency. I've got everything working now in #6928 as follows:

# API 2

model = # on top of the tensor input
model.add_loss()  # involving y_tensor
model.fit(epochs=10, steps_per_epoch=1000)

# API 3

model = # on top of the tensor input
model.compile()
model.fit(y=y_tensor, epochs=10, steps_per_epoch=1000)

There are extended unit tests and support for Input Tensors with each of the following APIs:

    # train_on_batch
    out = model.train_on_batch(x, y)

    # test_on_batch
    out = model.test_on_batch(x, y)

    # predict_on_batch
    out = model.predict_on_batch(x)

    # fit
    out = model.fit(x, y, epochs=1, batch_size=batch_size,
                    steps_per_epoch=steps_per_epoch)

    # evaluate
    out = model.evaluate(x, y, batch_size=batch_size,
                         steps=steps_per_epoch)

    # predict
    out = model.predict(x, batch_size=batch_size,
                        steps=steps_per_epoch)

I've also incorporated and merged all feedback from all the split atomic PRs into #6928, so it is the canonical version with the most complete functionality for the purposes discussed here, but I'm ok with an alternative solution that works as well. :-)

fchollet · 2017-08-10T21:32:47Z

keras/engine/training.py

+            steps: Total number of steps (batches of samples)
+                before declaring _predict_loop finished.
+                Ignored with the default value of `None`.
+            steps_name: The public API's parameter name for `steps`.


Docstring should have a Returns section and a Raises section.

fchollet · 2017-08-10T21:33:09Z

keras/engine/training.py

+            ins: list of tensors to be fed to the Keras function.
+            batch_size: integer batch size or None if unknown.
+            steps: Total number of steps (batches of samples)
+                before declaring _predict_loop finished.


Using code markers around code keywords (.e.g _predict_loop).

fchollet · 2017-08-10T21:37:49Z

keras/engine/training.py

+                if hasattr(ins[0], 'shape'):
+                    validation_steps = steps_per_epoch
+                else:
+                    raise ValueError('When `steps_per_epoch` validation '


"When using steps_per_epoch, ..."

fchollet · 2017-08-10T21:43:28Z

keras/engine/training.py


        self.history = cbks.History()
        callbacks = [cbks.BaseLogger()] + (callbacks or []) + [self.history]
        if verbose:
-            callbacks += [cbks.ProgbarLogger()]
+            if steps_per_epoch:


Prefer if steps_per_epoch is not None

ahundt · 2017-08-11T17:52:45Z

@fchollet Addressed the review items here.

* commit '41fdd5aa5fe080bf5fa12638b9abc9f50d835a39': training.py improve docstrings and error case fix docstring comments from review (keras-team#7113)

fchollet

LGTM, thanks!

TimZaman · 2017-08-11T19:43:57Z

Awesome!

…

On Fri, 11 Aug 2017 at 21:06, François Chollet ***@***.***> wrote: Merged #7113 <#7113>. — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub <#7113 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AHXSRHYCC8oRgAkkvHtCAlJBmlVx9tqXks5sXJgigaJpZM4OENzV> .

* master: model.fit(steps_per_epoch), mnist_tfrecord.py, progbar np.mean (keras-team#7113) Change default size to allow different MobileNet sizes (keras-team#7586) cntk backend: fix the reversed rnn bug (keras-team#7593) Fix mask for multi output --> multi inputs (keras-team#7591) [RELNOTES] Subtract merge layer (keras-team#7573) update docker with cntk 2.1 (keras-team#7565) [RELNOTES] Move constraint management to be based on variable attributes (like TF). (keras-team#7564) Add handling for `dtype` arg in initializer config. Fix keras-team#7550. (keras-team#7552) remove unnecessary function definition (keras-team#7542) refactor the function - _convert_string_dtype (keras-team#7540) Add batchnorm tests for CNTK (keras-team#7534) Clean up RNN tests (keras-team#7529) Add merge tests (keras-team#7533) # Conflicts: # examples/mnist_tfrecord.py # keras/engine/training.py # keras/utils/generic_utils.py # tests/keras/engine/test_training.py

ahundt · 2017-08-11T22:58:13Z

Yay!

ahundt added 13 commits June 20, 2017 21:58

generic_utils.py don't crash when dealing with batched data

1a5f6b6

Progbar() unit test

38cfe25

mnist_tfrecord.py added (keras-team#7061, keras-team#7072, keras-team…

c67cfad

…#6928, keras-team#7046)

Fix mnist_tfrecord.py runtime errors

b1839e2

mnist_tfrecord.py pep8

b8085f9

mnist_tfrecord.py add parallelism option

3da96e5

Merge branch 'master' into progbar_batches

d1ea4b7

reorder inputs

b8019c6

mnist_tfrecord.py indentation fix

750a211

lower batch size and epochs

2a1cd77

loss defaults to None in compile()

0c43bba

mnist_tfrecord.py

40d16c3

model.fit(steps_per_epoch) added

f3e25de

fchollet reviewed Jun 24, 2017

View reviewed changes

added _check_num_samples for cases when batch_size does not apply

7d8f0b7

fix test failures

563c5ff

remove inaccurate warning

0de3fc6

fchollet reviewed Jun 29, 2017

View reviewed changes

This was referenced Jul 3, 2017

Input Tensors: High Performance Large Datasets via TFRecords #6928

Closed

Native TensorFlow input queue implemented with fit, predict, evaluate (TFRecords) #7208

Closed

ahundt mentioned this pull request Jul 13, 2017

reorganize training.py, code is clearer and handles more corner cases… #7072

Closed

ahundt added 4 commits July 31, 2017 22:25

improved fit(steps_per_epoch) with separate internal epoch loop in _f…

e9b63cc

…it_loop

fit(steps_per_epoch) initial validation support

5bcdc36

training.py pep8

9f343a1

ahundt mentioned this pull request Aug 1, 2017

Add tensor input for evaluation. ahundt/keras#1

Closed

ahundt added 2 commits August 7, 2017 21:40

training.py fix test error

f1af666

mnist_tfrecord.py and training.py fixed review comments, docs, and er…

351e56b

…ror messages (keras-team#7113)

training.py fix unit test error for steps_per_epoch

d755b80

TimZaman reviewed Aug 8, 2017

View reviewed changes

Dref360 reviewed Aug 8, 2017

View reviewed changes

ahundt added a commit to ahundt/keras that referenced this pull request Aug 8, 2017

add Model.evaluate(steps) and correct docs according to review. (kera…

d88987d

…s-team#7113)

fchollet reviewed Aug 8, 2017

View reviewed changes

fix docstring comments from review (keras-team#7113)

56736f3

ahundt force-pushed the fit_steps_per_epoch branch from 3e13d6c to 56736f3 Compare August 8, 2017 20:54

ahundt commented Aug 8, 2017

View reviewed changes

fchollet reviewed Aug 10, 2017

View reviewed changes

training.py improve docstrings and error case

41fdd5a

fchollet approved these changes Aug 11, 2017

View reviewed changes

fchollet merged commit d687c6e into keras-team:master Aug 11, 2017

model.fit(steps_per_epoch), mnist_tfrecord.py, progbar np.mean #7113

model.fit(steps_per_epoch), mnist_tfrecord.py, progbar np.mean #7113

Conversation

ahundt commented Jun 24, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

fchollet commented Jun 25, 2017

ahundt commented Jun 26, 2017 • edited Loading

ahundt commented Jun 26, 2017

fchollet Jun 29, 2017 • edited Loading

Choose a reason for hiding this comment

ahundt Jun 29, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ahundt Jul 8, 2017 • edited Loading

Choose a reason for hiding this comment

ahundt commented Aug 8, 2017 • edited Loading

ahundt commented Aug 8, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

TimZaman commented Aug 8, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ahundt Aug 8, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ahundt commented Aug 8, 2017 • edited Loading

fchollet commented Aug 8, 2017

ahundt left a comment • edited Loading

Choose a reason for hiding this comment

ahundt Aug 8, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ahundt commented Aug 9, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ahundt commented Aug 11, 2017

fchollet left a comment

Choose a reason for hiding this comment

TimZaman commented Aug 11, 2017 via email

ahundt commented Aug 11, 2017

ahundt commented Jun 24, 2017 •

edited

Loading

ahundt commented Jun 26, 2017 •

edited

Loading

fchollet Jun 29, 2017 •

edited

Loading

ahundt Jun 29, 2017 •

edited

Loading

ahundt Jul 8, 2017 •

edited

Loading

ahundt commented Aug 8, 2017 •

edited

Loading

ahundt Aug 8, 2017 •

edited

Loading

ahundt commented Aug 8, 2017 •

edited

Loading

ahundt left a comment •

edited

Loading

ahundt Aug 8, 2017 •

edited

Loading

ahundt commented Aug 9, 2017 •

edited

Loading