Compartilhamento de tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Prefácio

Ao usar o TensorFlow 2 para treinamento ou previsão, o gerenciamento adequado da memória da GPU é crucial. A falha em gerenciar e liberar efetivamente a memória da GPU pode levar a vazamentos de memória, o que pode afetar tarefas de computação subsequentes. Neste artigo, exploraremos várias maneiras de liberar efetivamente a memória da GPU, tanto de forma convencional quanto quando uma tarefa é forçada a encerrar.

1. Métodos convencionais de gerenciamento de memória de vídeo

1. Redefinir imagem padrão

Cada vez que você executa um novo gráfico do TensorFlow, chamando tf.keras.backend.clear_session() para limpar o gráfico atual do TensorFlow e liberar memória.

import tensorflow as tf
tf.keras.backend.clear_session()

2. Limite o uso de memória GPU

Ao definir a política de uso de memória de vídeo, você pode evitar que a memória de vídeo da GPU fique muito ocupada.

• Aumente o uso de memória de vídeo sob demanda：

  import tensorflow as tf
  
  gpus = tf.config.experimental.list_physical_devices('GPU')
  if gpus:
      try:
          for gpu in gpus:
              tf.config.experimental.set_memory_growth(gpu, True)
      except RuntimeError as e:
          print(e)
  

• Limite o uso de memória de vídeo：

  import tensorflow as tf
  
  gpus = tf.config.experimental.list_physical_devices('GPU')
  if gpus:
      try:
          tf.config.experimental.set_virtual_device_configuration(
              gpus[0],
              [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=4096)])  # 限制为 4096 MB
      except RuntimeError as e:
          print(e)
  

3. Libere manualmente a memória GPU

Após o treinamento ou previsão, use gc O módulo e as funções de gerenciamento de memória do TensorFlow liberam manualmente a memória da GPU.

import tensorflow as tf
import gc

tf.keras.backend.clear_session()
gc.collect()

4. Uso with contexto de gerenciamento de declarações

Usado em código de treinamento ou previsão with instrução para gerenciar automaticamente a liberação de recursos.

import tensorflow as tf

def train_model():
    with tf.device('/GPU:0'):
        model = tf.keras.models.Sequential([
            tf.keras.layers.Dense(64, activation='relu', input_shape=(32,)),
            tf.keras.layers.Dense(10, activation='softmax')
        ])
        model.compile(optimizer='adam', loss='categorical_crossentropy')
        # 假设 X_train 和 y_train 是训练数据
        model.fit(X_train, y_train, epochs=10)

train_model()

2. Gerenciamento de memória de vídeo ao encerrar tarefas à força

Às vezes, precisamos encerrar à força a tarefa do TensorFlow para liberar memória da GPU.Neste caso, use o Pythonmultiprocessing módulo ouos Os módulos podem gerenciar recursos com eficiência.

1. Uso multiprocessing módulo

Ao executar tarefas do TensorFlow em processos separados, todo o processo pode ser eliminado para liberar memória de vídeo quando necessário.

import multiprocessing as mp
import tensorflow as tf
import time

def train_model():
    model = tf.keras.models.Sequential([
        tf.keras.layers.Dense(64, activation='relu', input_shape=(32,)),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    model.compile(optimizer='adam', loss='categorical_crossentropy')
    # 假设 X_train 和 y_train 是训练数据
    model.fit(X_train, y_train, epochs=10)

if __name__ == '__main__':
    p = mp.Process(target=train_model)
    p.start()
    time.sleep(60)  # 例如，等待60秒
    p.terminate()
    p.join()  # 等待进程完全终止

2. Uso os módulo encerra processo

Obtendo o ID do processo e usando os Módulo que pode encerrar à força o processo do TensorFlow.

import os
import signal
import tensorflow as tf
import multiprocessing as mp

def train_model():
    pid = os.getpid()
    with open('pid.txt', 'w') as f:
        f.write(str(pid))

    model = tf.keras.models.Sequential([
        tf.keras.layers.Dense(64, activation='relu', input_shape=(32,)),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    model.compile(optimizer='adam', loss='categorical_crossentropy')
    # 假设 X_train 和 y_train 是训练数据
    model.fit(X_train, y_train, epochs=10)

if __name__ == '__main__':
    p = mp.Process(target=train_model)
    p.start()
    time.sleep(60)  # 例如，等待60秒
    with open('pid.txt', 'r') as f:
        pid = int(f.read())
    os.kill(pid, signal.SIGKILL)
    p.join()

Resumir

Ao usar o TensorFlow 2 para treinamento ou previsão, é crucial gerenciar e liberar adequadamente a memória da GPU.Ao redefinir o mapa padrão, limitar o uso da memória de vídeo, liberar manualmente a memória de vídeo e usarwith O contexto de gerenciamento de instruções pode efetivamente evitar problemas de vazamento de memória.Quando você precisar encerrar uma tarefa à força, usemultiprocessing módulos eos O módulo pode garantir que a memória de vídeo seja liberada a tempo. Através destes métodos, a utilização eficiente dos recursos da GPU pode ser garantida e a estabilidade e o desempenho das tarefas de computação podem ser melhorados.