在循环中使用Keras时，如何防止内存使用爆炸

Question

我的问题似乎很普遍

我正在使用普通的策略梯度方法进行强化学习。环境只是一个简单的单周期游戏，其中状态和动作空间是实线。代理是一个具有两个输出头的神经网络，我使用Keras的密集层手动构建，例如，我的第一个隐藏层是

layers.Dense(NH[0], activation ="relu", \
             kernel_initializer=initializers.GlorotNormal())(inputs)

其中NH包含隐藏层的神经元数量列表。输出是高斯策略的平均值和标准偏差。我不知道这部分是否重要，但我还是包括了它

环境很简单：状态是一个正态变量，动作是一些实标量，只有一个周期。我多次运行该策略，收集生成的批处理，并使用tf.GradientTape（）中的工具根据自定义丢失函数更新网络。我可以将代码运行数千次以查看算法的学习情况

真正的问题是，我想多次运行学习过程，每次随机重新初始化网络权重，以获得奖励历史的分布，但如果我在一个循环中运行所有这些，计算机会快速冻结。显然，这是Keras和Tensorflow的一个非常普遍的问题，人们已经抱怨了很多年，但这仍然是一个问题。。。现在，我已经尝试了通常的解决方案Here人们建议在循环结束时添加如下内容，这样在我重新初始化网络之前，我就可以一清二楚了

keras.backend.clear_session()
gc.collect()
del actor

这并不能解决问题。然后，我看到有人给出了一个更进一步的函数

def reset_keras(model):

# Clear model, if possible
try:
    del model
except:
    pass

# Garbage collection
gc.collect()

# Clear and close tensorflow session
session = K.get_session() # Get session
K.clear_session()         # Clear session
session.close()           # Close session

# Reset all tensorflow graphs
tf.compat.v1.reset_default_graph()

这也不管用。我还试着按照前三个命令的顺序移动，但也不起作用

有人知道如何解决这个问题吗？了解发生这种情况的原因也很有用。我还想知道如何在这里分析内存使用情况，这样我就不必等4个小时才知道新的解决方案会使计算机再次冻结

事实上，如果你有一个最小的工作示例，你可以证明代码不会导致内存使用爆炸性增长，我会非常愿意从头开始重新编写整个该死的代码来停止问题。顺便提一下，为什么开发人员没有解决这个问题？这是我在R和Python上遇到的唯一一个包

编辑 正如所问，我提供了一个关于这个问题的最简单的工作示例。我编了一个快速的游戏：这是一个移动的目标，其中的最佳行动是玩一些状态值的倍数，产生0的奖励

我写下了一个演员类，并使用了一个简单的线性回归作为一个可能会被关闭的批评家。如果你看一下内存使用情况，它正在攀升。。。那个游戏不会使我的电脑崩溃，除非我玩得更多，但它表明内存使用量增加了

import numpy      as np
import psutil

import tensorflow                    as tf
import tensorflow.keras              as keras
import tensorflow.keras.layers       as layers
import tensorflow.keras.initializers as initializers

import tensorflow.python.keras.backend as kb
import matplotlib.pyplot as plt

BATCH    = 10
MC_DRAWS = 2000
M        = 10

# Training options
LR = 0.01
def display_memory():
    print( f'{round(psutil.virtual_memory().used/2**30, 2)} GB' )

class Actor:

    def __init__(self):
        self.nn    = self.make_actor()
        self.batch = BATCH
        self.opt   = keras.optimizers.Adam( learning_rate = LR )

    def make_actor(self):
        inputs = layers.Input( shape=(1) )
        hidden = layers.Dense(5, activation='relu', 
                              kernel_initializer=initializers.GlorotNormal() )(inputs)
        mu     = layers.Dense(1, activation='linear',
                          kernel_initializer=initializers.GlorotNormal() )(hidden)
        sigma  = layers.Dense(1, activation='softplus',
                          kernel_initializer=initializers.GlorotNormal() )(hidden)
    
        nn  = keras.Model(inputs=inputs, outputs=[mu, sigma])
    
        return nn

    def update_weights(self, state, action, reward):

        # Get proper format
        state  = tf.constant(state,  dtype='float32', shape=(self.batch,1))
        action = tf.constant(action, dtype='float32', shape=(self.batch,1))
        reward = tf.constant(reward, dtype='float32', shape=(self.batch,1))
    
        # Update Policy Network Parameters
        with tf.GradientTape() as tape:   
            # Compute Gaussian loss
            loss_value = self.custom_loss(state, action, reward)
            loss_value = tf.math.reduce_mean( loss_value, keepdims=True )
        
            # Compute gradients
            grads = tape.gradient(loss_value, self.nn.trainable_variables)
 
            # Apply gradients to update network weights
            self.opt.apply_gradients(zip(grads, self.nn.trainable_variables))
        
    def custom_loss(self, state, action, reward):
        # Obtain mean and standard deviation
        nn_mu, nn_sigma = self.nn(state)
    
        # Gaussian pdf
        pdf_value = tf.exp(-0.5 *((action - nn_mu) / (nn_sigma))**2) *\
                    1/(nn_sigma*tf.sqrt(2 *np.pi))
                    
        # Log probabilities
        log_prob  = tf.math.log( pdf_value + 1e-5 )
    
        # Compute loss
        loss_actor = -reward * log_prob
    
        return loss_actor

class moving_target_game:

    def __init__(self):
        self.action_range = [-np.inf, np.inf]
        self.state_range  = [1, 2]
        self.reward_range = [-np.inf, 0]

    def draw(self):
        return np.random.ranint(low  = self.state_range[0],
                            high = self.state_range[1])

    def get_reward(self, action, state):
        return -(5*state - action)**2

class Critic:  
    def __init__(self):
    
        self.order      = 3
        self.projection = None

    def predict(self, state, reward):
    
        # Enforce proper format
        x = np.array( state ).reshape(-1,1)
        y = np.array( reward ).reshape(-1,1)
    
        # Make regression matrix
        X = np.ones( shape = x.shape )
        for i in range( self.order ):
            X = np.hstack( (X, x**(i+1)) )
        
        # Prediction
        xt = x.transpose()
        P  = x @ np.linalg.inv( xt @ x  ) @ xt
        Py = P @ y
    
        self.projection = P
    
        return Py

#%% Moving Target Game with Actor and Actor-Critic

do_actor_critic = True

display_memory()

history    = np.zeros( shape=(MC_DRAWS, M) )
env        = moving_target_game()

for m in range(M):

    # New Actor Network
    actor  = Actor()

    if do_actor_critic:
        critic = Critic()

    for i in range(MC_DRAWS):
    
        state_tape  = []
        action_tape = []
        reward_tape = []
    
        for j in range(BATCH):
        
            # Draw state
            state = env.draw()
            s     = tf.constant([state], dtype='float32')
        
            # Take action
            mu, sigma = actor.nn( s )
            a         = tf.random.normal([1], mean=mu, stddev=sigma)
        
            # Reward
            r = env.get_reward( state, a )
        
            # Collect results
            action_tape.append( float(a)     )
            reward_tape.append( float(r)     )
            state_tape.append(  float(state) )
        
            del (s, a, mu, sigma)
    
        # Update network weights
        history[i,m] = np.mean( reward_tape )
    
        if do_actor_critic:
            # Update critic
            value = critic.predict(state_tape, reward_tape)
            # Benchmark reward
            mod = np.array(reward_tape).reshape(-1,1) - value
            # Update actor
            actor.update_weights(state_tape, action_tape, mod)
        else:
            actor.update_weights(state_tape, action_tape, reward_tape)

    del actor
    kb.clear_session()

    if do_actor_critic:
        del critic
    
    print( f'Average Reward on last: {np.mean(reward_tape)} ' )
    display_memory()

plt.plot( history )

Answer 1

您可以通过调用来尝试重新启动后端

reset_tensorflow_keras_backend()

在每个模型估计之后，函数定义如下：

def reset_tensorflow_keras_backend():
    # to be further investigated, but this seems to be enough
    import tensorflow as tf
    import tensorflow.keras as keras
    tf.keras.backend.clear_session()
    tf.reset_default_graph()
    _ = gc.collect()