Quelle est la différence entre "samples_per_Epoch" et "steps_per_Epoch" dans fit_generator
J'ai été dérouté par ce problème pendant plusieurs jours ...
Ma question est la suivante: pourquoi le temps d’entraînement a-t-il une telle différence entre le fait que j’ai défini le paramètre batch_size sur "1" et sur "20" pour mon générateur?.
Si je règle batch_size à 1, le temps d'apprentissage de 1 Epoch est d'environ 180 ~ 200 s .Si je règle batch_size sur 20, le temps d'apprentissage de 1 Epoch est d'environ 3000 ~ 3200 s.
Cependant, cette horrible différence entre ces durées de formation semble anormale ..., puisque ce devrait être le résultat inverse: Batch_size = 1, temps de formation -> 3000 ~ 3200 s . Batch_size = 20, temps de formation -> 180 ~ 200 sec.
L’entrée de mon générateur n’est pas le chemin du fichier, mais les tableaux numpy qui sont déjà chargés dans la mémoire Via l’appel "np.load ()" . Je pense donc que le problème de l’arbitrage E/S ne n'existe pas.
J'utilise Keras-2.0.3 et mon backend est tensorflow-gpu 1.0.1
J'ai vu la mise à jour de ce fichier fusionné PR , , Mais il semble que ce changement n'affectera rien du tout. (l'utilisation est identique à l'original)
Le link est ici l’essentiel de mon générateur défini par moi-même et de la partie de mon fit_generator.
Est-ce que quelqu'un pourrait m'aider à expliquer ce problème? Merci beaucoup :)
Lorsque vous utilisez fit_generator, le nombre d'échantillons traités pour chaque époque est batch_size * steps_per_epochs. De la documentation de Keras pour fit_generator: https://keras.io/models/sequential/
steps_per_Epoch: Nombre total d’étapes (lots d’échantillons) à générer à partir du générateur avant de déclarer une époque terminée et de commencer à l’époque suivante. Il doit généralement être égal au nombre d'échantillons uniques de votre jeu de données divisé par la taille du lot.
Ceci est différent du comportement de 'fit', où augmenter batch_size accélère généralement les choses.
En conclusion, lorsque vous augmentez batch_size avec fit_generator, vous devez réduire les étapes step_per_epochs du même facteur, si vous souhaitez que le temps d’entraînement reste identique ou inférieur.
Le tout est:
fit() fonctionne plus rapidement que fit_generator() puisqu'il peut accéder aux données directement en mémoire.
fit() prend en mémoire les données des tableaux numpy, alors que fit_generator() prend des données du générateur de séquence telles que keras.utils.Sequence qui fonctionne plus lentement.
Vous devez également prendre en compte les paramètres de fonction suivants lorsque vous utilisez fit_generator:
max_queue_size, use_multiprocessing et workers
max_queue_size - peut entraîner le chargement de plus de données que prévu, ce qui, en fonction du code du générateur, peut provoquer des imprévus ou des actions inutiles susceptibles de ralentir les temps d'exécution.
use_multiprocessing avec workers - peut entraîner des processus supplémentaires susceptibles de générer un travail supplémentaire pour la sérialisation et la communication interprocessus. Vous devez d'abord sérialiser vos données à l'aide de pickle, puis les envoyer à ces processus cibles, puis effectuer votre traitement à l'intérieur de ces processus, puis la totalité de la procédure de communication se répète à l'envers, vous picklez les résultats et les envoyez au processus principal. via RPC. Dans la plupart des cas, cela devrait être rapide, mais si vous traitez des dizaines de giga-octets de données ou si votre générateur est implémenté de manière sous-optimale, vous risquez d'obtenir le ralentissement que vous décrivez.