python - 抑制 keras 消息：（常量）：/job/localhost/
问题描述
我在 keras 中创建了一个自定义层，并对其进行测试会打印出大量消息，例如：
Const_4340: (Const): /job:localhost/replica:0/task:0/device:CPU:0
Const_4341: (Const): /job:localhost/replica:0/task:0/device:CPU:0
Const_4342: (Const): /job:localhost/replica:0/task:0/device:CPU:0
....
或者
input_112: (Placeholder): /job:localhost/replica:0/task:0/device:CPU:0
noise0_74/random_uniform/shape: (Const): /job:localhost/replica:0/task:0/device:CPU:0
...
noise0_74/Const_3: (Const): /job:localhost/replica:0/task:0/device:CPU:0
noisy_layer_108/random_uniform/shape: (Const): /job:localhost/replica:0/task:0/device:CPU:0
noisy_layer_108/random_uniform/min: (Const): /job:localhost/replica:0/task:0/device:CPU:0
noisy_layer_108/random_uniform/max: (Const): /job:localhost/replica:0/task:0/device:CPU:0
.....
Adam_89/iterations/Initializer/initial_value: (Const): /job:localhost/replica:0/task:0/device:CPU:0
Adam_89/learning_rate/Initializer/initial_value: (Const): /job:localhost/replica:0/task:0/device:CPU:0
Adam_89/beta_1/Initializer/initial_value: (Const): /job:localhost/replica:0/task:0/device:CPU:0
Adam_89/beta_2/Initializer/initial_value: (Const): /job:localhost/replica:0/task:0/device:CPU:0
Adam_89/decay/Initializer/initial_value: (Const): /job:localhost/replica:0/task:0/device:CPU:0
...
使其无法调试。他们的意思是什么？我如何阅读它们？有没有办法压制他们？或者至少有一个解决方法？
编辑：这里有更多代码：主脚本：
from noisy_net import *
import os
os.environ['TF_CPP_MIN_VLOG_LEVEL'] = '3'
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
from dqn_utilities import *
import logging
cwd = os.getcwd()
path = cwd+"/models/space_invaders/"
os.makedirs(path, exist_ok=True)
def save_model(agent):
p = os.path.join(path, agent.name +"checkpoint.h5")
agent.model.save(p)
print("Model Saved")
return
Agent = Agent_NoisyNet()
score_history = []
state = env.reset()
episode_reward = 0
episode = 0
try:
for step in range(TOTAL_TR_STEPS):
if step % 1000 == 0:
print("Step no: " + str(step))
action = Agent.predict_action(state)
next_state, reward, done, _ = env.step(action)
episode_reward += reward
experience = (state, action, reward, next_state, done)
Agent.memory.append(experience)
if RENDER==True:
env.render()
_ = Agent.train()
Agent._update_target()
state = next_state
if done or step == TOTAL_TR_STEPS-1:
score_history.append(episode_reward)
state = env.reset()
episode+=1
avg_score = np.mean(score_history[-20:])
print(f"At step: {step}")
print('episode ', episode, 'score %.2f average score %2f' % \
(episode_reward, avg_score))
score_history.append(episode_reward)
episode_reward = 0
except KeyboardInterrupt:
raise
env.close()
- 制作网络的脚本：
from Memory import ReplayMemory
from params import *
from keras.layers import Conv2D, Flatten, Input
from keras.models import Model
from keras.optimizers import Adam
import numpy as np
from NoisyLayer import NoisyLayer
import tensorflow as tf
from time import time
class Agent_NoisyNet():
def __init__(self, input_shape=INPUT_SHAPE, action_size=ACTION_SPACE_SIZE,
memory_size=MEMORY_SIZE, duel_type=DUEL_TYPE, double=DOUBLE,
noise_type=NOISE_TYPE, conv_params=CONV_PARAMS, dense_params=DENSE_PARAMS,
gamma=GAMMA, batch_size=MINIBATCH_SIZE, learning_rate=LEARNING_RATE,
name=NAME):
self.state_shape = input_shape
self.action_size = action_size
self.learning_rate = learning_rate
self.memory_size = memory_size
self.batch_size = batch_size
self.gamma = gamma
self.duel_type = duel_type
self.double = double
self.noise_type = noise_type
self.model = self._create_network(conv_params, dense_params)
self.target_model = self._create_network(conv_params, dense_params)
self._update_target()
self.memory = ReplayMemory(self.memory_size)
self.name = name
def total_update(self):
self._update_target()
def _update_target(self):
self.target_model.set_weights((self.model.get_weights()))
def _sample_noise_model(self, model):
name = 'noise'
noise_layers = [model.get_layer(index=index)\
for index in range(len(model.layers))\
if name in model.get_layer(index=index).name]
for layer in noise_layers:
layer.set_noise()
def _create_network(self, conv_params, dense_params):
inputs = Input(shape=self.state_shape)
out = inputs
for index, units in enumerate(dense_params):
out = NoisyLayer(units=units, name=f'noise{index}', activation='relu')(out)
outputs = NoisyLayer(units=self.action_size)(out)
model = Model(inputs=inputs, outputs=outputs)
opt = Adam(lr=self.learning_rate)
model.compile(opt, loss='mean_squared_error')
return model
def train(self):
if self.memory.size < MIN_REPLAY_MEMORY_SIZE:
return None
self._sample_noise_model(self.model)
self._sample_noise_model(self.target_model)
states, actions, rewards, next_states, dones = \
self.memory.sample(self.batch_size)
p_Qs = self.model.predict(states)
t_Qs = np.copy(p_Qs)
index_range = np.arange(states.shape[0])
t_Qs[index_range, actions] = self.bootstrap(rewards, next_states, dones)
history = self.model.fit(states, t_Qs, batch_size=self.batch_size)
return history.history["loss"]
def bootstrap(self, rewards, next_states, dones):
Qs = self.model.predict(next_states)
actions = np.argmax(Qs, axis=-1)
rows = np.arange(Qs.shape[0])
return rewards + self.gamma * Qs[rows,actions]*(1-dones)
def predict_action(self, state):
self._sample_noise_model(self.model)
state = np.expand_dims(state, axis=0)
Qs = np.squeeze(self.model.predict(state))
action = np.argmax(Qs)
return action
- 自定义图层类：
from params import *
from keras.layers import Layer, Multiply, Add, Dot, add, Dense
import keras.backend as K
import numpy as np
from itertools import product
from keras.activations import relu
from time import time
import tensorflow as tf
from keras import initializers
from math import sqrt
class NoisyLayer(Dense):
def __init__(self, units, **kwargs):
self.units = units # output_dimension
self.noise_type = 'factorised'
super(NoisyLayer, self).__init__(units,**kwargs)
def build(self, input_shape):
self.state_shape = input_shape
W = 1/sqrt(input_shape[1])
B = SIGMA_0/sqrt(input_shape[1])
self.weight_mu = self.add_weight(name='weight_mu',
shape=(input_shape[1], self.units),
initializer=initializers.uniform(-W, W),
trainable=True)
self.weight_sigma = self.add_weight(name='weight_sigma',
shape=(input_shape[1], self.units),
initializer=initializers.Constant(B),
trainable=True)
self.bias_mu = self.add_weight(name='bias_mu',
shape=(self.units,),
initializer=initializers.uniform(-W, W),
trainable=True)
self.bias_sigma = self.add_weight(name='bias_sigma',
shape=(self.units,),
initializer=initializers.Constant(B),
trainable=True)
self.eps_w, self.eps_b = None, None
self.set_noise()
self.bias = None
self.built = True
def call(self, input_tensor):
WeightedInp = K.dot(input_tensor,
self.weight_mu + self.weight_sigma * self.eps_w)
bias = self.bias_mu + self.bias_sigma * self.eps_b
return self.activation(K.bias_add(WeightedInp, bias))
def compute_output_shape(self, input_shape):
return (input_shape[0], self.units)
def _sample_noise(self):
t1= time()
if self.noise_type == 'factorised':
eps_w_temp = np.random.normal(0,1, size=(max(self.state_shape[1], self.units)))
eps_b = np.random.normal(0,1, size=self.units)
eps_w = np.zeros((self.state_shape[1], self.units))
f = lambda x : self._factor_function(x)
for i, j in product(range(self.units),range(self.state_shape[1])):
eps_w[j][i] = f(eps_b[i])*f(eps_w_temp[j])
eps_b = self._factor_function(eps_b)
else:
raise Exception("No known type for noisy layer, from _get_epsilon")
print("*******************************************")
print("Elapsed time for sample_noise: ",time()-t1)
print("*******************************************")
return eps_w, eps_b
def set_noise(self):
eps_w, eps_b = self._sample_noise()
self.eps_w = K.constant(eps_w)
self.eps_b = K.constant(eps_b)
def _factor_function(self, x):
return np.sign(x)*np.sqrt(np.abs(x))
--还有一堆参数和其他类：
import gym
import numpy as np
STACK_SIZE = 4
max_width = 84
max_height = 84
INPUT_SHAPE = [max_height, max_width, STACK_SIZE]
GAME = "CartPole-v0"
env = gym.make(GAME)
INPUT_SHAPE = env.observation_space.shape
ACTION_SPACE_SIZE = env.action_space.n
ACTION_SPACE = np.array(np.identity(ACTION_SPACE_SIZE, dtype=int).tolist())
LEARNING_RATE = 0.00025 # or 0.000001
GAMMA = 0.99
INITIAL_NO_OP = 30
UPDATE_TARGET_STEPS = 10000
TOTAL_TR_STEPS = 100000#50000000
MEMORY_SIZE = 100000
UPDATE_FREQ = 3
MINIBATCH_SIZE = 32
K_ = 3 # do the same predicted action every k_ steps
# EPSILON PARAMS
E_START = 1
E_STOP = 0.1 # over 1 mil steps, linearly
END_EPS_DECAY = 1000000
MIN_REPLAY_MEMORY_SIZE = 1000
RENDER = False
CONV_PARAMS = [] #for simple testing, without pixels
#CONV_PARAMS = [(32, 8, 4), (64, 4, 2), (64, 3, 1)]
DENSE_PARAMS = [512]
#DENSE_PARAMS = [10]
VALUE_FC = 512
ADVANTAGE_FC = 512
DUEL_TYPE = "ave" # or "max" or 'naive'
DOUBLE = True # implement double or not boostrap method
NOISE_TYPE = 'factorised' # 'independent' # or 'factorised'
SIGMA_0 = 0.15
NAME = "NoisyNets_DQN"
......
import random
import numpy as np
MINIBATCH_SIZE = 64
class ReplayMemory():
def __init__(self, max_size=10000):
self.buffer = [None] * max_size
self.max_size = max_size
self.index = 0
self.size = 0
def append(self, obj):
self.buffer[self.index] = obj
self.size = min(self.size + 1, self.max_size)
self.index = (self.index + 1) % self.max_size
def sample(self, batch_size=MINIBATCH_SIZE):
if self.size < batch_size:
batch_size = self.size
indices = random.sample(range(self.size), batch_size)
exps = [self.buffer[i] for i in indices]
states, actions, rewards, next_states, dones = zip(*exps)
return [np.array(e) for e in [states, actions, rewards, next_states, dones]]
解决方案
推荐阅读
- .net - 数据库连接（无法打开登录请求的数据库“VRM”。）
- laravel - 如何检查新的年龄范围是否重叠？
- angular - Ionic 3 侧边菜单在按钮单击时关闭
- excel - 删除 Excel 中的所有注释
- c++ - 为什么 std::vector::operator= 过度分配内存？
- android - 我如何解析这个请求的响应？
- php - 如何在 nginx 服务器中使用 php 创建永久链接？
- r - 尝试按时间对数据进行分组并对每个月的值求和
- tensorflow - 与初学者代码相比，使用 TensorFlow 2.0 专家代码的训练结果更差
- c - 在 C 中将十进制转换为十六进制并打印数组