J'ai deux questions:Comment GPU/multi-GPU Tensorflow alloue-t-il de la mémoire?
(1) Comment Tensorflow alloue-t-il la mémoire GPU lors de l'utilisation d'un seul GPU? J'ai une mise en œuvre de convolution 2d comme celui-ci (à l'échelle mondiale en utilisant le GPU):
def _conv(self, name, x, filter_size, in_filters, out_filters, strides):
with tf.variable_scope(name):
n = filter_size * filter_size * out_filters
kernel = tf.get_variable(
'', [filter_size, filter_size, in_filters, out_filters], tf.float32,
initializer=tf.random_normal_initializer(stddev=np.sqrt(2.0/n)),
)
return tf.nn.conv2d(x, kernel, strides, padding='SAME')
# another option
# x = tf.nn.conv2d(x, kernel, strides, padding='SAME')
# return x
L'autre option dans les commentaires fait la même opération, mais ont ajouté une nouvelle variable x. Dans ce cas, TF alloue-t-il plus de mémoire GPU?
(2) lors de l'utilisation de plusieurs GPU. Je voudrais utiliser list pour rassembler les résultats de plusieurs GPU. La mise en œuvre est la suivante:
def _conv(self, name, input, filter_size, in_filters, out_filters, strides, trainable=True):
assert type(input) is list
assert len(input) == FLAGS.gpu_num
n = filter_size * filter_size * out_filters
output = []
for i in range(len(input)):
with tf.device('/gpu:%d' % i):
with tf.variable_scope(name, reuse=i > 0):
kernel = tf.get_variable(
'', [filter_size, filter_size, in_filters, out_filters], tf.float32,
initializer=tf.random_normal_initializer(stddev=np.sqrt(2.0/n))
)
output.append(tf.nn.conv2d(input[i], kernel, strides, padding='SAME'))
return output
aura-t-TF allouer plus de mémoire en raison de l'utilisation de list? Est-ce que output (le list) est connecté à un périphérique GPU? J'ai ce genre de questions parce que lorsque j'utilise deux GPU pour former les CNN avec cette implémentation, le programme utilise beaucoup plus de mémoire GPU que lorsqu'il utilise un GPU. Je pense qu'il y a quelque chose que j'ai manqué ou mal compris. Utilisation de ce code pour vérifier chaque tenseur et le périphérique connecté.
Avez-vous regardé la page des options GPU sur le [site web de Tensorflow ici] (https://www.tensorflow.org/tutorials/using_gpu#allowing_gpu_memory_growth). Si je comprends bien, Tensorflow a tendance à saisir autant de mémoire GPU que possible et le gérera ensuite lui-même. Cela peut être légèrement frustrant lorsque vous essayez de surveiller rapidement avec nvidia SMI. Cependant, vous pouvez autoriser la croissance du GPU, ce qui signifie qu'il ne prend que ce dont il a besoin et peut continuer à en prendre plus. Vous pouvez configurer TF pour pouvoir seulement prendre une fraction de la mémoire aussi. Voyez si cette page liée répond à vos questions. – JCooke
Merci pour votre commentaire mais ce lien n'a pas répondu à mes questions. Dans la mémoire GPU saisie par TF, il y a une partie de la mémoire "nécessaire" et une autre partie pour les gains de performance. Lorsque la mémoire du GPU n'est pas suffisante, TF alloue uniquement la mémoire nécessaire (peut-être y a-t-il quelque chose de plus complexe derrière et c'est pourquoi nous voyons des avertissements de manque de mémoire mais pas d'échec). Le souvenir mentionné dans ma question signifie cette mémoire nécessaire, pas la mémoire saisie par TF. – Seven
Ahhh ok je vois. Donc, vous êtes plus intéressé par la façon dont la mémoire est acquise et pour quoi faire? J'ai peur de ne pas être assez qualifié pour vous donner une réponse raisonnable. J'espère que quelqu'un d'autre peut vous aider! – JCooke