parameters: (self,
                      generator,
                      steps_per_epoch,
                      epochs=1,
                      verbose=1,
                      callbacks=None,
                      validation_data=None,
                      validation_steps=None,
                      class_weight=None,
                      max_queue_size=10,
                      workers=1,
                      use_multiprocessing=False,
                      initial_epoch=0,
                      **kwargs)
return_statement: return self.model.fit_generator(
          generator,
          steps_per_epoch,
          epochs,
          verbose=verbose,
          callbacks=callbacks,
          validation_data=validation_data,
          validation_steps=validation_steps,
          class_weight=class_weight,
          max_queue_size=max_queue_size,
          workers=workers,
          use_multiprocessing=use_multiprocessing,
          initial_epoch=initial_epoch)
docstring: Fits the model on data generated batch-by-batch by a Python generator.
  
      The generator is run in parallel to the model, for efficiency.
      For instance, this allows you to do real-time data augmentation
      on images on CPU in parallel to training your model on GPU.
  
      Arguments:
          generator: A generator.
              The output of the generator must be either
              - a tuple (inputs, targets)
              - a tuple (inputs, targets, sample_weights).
              All arrays should contain the same number of samples.
              The generator is expected to loop over its data
              indefinitely. An epoch finishes when `steps_per_epoch`
              batches have been seen by the model.
          steps_per_epoch: Total number of steps (batches of samples)
              to yield from `generator` before declaring one epoch
              finished and starting the next epoch. It should typically
              be equal to the number of unique samples of your dataset
              divided by the batch size.
          epochs: Integer, total number of iterations on the data.
          verbose: Verbosity mode, 0, 1, or 2.
          callbacks: List of callbacks to be called during training.
          validation_data: This can be either
              - A generator for the validation data
              - A tuple (inputs, targets)
              - A tuple (inputs, targets, sample_weights).
          validation_steps: Only relevant if `validation_data`
              is a generator.
              Number of steps to yield from validation generator
              at the end of every epoch. It should typically
              be equal to the number of unique samples of your
              validation dataset divided by the batch size.
          class_weight: Dictionary mapping class indices to a weight
              for the class.
          max_queue_size: Maximum size for the generator queue
          workers: Maximum number of processes to spin up
          use_multiprocessing: If True, use process based threading.
              Note that because
              this implementation relies on multiprocessing,
              you should not pass
              non picklable arguments to the generator
              as they can't be passed
              easily to children processes.
          initial_epoch: Epoch at which to start training
              (useful for resuming a previous training run)
          **kwargs: support for legacy arguments.
  
      Returns:
          A `History` object.
  
      Raises:
          RuntimeError: if the model was never compiled.
          ValueError: In case the generator yields
              data in an invalid format.
  
      Example:
  
      ```python
          def generate_arrays_from_file(path):
              while 1:
                  f = open(path)
                  for line in f:
                      # create Numpy arrays of input data
                      # and labels, from each line in the file
                      x, y = process_line(line)
                      yield (x, y)
                      f.close()
  
          model.fit_generator(generate_arrays_from_file('/my_file.txt'),
                              steps_per_epoch=1000, epochs=10)
      ```
docstring_summary: Fits the model on data generated batch-by-batch by a Python generator.
docstring_tokens: Fits the model on data generated batch - by - batch by a Python generator .
function: def fit_generator(self,
                      generator,
                      steps_per_epoch,
                      epochs=1,
                      verbose=1,
                      callbacks=None,
                      validation_data=None,
                      validation_steps=None,
                      class_weight=None,
                      max_queue_size=10,
                      workers=1,
                      use_multiprocessing=False,
                      initial_epoch=0,
                      **kwargs):
      """Fits the model on data generated batch-by-batch by a Python generator.
  
      The generator is run in parallel to the model, for efficiency.
      For instance, this allows you to do real-time data augmentation
      on images on CPU in parallel to training your model on GPU.
  
      Arguments:
          generator: A generator.
              The output of the generator must be either
              - a tuple (inputs, targets)
              - a tuple (inputs, targets, sample_weights).
              All arrays should contain the same number of samples.
              The generator is expected to loop over its data
              indefinitely. An epoch finishes when `steps_per_epoch`
              batches have been seen by the model.
          steps_per_epoch: Total number of steps (batches of samples)
              to yield from `generator` before declaring one epoch
              finished and starting the next epoch. It should typically
              be equal to the number of unique samples of your dataset
              divided by the batch size.
          epochs: Integer, total number of iterations on the data.
          verbose: Verbosity mode, 0, 1, or 2.
          callbacks: List of callbacks to be called during training.
          validation_data: This can be either
              - A generator for the validation data
              - A tuple (inputs, targets)
              - A tuple (inputs, targets, sample_weights).
          validation_steps: Only relevant if `validation_data`
              is a generator.
              Number of steps to yield from validation generator
              at the end of every epoch. It should typically
              be equal to the number of unique samples of your
              validation dataset divided by the batch size.
          class_weight: Dictionary mapping class indices to a weight
              for the class.
          max_queue_size: Maximum size for the generator queue
          workers: Maximum number of processes to spin up
          use_multiprocessing: If True, use process based threading.
              Note that because
              this implementation relies on multiprocessing,
              you should not pass
              non picklable arguments to the generator
              as they can't be passed
              easily to children processes.
          initial_epoch: Epoch at which to start training
              (useful for resuming a previous training run)
          **kwargs: support for legacy arguments.
  
      Returns:
          A `History` object.
  
      Raises:
          RuntimeError: if the model was never compiled.
          ValueError: In case the generator yields
              data in an invalid format.
  
      Example:
  
      ```python
          def generate_arrays_from_file(path):
              while 1:
                  f = open(path)
                  for line in f:
                      # create Numpy arrays of input data
                      # and labels, from each line in the file
                      x, y = process_line(line)
                      yield (x, y)
                      f.close()
  
          model.fit_generator(generate_arrays_from_file('/my_file.txt'),
                              steps_per_epoch=1000, epochs=10)
      ```
      """
      # Legacy support
      if 'max_q_size' in kwargs:
        max_queue_size = kwargs.pop('max_q_size')
        logging.warning('The argument `max_q_size` has been renamed '
                        '`max_queue_size`. Update your method calls accordingly.')
      if 'pickle_safe' in kwargs:
        use_multiprocessing = kwargs.pop('pickle_safe')
        logging.warning('The argument `pickle_safe` has been renamed '
                        '`use_multiprocessing`. '
                        'Update your method calls accordingly.')
      if kwargs:
        raise ValueError('Unrecognized keyword arguments: ' + str(kwargs))
  
      if self.model is None:
        raise RuntimeError('The model needs to be compiled ' 'before being used.')
      return self.model.fit_generator(
          generator,
          steps_per_epoch,
          epochs,
          verbose=verbose,
          callbacks=callbacks,
          validation_data=validation_data,
          validation_steps=validation_steps,
          class_weight=class_weight,
          max_queue_size=max_queue_size,
          workers=workers,
          use_multiprocessing=use_multiprocessing,
          initial_epoch=initial_epoch)
function_tokens: def fit_generator ( self , generator , steps_per_epoch , epochs = 1 , verbose = 1 , callbacks = None , validation_data = None , validation_steps = None , class_weight = None , max_queue_size = 10 , workers = 1 , use_multiprocessing = False , initial_epoch = 0 , * * kwargs ) : # Legacy support if 'max_q_size' in kwargs : max_queue_size = kwargs . pop ( 'max_q_size' ) logging . warning ( 'The argument `max_q_size` has been renamed ' '`max_queue_size`. Update your method calls accordingly.' ) if 'pickle_safe' in kwargs : use_multiprocessing = kwargs . pop ( 'pickle_safe' ) logging . warning ( 'The argument `pickle_safe` has been renamed ' '`use_multiprocessing`. ' 'Update your method calls accordingly.' ) if kwargs : raise ValueError ( 'Unrecognized keyword arguments: ' + str ( kwargs ) ) if self . model is None : raise RuntimeError ( 'The model needs to be compiled ' 'before being used.' ) return self . model . fit_generator ( generator , steps_per_epoch , epochs , verbose = verbose , callbacks = callbacks , validation_data = validation_data , validation_steps = validation_steps , class_weight = class_weight , max_queue_size = max_queue_size , workers = workers , use_multiprocessing = use_multiprocessing , initial_epoch = initial_epoch )