wake-up-neo.com

Keras verwendet beim Aufruf von train_on_batch, fit usw. viel zu viel GPU-Speicher

Ich habe mit Keras rumgespielt und mag es bis jetzt. Beim Arbeiten mit relativ tiefen Netzwerken gab es ein großes Problem: Beim Aufruf von model.train_on_batch oder model.fit usw. weist Keras wesentlich mehr GPU-Speicher zu, als das Modell selbst benötigen sollte. Dies wird nicht dadurch verursacht, dass versucht wird, einige wirklich große Bilder zu trainieren. Das Netzwerkmodell selbst scheint viel GPU-Speicher zu erfordern. Ich habe dieses Spielzeugbeispiel erstellt, um zu zeigen, was ich meine. Hier ist im Wesentlichen, was los ist:

Ich erstelle ein ziemlich tiefes Netzwerk und verwende model.summary (), um die Gesamtzahl der für das Netzwerk erforderlichen Parameter zu ermitteln (in diesem Fall 206538153, was etwa 826 MB entspricht). Ich verwende dann nvidia-smi, um zu sehen, wie viel GPU-Speicher Keras zugewiesen hat, und ich kann sehen, dass es vollkommen Sinn macht (849 MB).

Ich kompiliere dann das Netzwerk und kann bestätigen, dass dies die GPU-Speicherverwendung nicht erhöht. Und wie wir in diesem Fall sehen können, stehen mir an diesem Punkt fast 1 GB VRAM zur Verfügung.

Dann versuche ich, ein einfaches 16x16-Bild und eine 1x1-Grundwahrheit in das Netzwerk einzuspeisen, und dann sprengt alles, weil Keras wieder ganz viel Speicher zuweist, und das ist für mich offensichtlich. Etwas über das Training des Netzwerks scheint viel mehr Speicher als nur das Modell zu benötigen, was für mich nicht sinnvoll ist. Ich habe wesentlich tiefere Netzwerke auf dieser GPU in anderen Frameworks trainiert, so dass ich denke, dass ich Keras falsch benutze (oder dass in meinem Setup oder in Keras etwas nicht stimmt, aber das ist natürlich schwer zu wissen).

Hier ist der Code:

from scipy import misc
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation, Convolution2D, MaxPooling2D, Reshape, Flatten, ZeroPadding2D, Dropout
import os

model = Sequential()

model.add(Convolution2D(256, 3, 3, border_mode='same', input_shape=(16,16,1)))
model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2)))
model.add(Convolution2D(512, 3, 3, border_mode='same'))
model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2)))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(Convolution2D(1024, 3, 3, border_mode='same'))
model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2)))
model.add(Convolution2D(256, 3, 3, border_mode='same'))
model.add(Convolution2D(32, 3, 3, border_mode='same'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Flatten())
model.add(Dense(4))
model.add(Dense(1))

model.summary()

os.system("nvidia-smi")
raw_input("Press Enter to continue...")    

model.compile(optimizer='sgd',
              loss='mse', 
              metrics=['accuracy'])

os.system("nvidia-smi")              
raw_input("Compiled model. Press Enter to continue...")

n_batches = 1
batch_size = 1
for ibatch in range(n_batches):
    x = np.random.Rand(batch_size, 16,16,1)
    y = np.random.Rand(batch_size, 1)

    os.system("nvidia-smi")
    raw_input("About to train one iteration. Press Enter to continue...")

    model.train_on_batch(x, y)         
    print("Trained one iteration")

Welche gibt mir folgende Ausgabe:

Using Theano backend.
Using gpu device 0: GeForce GTX 960 (CNMeM is disabled, cuDNN 5103)
/usr/local/lib/python2.7/dist-packages/theano/sandbox/cuda/__init__.py:600: UserWarning: Your cuDNN version is more recent than the one Theano officially supports. If you see any problems, try updating Theano or downgrading cuDNN to version 5.
  warnings.warn(warn)
____________________________________________________________________________________________________
Layer (type)                     Output Shape          Param #     Connected to                     
====================================================================================================
convolution2d_1 (Convolution2D)  (None, 16, 16, 256)   2560        convolution2d_input_1[0][0]      
____________________________________________________________________________________________________
maxpooling2d_1 (MaxPooling2D)    (None, 8, 8, 256)     0           convolution2d_1[0][0]            
____________________________________________________________________________________________________
convolution2d_2 (Convolution2D)  (None, 8, 8, 512)     1180160     maxpooling2d_1[0][0]             
____________________________________________________________________________________________________
maxpooling2d_2 (MaxPooling2D)    (None, 4, 4, 512)     0           convolution2d_2[0][0]            
____________________________________________________________________________________________________
convolution2d_3 (Convolution2D)  (None, 4, 4, 1024)    4719616     maxpooling2d_2[0][0]             
____________________________________________________________________________________________________
convolution2d_4 (Convolution2D)  (None, 4, 4, 1024)    9438208     convolution2d_3[0][0]            
____________________________________________________________________________________________________
convolution2d_5 (Convolution2D)  (None, 4, 4, 1024)    9438208     convolution2d_4[0][0]            
____________________________________________________________________________________________________
convolution2d_6 (Convolution2D)  (None, 4, 4, 1024)    9438208     convolution2d_5[0][0]            
____________________________________________________________________________________________________
convolution2d_7 (Convolution2D)  (None, 4, 4, 1024)    9438208     convolution2d_6[0][0]            
____________________________________________________________________________________________________
convolution2d_8 (Convolution2D)  (None, 4, 4, 1024)    9438208     convolution2d_7[0][0]            
____________________________________________________________________________________________________
convolution2d_9 (Convolution2D)  (None, 4, 4, 1024)    9438208     convolution2d_8[0][0]            
____________________________________________________________________________________________________
convolution2d_10 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_9[0][0]            
____________________________________________________________________________________________________
convolution2d_11 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_10[0][0]           
____________________________________________________________________________________________________
convolution2d_12 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_11[0][0]           
____________________________________________________________________________________________________
convolution2d_13 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_12[0][0]           
____________________________________________________________________________________________________
convolution2d_14 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_13[0][0]           
____________________________________________________________________________________________________
convolution2d_15 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_14[0][0]           
____________________________________________________________________________________________________
convolution2d_16 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_15[0][0]           
____________________________________________________________________________________________________
convolution2d_17 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_16[0][0]           
____________________________________________________________________________________________________
convolution2d_18 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_17[0][0]           
____________________________________________________________________________________________________
convolution2d_19 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_18[0][0]           
____________________________________________________________________________________________________
convolution2d_20 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_19[0][0]           
____________________________________________________________________________________________________
convolution2d_21 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_20[0][0]           
____________________________________________________________________________________________________
convolution2d_22 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_21[0][0]           
____________________________________________________________________________________________________
convolution2d_23 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_22[0][0]           
____________________________________________________________________________________________________
convolution2d_24 (Convolution2D) (None, 4, 4, 1024)    9438208     convolution2d_23[0][0]           
____________________________________________________________________________________________________
maxpooling2d_3 (MaxPooling2D)    (None, 2, 2, 1024)    0           convolution2d_24[0][0]           
____________________________________________________________________________________________________
convolution2d_25 (Convolution2D) (None, 2, 2, 256)     2359552     maxpooling2d_3[0][0]             
____________________________________________________________________________________________________
convolution2d_26 (Convolution2D) (None, 2, 2, 32)      73760       convolution2d_25[0][0]           
____________________________________________________________________________________________________
maxpooling2d_4 (MaxPooling2D)    (None, 1, 1, 32)      0           convolution2d_26[0][0]           
____________________________________________________________________________________________________
flatten_1 (Flatten)              (None, 32)            0           maxpooling2d_4[0][0]             
____________________________________________________________________________________________________
dense_1 (Dense)                  (None, 4)             132         flatten_1[0][0]                  
____________________________________________________________________________________________________
dense_2 (Dense)                  (None, 1)             5           dense_1[0][0]                    
====================================================================================================
Total params: 206538153
____________________________________________________________________________________________________
None
Thu Oct  6 09:05:42 2016       
+------------------------------------------------------+                       
| NVIDIA-SMI 352.63     Driver Version: 352.63         |                       
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX 960     Off  | 0000:01:00.0      On |                  N/A |
| 30%   37C    P2    28W / 120W |   1082MiB /  2044MiB |      9%      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID  Type  Process name                               Usage      |
|=============================================================================|
|    0      1796    G   /usr/bin/X                                     155MiB |
|    0      2597    G   compiz                                          65MiB |
|    0      5966    C   python                                         849MiB |
+-----------------------------------------------------------------------------+
Press Enter to continue...
Thu Oct  6 09:05:44 2016       
+------------------------------------------------------+                       
| NVIDIA-SMI 352.63     Driver Version: 352.63         |                       
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX 960     Off  | 0000:01:00.0      On |                  N/A |
| 30%   38C    P2    28W / 120W |   1082MiB /  2044MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID  Type  Process name                               Usage      |
|=============================================================================|
|    0      1796    G   /usr/bin/X                                     155MiB |
|    0      2597    G   compiz                                          65MiB |
|    0      5966    C   python                                         849MiB |
+-----------------------------------------------------------------------------+
Compiled model. Press Enter to continue...
Thu Oct  6 09:05:44 2016       
+------------------------------------------------------+                       
| NVIDIA-SMI 352.63     Driver Version: 352.63         |                       
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX 960     Off  | 0000:01:00.0      On |                  N/A |
| 30%   38C    P2    28W / 120W |   1082MiB /  2044MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID  Type  Process name                               Usage      |
|=============================================================================|
|    0      1796    G   /usr/bin/X                                     155MiB |
|    0      2597    G   compiz                                          65MiB |
|    0      5966    C   python                                         849MiB |
+-----------------------------------------------------------------------------+
About to train one iteration. Press Enter to continue...
Error allocating 37748736 bytes of device memory (out of memory). Driver report 34205696 bytes free and 2144010240 bytes total 
Traceback (most recent call last):
  File "memtest.py", line 65, in <module>
    model.train_on_batch(x, y)         
  File "/usr/local/lib/python2.7/dist-packages/keras/models.py", line 712, in train_on_batch
    class_weight=class_weight)
  File "/usr/local/lib/python2.7/dist-packages/keras/engine/training.py", line 1221, in train_on_batch
    outputs = self.train_function(ins)
  File "/usr/local/lib/python2.7/dist-packages/keras/backend/theano_backend.py", line 717, in __call__
    return self.function(*inputs)
  File "/usr/local/lib/python2.7/dist-packages/theano/compile/function_module.py", line 871, in __call__
    storage_map=getattr(self.fn, 'storage_map', None))
  File "/usr/local/lib/python2.7/dist-packages/theano/gof/link.py", line 314, in raise_with_op
    reraise(exc_type, exc_value, exc_trace)
  File "/usr/local/lib/python2.7/dist-packages/theano/compile/function_module.py", line 859, in __call__
    outputs = self.fn()
MemoryError: Error allocating 37748736 bytes of device memory (out of memory).
Apply node that caused the error: GpuContiguous(GpuDimShuffle{3,2,0,1}.0)
Toposort index: 338
Inputs types: [CudaNdarrayType(float32, 4D)]
Inputs shapes: [(1024, 1024, 3, 3)]
Inputs strides: [(1, 1024, 3145728, 1048576)]
Inputs values: ['not shown']
Outputs clients: [[GpuDnnConv{algo='small', inplace=True}(GpuContiguous.0, GpuContiguous.0, GpuAllocEmpty.0, GpuDnnConvDesc{border_mode='half', subsample=(1, 1), conv_mode='conv', precision='float32'}.0, Constant{1.0}, Constant{0.0}), GpuDnnConvGradI{algo='none', inplace=True}(GpuContiguous.0, GpuContiguous.0, GpuAllocEmpty.0, GpuDnnConvDesc{border_mode='half', subsample=(1, 1), conv_mode='conv', precision='float32'}.0, Constant{1.0}, Constant{0.0})]]

HINT: Re-running with most Theano optimization disabled could give you a back-trace of when this node was created. This can be done with by setting the Theano flag 'optimizer=fast_compile'. If that does not work, Theano optimizations can be disabled with 'optimizer=None'.
HINT: Use the Theano flag 'exception_verbosity=high' for a debugprint and storage map footprint of this apply node.

Ein paar Dinge zu beachten: 

  • Ich habe sowohl Theano als auch TensorFlow Backends ausprobiert. Beide haben die gleichen Probleme und haben in derselben Zeile keinen Speicher mehr. In TensorFlow scheint Keras sehr viel Speicher (ca. 1,5 GB) vorzuordnen, so dass nvidia-smi uns nicht hilft, das zu verfolgen, was dort vor sich geht, aber ich bekomme die gleichen Out-of-Memory-Ausnahmen. Dies weist wiederum auf einen Fehler in (meiner Verwendung von) Keras hin (obwohl es schwierig ist, sich über solche Dinge sicher zu sein, könnte dies etwas mit meinem Setup sein).
  • Ich habe versucht, CNMEM in Theano zu verwenden, das sich wie TensorFlow verhält: Es weist eine große Menge an Speicher (ca. 1,5 GB) vor, stürzt jedoch an derselben Stelle ab.
  • Es gibt einige Warnungen zur CudNN-Version. Ich habe versucht, das Theano-Backend mit CUDA auszuführen, aber nicht mit CudNN, und ich habe die gleichen Fehler erhalten, sodass dies nicht die Ursache des Problems ist.
  • Wenn Sie dies auf Ihrer eigenen GPU testen möchten, sollten Sie das Netzwerk je nach GPU-Speicher tiefer/flacher gestalten, um dies testen zu können.
  • Meine Konfiguration ist wie folgt: Ubuntu 14.04, GeForce GTX 960, CUDA 7.5.18, CudNN 5.1.3, Python 2.7, Keras 1.1.0 (über Pip installiert)
  • Ich habe versucht, die Kompilierung des Modells zu ändern, um verschiedene Optimierer und Verluste zu verwenden, aber das scheint nichts zu ändern.
  • Ich habe versucht, die Funktion train_on_batch zu ändern, um stattdessen "fit" zu verwenden, aber es hat das gleiche Problem.
  • Ich habe eine ähnliche Frage hier bei StackOverflow gesehen - Warum benötigt dieses Keras-Modell mehr als 6 GB Arbeitsspeicher? - aber soweit ich das beurteilen kann, habe ich diese Probleme nicht in meiner Konfiguration. Ich hatte noch nie mehrere Versionen von CUDA installiert und habe meine Variablen PATH, LD_LIBRARY_PATH und CUDA_ROOT mehrmals geprüft, als ich zählen kann.
  • Julius schlug vor, dass die Aktivierungsparameter selbst den GPU-Speicher belegen. Wenn dies wahr ist, kann jemand es etwas klarer erklären? Ich habe versucht, die Aktivierungsfunktion meiner Faltungsebenen in Funktionen zu ändern, die eindeutig hart programmiert sind und keine erlernbaren Parameter enthalten, soweit ich das beurteilen kann, und dies ändert nichts. Es ist auch unwahrscheinlich, dass diese Parameter fast genauso viel Speicher benötigen wie der Rest des Netzwerks.
  • Nach eingehenden Tests hat das größte Netzwerk, das ich trainieren kann, etwa 453 MB an Parametern, also etwa 2 GB GPU-RAM. Ist das normal? 
  • Nachdem ich Keras mit einigen kleineren CNNs getestet habe, die in meine GPU passen, kann ich feststellen, dass es sehr plötzliche Spitzen in der Verwendung von GPU RAM gibt. Wenn ich ein Netzwerk mit etwa 100 MB Parametern betreibe, verbrauchen 99% der Zeit während des Trainings weniger als 200 MB GPU-RAM. Ab und zu steigt der Speicherbedarf jedoch auf etwa 1,3 GB. Es ist sicher anzunehmen, dass es diese Spitzen sind, die meine Probleme verursachen. Ich habe diese Spitzen noch nie in anderen Frameworks gesehen, aber sie könnten aus gutem Grund da sein? Wenn jemand weiß, was sie verursacht, und wenn es einen Weg gibt, um sie zu vermeiden, läuten Sie bitte ein!
memorytensorflowkerastheano
31
Martin

Es ist ein sehr häufiger Fehler zu vergessen, dass die Aktivierungen und Farbverläufe nicht nur die Parameter, sondern auch den vram-Wert beanspruchen, was den Speicherbedarf erheblich erhöht. Die Backprob-Berechnungen selbst machen es so, dass die Trainingsphase das VRAM der Vorwärts-/Inferenznutzung des neuronalen Netzes fast verdoppelt.

Beim Erstellen des Netzwerks werden also nur die Parameter zugewiesen. Wenn das Training jedoch beginnt, werden die Aktivierungen (mal jedes Minibatch) sowie die Backprop-Berechnungen zugewiesen, was die Speicherauslastung erhöht.

15
Jules G.M.

Sowohl Theano als auch Tensorflow erweitern den symbolischen Graphen, der erstellt wird, obwohl beide unterschiedlich sind. 

Um zu analysieren, wie der Speicherverbrauch abläuft, können Sie mit einem kleineren Modell beginnen und es vergrößern, um den entsprechenden Speicherzuwachs zu sehen. Ebenso können Sie den batch_size vergrößern, um das entsprechende Wachstum im Speicher anzuzeigen.

Hier ist ein Code-Snippet zum Erhöhen von batch_size basierend auf Ihrem ursprünglichen Code:

from scipy import misc
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation, Convolution2D, MaxPooling2D, Reshape, Flatten, ZeroPadding2D, Dropout
import os
import matplotlib.pyplot as plt


def gpu_memory():
    out = os.popen("nvidia-smi").read()
    ret = '0MiB'
    for item in out.split("\n"):
        if str(os.getpid()) in item and 'python' in item:
            ret = item.strip().split(' ')[-2]
    return float(ret[:-3])

gpu_mem = []
gpu_mem.append(gpu_memory())

model = Sequential()
model.add(Convolution2D(100, 3, 3, border_mode='same', input_shape=(16,16,1)))
model.add(Convolution2D(256, 3, 3, border_mode='same'))
model.add(Convolution2D(32, 3, 3, border_mode='same'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Flatten())
model.add(Dense(4))
model.add(Dense(1))

model.summary()
gpu_mem.append(gpu_memory())

model.compile(optimizer='sgd',
              loss='mse', 
              metrics=['accuracy'])
gpu_mem.append(gpu_memory())


batches = []
n_batches = 20
batch_size = 1
for ibatch in range(n_batches):
    batch_size = (ibatch+1)*10
    batches.append(batch_size)
    x = np.random.Rand(batch_size, 16,16,1)
    y = np.random.Rand(batch_size, 1)
    print y.shape

    model.train_on_batch(x, y)         
    print("Trained one iteration")

    gpu_mem.append(gpu_memory())

fig = plt.figure()
plt.plot([-100, -50, 0]+batches, gpu_mem)
plt.show()

Außerdem erhöht Tensorflow den gesamten verfügbaren GPU-Speicher. Um das zu beenden, müssen Sie config.gpu_options.allow_growth = True in get_session() hinzufügen.

# keras/backend/tensorflow_backend.py
def get_session():
    global _SESSION
    if tf.get_default_session() is not None:
        session = tf.get_default_session()
    else:
        if _SESSION is None:
            if not os.environ.get('OMP_NUM_THREADS'):
                config = tf.ConfigProto(allow_soft_placement=True,
                    )
            else:
                nb_thread = int(os.environ.get('OMP_NUM_THREADS'))
                config = tf.ConfigProto(intra_op_parallelism_threads=nb_thread,
                                        allow_soft_placement=True)
            config.gpu_options.allow_growth = True
            _SESSION = tf.Session(config=config)
        session = _SESSION
    if not _MANUAL_VAR_INIT:
        _initialize_variables()
    return session

Wenn Sie nun das vorhergehende Snippet ausführen, erhalten Sie folgende Diagramme:

Theano:  Theano Tensorflow:  Tenserflow

Theano: Nach model.compile(), was auch immer der Speicher benötigt wird, verdoppelt sich das während des Trainings fast. Dies liegt daran, dass Theano den symbolischen Graphen erweitert, um eine Rückwärtsausbreitung durchzuführen, und dass jeder Tensor einen entsprechenden Tensor benötigt, um den Rückwärtsfluss von Gradienten zu erreichen. Der Speicherbedarf scheint nicht mit batch_size zu wachsen, und dies ist für mich unerwartet, da die Platzhaltergröße zunehmen sollte, um den Datenzufluss von CPU-> GPU aufzunehmen.

Tensorflow: Auch nach model.compile() wird kein GPU-Speicher zugewiesen, da Keras bis zu diesem Zeitpunkt get_session() nicht aufruft, der tatsächlich _initialize_variables() aufruft. Tensorflow scheint den Speicher in Brocken nach Geschwindigkeit zu verlagern, so dass der Speicher nicht linear mit batch_size wächst.

Trotz alledem scheint Tensorflow speicherhungrig zu sein, aber für große Graphen ist es sehr schnell. Theano hingegen ist sehr gpu-speichereffizient, benötigt jedoch viel Zeit, um den Graphen zu Beginn des Trainings zu initialisieren. Danach ist es auch ziemlich schnell. 

12
indraforyou

200M Params für 2 GB GPU sind zu viel. Auch Ihre Architektur ist nicht effizient, lokale Engpässe zu verwenden, wird effizienter sein. Sie sollten auch von einem kleinen Modell zu einem großen Modell wechseln und nicht rückwärts. Im Moment haben Sie eine Eingabe von 16x16 Das Netzwerk wird "mit Nullen aufgefüllt" und basiert nicht auf Eingabefunktionen. Ihre Modellebenen hängen von Ihrer Eingabe ab. Sie können also nicht beliebig viele Ebenen und Größen festlegen. Sie müssen zählen, wie viele Daten an die einzelnen Objekte weitergegeben werden Wenn Sie verstehen, warum dies so ist, würde ich Ihnen empfehlen, diesen kostenlosen Kurs zu sehen http://cs231n.github.io

0
Andrey Nikishaev