Comment calculer optimal de la taille des lots

Parfois, je rencontre un problème:

OOM lors de l'attribution du tenseur de la forme de la

e.q.

OOM lors de l'attribution du tenseur de la forme (1024, 100, 160)

Où 1024 est ma taille de lot et je ne sais pas ce qui est le reste. Si je diminue la taille de lot ou le nombre de neurones dans le modèle, il fonctionne très bien.

Est-il un générique façon de calculer optimal de la taille des lots en fonction du modèle et de la mémoire graphique, de sorte que le programme ne plante pas?

MODIFIER

Depuis ma question peut sembler incertaine, permettez-moi de mettre à sa manière: je veux la plus grande taille de lot possible en termes de mon modèle, qui va rentrer dans mon GPU, de la mémoire et de ne pas planter le programme.

EDIT 2

À celui qui a voté pour la fermeture de la question d'être trop large: Comment sur terre est la question trop large? Il y a un algorithme qui sélectionne une portion de données pour mettre en mémoire GPU. Il est clairement imparfait puisque les données excède parfois les la mémoire graphique. Demander comment fonctionne l'algorithme, afin d'éviter des plantages aléatoires, semble tout à fait raisonnable pour moi.

InformationsquelleAutor Andrzej Gis | 2017-10-09

8

Vous pouvez estimer le plus grand de la taille des lots à l'aide de:

Max taille des lots= disponible de la mémoire graphique octets /4 /(taille des tenseurs + facile à former des paramètres)
- Comment puis-je obtenir le taille de tenseurs et le nombre éducables paramètres? N'êtes-vous pas disparus de la taille des modèles dans l'équation?
- intéressant - ne pourriez-vous point de référence?
- la taille du modèle est en fait le pas de paramètres d'entraînement, ce qui en Keras vous obtenez avec model.summary()
- Je ne suis pas sûr si vous êtes à droite. Si je créer un grand netowork et de le nourrir avec des batch_size=1, j'ai également le même message d'erreur.
- Cela peut certainement se produire que la combinaison de votre modèle taille (facile à former des paramètres) et de la taille des données d'entrée d'échappement de votre mémoire, même avec batch_size = 1, surtout si vous avez un petit GPU...
- hehe, je n'ai pas que "non" est synonyme de "nombre". Maintenant, il prend tout son sens 🙂
- Qu'est-ce que taille de tenseurs ? Je suis encore confus à propos de cette partie.
- Chaque couche a ses tenseur + une ou plusieurs matrices de poids (généralement désigné comme aptes à la formation des paramètres). Par exemple: si vous donnez le biberon à votre réseau avec 200x200 des images RVB, alors la taille de votre entrée tenseur (en octets) est [la taille des lots] * 3 * 200 * 200 ( * 4 si vous utilisez des entiers 64 bits)
- Théoriquement, votre formule de sens. Avez-vous déjà testé empiriquement? Je suis en observant les suivantes: Pour Alexnet avec 62 millions de paramètres et une taille d'image de 224x224x3 et un 6GO carte graphique, je devrais être capable de s'adapter: (6 GO - (62 Millions d'euros * 4 octets)) / (224 * 224 * 3 * 4 octets) = 9553 comme max_batch_size. Dans la pratique, je ne suis pas en mesure d'exécuter de formation avec plus de batch_size = 512. Avec 1024 déjà, elle se bloque. Deuxième exemple: l'organisme-50 a seulement 25 Millions de paramètres. Je devrais donc obtenir encore plus de max_batch_size. Dans la pratique, la formation se bloque avec batch_size=128. Veuillez informer.
- Vous devez prendre en compte tous les tenseurs, pas juste à l'entrée
- Pourriez-vous nous donner un exemple de ce que les tenseurs-vous dire? J'ai pensé avec tous les moyens paramètres je dois le prendre en compte? S'il vous plaît corrigez-moi si je me trompe.
- Pour chaque couche de votre modèle pour stocker un espace réservé d'entrée, une ou plusieurs matrices de poids (recyclable ou autre) et une sortie de l'espace réservé (qui peut également être le à côté de la couche d'entrée).
InformationsquelleAutor ilan
11

De la récente Apprentissage en Profondeur du livre par Goodfellow et coll., chapitre 8:
Minibatch tailles sont généralement pilotés par les facteurs suivants:
- De plus grands lots de fournir une estimation plus précise de la pente, mais
  avec moins linéaire des rendements.
- Architectures multicœurs sont généralement
  sous-utilisées en très petites quantités. Ce qui motive l'aide de certains
  minimum absolu de la taille des lots, en dessous de laquelle il n'y a pas de réduction de la
  temps de traitement d'une minibatch.
- Si tous les exemples dans le lot sont à
  le traitement en parallèle (comme c'est généralement le cas), alors le montant de
  la mémoire s'adapte à la taille du lot. Pour de nombreuses configurations matérielles c'est
  le facteur de limitation dans la taille des lots.
- Certains types de matériel de parvenir à
  meilleure exécution avec des tailles spécifiques de tableaux. En particulier lors de l'utilisation de
  Gpu, il est courant d'alimentation de 2 tailles de lots pour offrir une meilleure exécution.
  Puissance typique de 2 tailles de lots vont de 32 à 256, avec 16 parfois
  tentée pour les grands modèles.
- Petits lots peuvent offrir un
  la régularisation de l'effet (Wilson et Martinez, 2003), peut-être en raison de la
  le bruit qu'ils ajoutent au processus d'apprentissage. Erreur de généralisation est souvent
  le mieux pour une taille de lot de 1. La formation avec une petite taille de lot
  peut nécessiter un petit apprentissage de taux pour maintenir la stabilité en raison de
  le haut de la variance de l'estimation du gradient. La durée totale d'utilisation
  peuvent être très élevés en raison de la nécessité de faire plus d'étapes, à la fois
  en raison de la réduction du taux d'apprentissage et parce qu'il faut plus de mesures
  pour observer l'ensemble de l'ensemble d'apprentissage.
Qui, en pratique, signifie habituellement "dans les puissances de 2 et le plus grand, le mieux, à condition que le lot s'insère dans votre processeur graphique (GPU) de la mémoire".

Vous pourriez également consulter plusieurs postes de bons ici dans la Pile d'Échange:
Il suffit de garder à l'esprit que le papier par Keskar et coll. 'Sur de Grands Lots de Formation pour l'Apprentissage en Profondeur: la Généralisation de l'Écart et des Minima Pointus', cité par plusieurs des postes ci-dessus, a reçu quelques objections par d'autres respectable chercheurs de la profonde communauté d'apprentissage.

Espère que cela aide...

Mise à JOUR (Dec 2017): Il y a un nouveau document de Yoshua Bengio & équipe, Trois Facteurs Influençant Minima en SGD (Novembre 2017); il est intéressant de lire dans le sens où il rapporte de nouveaux théorique & résultats expérimentaux sur l'interaction entre l'apprentissage des taux et de la taille des lots.
- Il ne réponds pas vraiment à ma question. Je veux la plus grande taille de lot possible en termes de mon modèle, qui s'inscrivent dans ma mémoire GPU.
- Compris. Dans la pratique, surtout si vous utilisez un GPU, les puissances de 2 exigence est donc de limiter, même si vous obtenez un "optimale" taille de, disons, 800, vous ne les utilisez pas; ce que vous faire est de commencer avec un n (puissance de 2) et, si vous obtenez une OOM, essayez avec n/2, n/4, etc (si pas, vous essayez 2*n) - voir la 4ème balle au-dessus de
- Avec la taille si une erreur se produit est une nuisance importante quand vous faites des expériences avec hyperparameters et de topologies. Une formule générique serait génial. Même si le résultat sera arrondi à la puissance de 2.
InformationsquelleAutor desertnaut
1

J'ai couru dans le même GPU mem erreur qui a été résolu par la configuration de la tensorflow session avec les éléments suivants:
```
# See https://www.tensorflow.org/tutorials/using_gpu#allowing_gpu_memory_growth
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
```
voir: google colaboratory `ResourceExhaustedError` avec GPU
- Malheureusement, cela ne change rien pour un grand réseau 🙁
- Oui. Dans mon cas, colaboratory lance avec 12 go mais avec l'option activée, il peut pousser à 52GB
InformationsquelleAutor michael

pour définir la fonction pour trouver la taille de lot pour le modèle de la formation

def FindBatchSize(model):
    """#model: model architecture, that is yet to be trained"""
    import os, sys, psutil, gc, tensorflow, keras
    import numpy as np
    from keras import backend as K
    BatchFound= 16

    try:
        total_params= int(model.count_params());    GCPU= "CPU"
        #find whether gpu is available
        try:
            if K.tensorflow_backend._get_available_gpus()== []:
                GCPU= "CPU";    #CPU and Cuda9GPU
            else:
                GCPU= "GPU"
        except:
            from tensorflow.python.client import device_lib;    #Cuda8GPU
            def get_available_gpus():
                local_device_protos= device_lib.list_local_devices()
                return [x.name for x in local_device_protos if x.device_type == 'GPU']
            if "gpu" not in str(get_available_gpus()).lower():
                GCPU= "CPU"
            else:
                GCPU= "GPU"

        #decide batch size on the basis of GPU availability and model complexity
        if (GCPU== "GPU") and (os.cpu_count() >15) and (total_params <1000000):
            BatchFound= 64    
        if (os.cpu_count() <16) and (total_params <500000):
            BatchFound= 64  
        if (GCPU== "GPU") and (os.cpu_count() >15) and (total_params <2000000) and (total_params >=1000000):
            BatchFound= 32      
        if (GCPU== "GPU") and (os.cpu_count() >15) and (total_params >=2000000) and (total_params <10000000):
            BatchFound= 16  
        if (GCPU== "GPU") and (os.cpu_count() >15) and (total_params >=10000000):
            BatchFound= 8       
        if (os.cpu_count() <16) and (total_params >5000000):
            BatchFound= 8    
        if total_params >100000000:
            BatchFound= 1

    except:
        pass
    try:

        #find percentage of memory used
        memoryused= psutil.virtual_memory()
        memoryused= float(str(memoryused).replace(" ", "").split("percent=")[1].split(",")[0])
        if memoryused >75.0:
            BatchFound= 8
        if memoryused >85.0:
            BatchFound= 4
        if memoryused >90.0:
            BatchFound= 2
        if total_params >100000000:
            BatchFound= 1
        print("Batch Size:  "+ str(BatchFound));    gc.collect()
    except:
        pass

    memoryused= [];    total_params= [];    GCPU= "";
    del memoryused, total_params, GCPU;    gc.collect()
    return BatchFound



#####################################################################################################
#####################################################################################################

InformationsquelleAutor Anurag Gupta

Vous devez vous connecter pour publier un commentaire.