����λ�ã���ҳ > �����̳� > �̳� > ǿ��ѧϰ�ʼ�֮��ACE:Off-PolicyActor-CriticwithCausality-AwareEntropyRegularization��
2024��ICML���£�ACE:Off-PolicyActor-CriticwithCausality-AwareEntropyRegularization����
���������廪��Ŀ�����ڲ�ʿʦ��д�����£���Ŀ��ҳΪ ACE (ace-rl.github.io) ����2024��7�·�����ICML�ڿ�
��Ϊ������ڣ���ʵֻ���ң���Ҫ���㿪ʼ��һ�������Ŀ��ǰ��ļ�ƪ���¶����̵�
������Ϊǿ��ѧϰ�ʼǵ�5ƪ
���ij��à¼ï¿½ï¿½2024.10.5�����������ʱ�䣬�����ˣ�ǰ��д������������
CSDN��ҳ�� https://blog.csdn.net/rvdgdsva
����԰��ҳ�� https://www.cnblogs.com/hassle
����԰�������ӣ�
��ƪǿ��ѧϰ������Ҫ������һ����Ϊ ACE ���㷨����������Ϊ Off-Policy Actor-Critic with Causality-Aware Entropy Regularization ����ͨ�����������ϵ������������������������ģ���ڲ�ͬ����ά���ϵIJ�ƽ��̽�����⣬ּ�ڸĽ�ǿ��ѧϰ��ע��1����̽��Ч�ʺ�����Ч�ʵ����⣬�ر����ڸ�ά���������������еı��֡�
��ע��1��: ǿ��ѧϰ������һƪ�͹���
��policy��ע��2��ѧϰ�����У���ͬÔʼ��Ϊ�IJ�ͬ���屻��ǰ��model-free RL �㷨�����ӡ�������һ���⣬����̽���˲�ͬ�ж�ά�Ⱥͽ���֮��������ϵ��������ѵ�������и���Ôʼ��Ϊ����Ҫ�ԡ�����������һ�������ϵ��֪�ء�ע��3���causality-aware entropy term������������Ч��ʶ�����ȿ��Ǿ��и�DZ��Ӱ�����Ϊ����ʵ�ָ�Ч��̽�������⣬Ϊ�˷�ֹ���ȹ�ע�ض���Ôʼ��Ϊ�����Ƿ������ݶ���������gradientdormancyphenomenon�������������������������û��ƣ��Խ�һ����ǿ���Ƿ�������Ч�ԡ�����ģ��RL������ȣ�����������㷨 ACE :Off-policy A ctor-criticwith C ausality-aware E ntropyregularization���ڿ�Խ7�����29�ֲ�ͬ����������������ʾ��ʵ���Ե��������ƣ���ǿ�������Ƿ�������Ч�ԡ��๦���Ժ͸�Ч������Ч�ʡ� ��׼���Խ������Ƶ����https://ace-rl.github.io/�ϻ�á�
��ע��2��: ǿ��ѧϰ�㷨��on-policy��off-policy
��ע��3��: ����� RL����Soft Q-Learning��SAC - ֪��
��1�� �����ϵ���� ��ͨ�������������-�����ṹģ�ͣ�������ͬ����ά�ȣ���Ôʼ��Ϊ���Խ�����Ӱ���С����Ϊ�����Ȩ�ء�������ЩȨ�ط�ӳ��ÿ������ά���ڲ�ͬѧϰ�׶ε������Ҫ�ԡ�
���������Ľ���Ô���ǣ�����һ���òµ¥µï¿½ï¿½ï¿½ï¿½Ó£ï¿½Ò»ï¿½ï¿½ï¿½ï¿½Ðµï¿½ï¿½ï¿½ï¿½ï¿½Ó¦ï¿½ï¿½Ñ§Ï°ï¿½ï¿½ï¿½ï¿½ï¿½Ö±Û²ï¿½×¥×¡ï¿½ï¿½ï¿½å£¬È»ï¿½ï¿½×¢ï¿½ï¿½ï¿½ï¿½×ªï¿½Æµï¿½Ñ§Ï°ï¿½Ö±Û³ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ä¿ï¿½ï¿½ï¿½ï¿½Ë¶ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ï¡ï¿½ï¿½ï¿½Ë£ï¿½ï¿½Ú²ï¿½ï¿½ï¿½Ñ§Ï°ï¿½Ä²ï¿½Í¬ï¿½×¶ï¿½Ç¿ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Òªï¿½ï¿½Ôʼ��Ϊ��̽���� ������Ҫ�ġ���̽�������п����ע����Ôʼ��Ϊ�����Լ�����������ÿ���׶ζԻ���Ôʼ��Ϊ��ѧϰ���Ӷ�������������˶������Ч�ʡ�
�˴��ɹ�ѧϰ�����ϣ�
��2�� ��������� ���������ǿ��ѧϰ��ܵĻ����ϣ���SAC�㷨���������� �����Ȩ���������� ���봫ͳ�����ò»¯²ï¿½Í¬ï¿½ï¿½ï¿½ï¿½Ò»ï¿½ï¿½ï¿½ï¿½Ý¸ï¿½ï¿½ï¿½Ôʼ��Ϊ�����Ȩ�ض�̬������ǿ������Ҫ��Ϊ��̽�������ٶԲ���Ҫ��Ϊ��̽����
���������Ľ���Ô���ǣ�����������һ���������-�����ṹģ���������ж��ռ��ϵ����Ȩ��(causal weights)�����Ȩ�ػ�����agent���и���Ч��̽���� ���������Ȩ�ؽϴ�Ķ���ά�Ƚ���̽���������Խ�������Ҫ�Ը��󣬲����ٶ����Ȩ�ؽ�С����Ϊά�ȵ�̽ ����һ��������Ŀ��ȱ���Բ�ͬѧϰ�׶�Ôʼ��Ϊ֮���������Ҫ�Ե���ʶ�����ܵ��µ�Ч��̽����Ϊ�˽����һ���ƣ�����������һ�������Ȩ�ؼ�Ȩ�IJ�������Ϊ�����ϵ��֪�������Ŀ�꣬��Ч�ؼ�ǿ�˶���ҪÔʼ��Ϊ��̽�����������˸���Ч��̽����
�˴��ɹ�ѧϰ�����ϣ�
��3�� �ݶȡ����ߡ�����Gradient Dormancy�� �����Ĺ۲쵽��ģ��ѵ��ʱ��Щ�ݶȻ���ijЩ�׶β���Ծ���������ߡ�����Ϊ�˷�ֹģ�͹��ȹ�עijЩÔʼ��Ϊ������������ �ݶ����ߵ�������û��� ���û���ͨ�������Եض�ģ�ͽ����Ŷ���reset��������ģ������ֲ����ţ��ٽ����㷺��̽����
���������Ľ���Ô���ǣ��û���ͨ��һ�����ݶ����̶߳Ⱦ��������ؼ�Ъ�Եظ���������������硣�������ϵ��֪̽����������ӱ�����û������ϣ�ּ�ڴٽ�����Ч������Ч��̽�������������������������ܡ�
ͨ���ڶ���������������е�ʵ�飬ACE չʾ����������������ǿ��ѧϰ�㷨����SAC��TD3���ı��֣�
�����еĶԱ�ʵ��ͼ����ʾ�� ACE �ڶ��������µ��������ƣ��������� ϡ�轱���͸�ά������ �У�ACE ƾ����̽��Ч�ʵ��������ܸ���ﵽ���Ų��ԡ�
��ACEÔ���ĵĵ�21ҳ���������Ӧ��д����ƪ�ģ������ҿ��˺þõĴ���ȥ������
����˵ʵ����α�����й����ģ���������е����һ����
����һ��ǿ��ѧϰ��RL���㷨�Ŀ�ܣ�������һ���������ƶϣ�Causal Discovery��������ԣ�Off-policy��Actor-Critic�����������Ƕ�ÿ��ģ�鼰�������˵����
Դ������ǧ���أ�����ֻ������main_casual����IJ��ִ��룬����ɾ���˺ܴ�һ���ִ����Ա������������
def train_loop(config, msg = "default"):
# Agent
agent = ACE_agent(env.observation_space.shape[0], env.action_space, config)
memory = ReplayMemory(config.replay_size, config.seed)
local_buffer = ReplayMemory(config.causal_sample_size, config.seed)
for i_episode in itertools.count(1):
done = False
state = env.reset()
while not done:
if config.start_steps > total_numsteps:
action = env.action_space.sample() # Sample random action
else:
action = agent.select_action(state) # Sample action from policy
if len(memory) > config.batch_size:
for i in range(config.updates_per_step):
#* Update parameters of causal weight
if (total_numsteps % config.causal_sample_interval == 0) and (len(local_buffer)>=config.causal_sample_size):
causal_weight, causal_computing_time = get_sa2r_weight(env, local_buffer, agent, sample_size=config.causal_sample_size, causal_method='DirectLiNGAM')
print("Current Causal Weight is: ",causal_weight)
dormant_metrics = {}
# Update parameters of all the networks
critic_1_loss, critic_2_loss, policy_loss, ent_loss, alpha, q_sac, dormant_metrics = agent.update_parameters(memory, causal_weight,config.batch_size, updates)
updates += 1
next_state, reward, done, info = env.step(action) # Step
total_numsteps += 1
episode_steps += 1
episode_reward += reward
#* Ignore the "done" signal if it comes from hitting the time horizon.
if '_max_episode_steps' in dir(env):
mask = 1 if episode_steps == env._max_episode_steps else float(not done)
elif 'max_path_length' in dir(env):
mask = 1 if episode_steps == env.max_path_length else float(not done)
else:
mask = 1 if episode_steps == 1000 else float(not done)
memory.push(state, action, reward, next_state, mask) # Append transition to memory
local_buffer.push(state, action, reward, next_state, mask) # Append transition to local_buffer
state = next_state
if total_numsteps > config.num_steps:
break
# test agent
if i_episode % config.eval_interval == 0 and config.eval is True:
eval_reward_list = []
for _ in range(config.eval_episodes):
state = env.reset()
episode_reward = []
done = False
while not done:
action = agent.select_action(state, evaluate=True)
next_state, reward, done, info = env.step(action)
state = next_state
episode_reward.append(reward)
eval_reward_list.append(sum(episode_reward))
avg_reward = np.average(eval_reward_list)
env.close()
��ʼ�� :
config
���û�����������ӡ�
ACE_agent
��ʼ��ǿ��ѧϰ�����壬����������ں���������ѧϰ����ڻ������ж���
memory
���ڴ洢���е���ʷ���ݣ�
local_buffer
���������Ȩ�صĸ��¡�
��ѵ��Ñ�� :
�������� ������ܲ�����С����ӻ����������������������Ӳ�����ѡ������ͨ�����ַ�ʽ��ȷ������̽���ͺ������á�
�������Ȩ��
�����ض�����ڣ��Ӿֲ��������в������ݣ�ͨ��
get_sa2r_weight
����ʹ��DirectLiNGAM�㷨����Ӷ��������������Ȩ�ء����Ȩ�ػ���Ϊ������Ϣ�������������Ż����ԡ�
�����������
����
memory
�е������㹻��ʱ����ʼͨ����������Q����Ͳ������磬ʹ�ü���������Ȩ����������ʧ������
��¼�뱣��ģ�� ��ÿ��һ���IJ������㷨����Ե�ǰ���Ե����ܣ���¼���ȽϽ����Ƿ񳬹���ʷ���ֵ������ǣ��򱣴�ģ�͵ļ��㡣
ʹ��
wandb
��¼ѵ�������е�ָ�꣬������ʧ���������������Ȩ�صļ���ʱ�䣬��Щ��Ϣ���԰������Ժͷ���ѵ�����̡�
��������
��Ҫͨ��
get_sa2r_weight
����ʵ�֣�������
DirectLiNGAM
ģ�ͽ�ϣ�����������Ȩ�ء����������ѵ��Ñ�������£�
causal_weight, causal_computing_time = get_sa2r_weight(env, local_buffer, agent, sample_size=config.causal_sample_size, causal_method='DirectLiNGAM')
����������
get_sa2r_weight
��������ڵ�ǰ�������������ݣ�
local_buffer
�������ģ�ͣ�����ʹ�õ���
DirectLiNGAM
�����������ж���ص����Ȩ�أ�
causal_weight
������ЩȨ�ػ�Ӱ������IJ����Ż��Ͳ������¡��ؼ��߼�������
total_numsteps % config.causal_sample_interval == 0
ʱ������ȷ��ֻ��ָ���IJ�������ڼ������Ȩ�أ�����ÿһ��������������㣬������㸺����
local_buffer
�д洢���㹻��������
config.causal_sample_size
������Щ�������������ϵ�ķ��֡�
DirectLiNGAM
��ѡ������ģ�ͣ����ڴ�״̬���ж��ͽ���֮���Ƶ��������ϵ��
���Ȩ�ؼ�����ɺ󣬳���Ὣ��ЩȨ��Ӧ�õ������Ż��У����Ҽ�¼Ȩ�ؼ�����ʱ�����Ϣ��
def get_sa2r_weight(env, memory, agent, sample_size=5000, causal_method='DirectLiNGAM'):
������������
return weight, model._running_time
�������ĺ���������DirectLiNGAMģ�ͼ������״̬�������ͽ���֮������Ȩ�ء�����������LaTeX��ʽ��ϸ�����������Ȩ�صĹ��̣�
����Ԥ����
��
����
memory
�����
states
��״̬����
actions
����������
rewards
������������ƴ�ӣ������������ݾ���
\(X_{\text{ori}}\)
��
���У� \(S\) ����״̬�� \(A\) ���������� \(R\) �������������ţ��������ݿ� \(X\) ���������������
������� ��
��
X_ori
ת��Ϊ
X
��������
pandas
���ݿ�ı����Ժ������
ʹ�� DirectLiNGAM ģ�ͶԾ��� \(X\) ������ϣ��õ������ϵ���ڽӾ��� \(A_{\text{model}}\) ��
���ڽӾ����ʾ״̬������������֮�������ṹ���ر��ǴӶ�����������Ӱ���ϵ��
��ȡ�����Խ��������Ȩ��
��
ͨ���ڽӾ�����ȡ�����Խ��������Ȩ��
\(w_{\text{r}}\)
����Ȩ�ش��ڽӾ�������һ����ѡ���붯����Ӧ��Ԫ�أ�
���У� \(d_s\) ��״̬��ά�ȣ� \(d_a\) �Ƕ�����ά�ȡ�
���Ȩ�صĹ�һ��
��
�����Ȩ��
\(w_{\text{r}}\)
����Softmax��һ����ȷ�����ǵ��ܺ�Ϊ1��
����Ȩ�صij߶�
��
������Ȩ�ظ��ݶ����������������ţ�
���������Ȩ�� \(w\) ��ʾÿ�������Խ��������Ӱ�죬������һ�������Ŵ������������ڽ�һ���IJ��Ե����������
�����ǶԺ�������Ô�����𲽽��ͣ�
�������
��Ҫ��
agent.update_parameters
����ʵ�֡�
agent.update_parameters
�����������ҪĿ������ǿ��ѧϰ�и��²��� (
policy
) �ͼ�ֵ���磨critic���IJ���������������������ܡ��������ʵ����һ����������Ա���ۼң�SAC, Soft Actor-Critic���ĸ��»��ƣ����Ҽ��������Ȩ����"����"��Ԫ��dormant neurons���Ĵ����������ģ�͵�³���Ժ��ȶ��ԡ�
critic_1_loss, critic_2_loss, policy_loss, ent_loss, alpha, q_sac, dormant_metrics = agent.update_parameters(memory, causal_weight, config.batch_size, updates)
ͨ��
agent.update_parameters
�����������������¼������֣�
critic_1_loss
��
critic_2_loss
�ֱ������� Critic �������ʧ������������ǰ���Եļ�ֵ��
policy_loss
��ʾ�����������ʧ�������Ż� agent ���ж�ѡ��
ent_loss
�������ڲ��Ե�����ԣ����� agent ��̽��������֮���ҵ�ƽ�⡣
��Щ�����ĸ�����ÿ��ѵ��Ñ���б����ã���ʹ��
wandb.log
��¼��ʧ��������ص�ѵ�����ݡ�
update_parameters
��
ACE_agent
���е�һ���ؼ����������ڸ��ݾ���طŻ������е���������������ģ�͵IJ����������Ƕ��乤��Ô������ϸ���ͣ�
���ȣ�������
memory
�в���һ��������
state_batch
��
action_batch
��
reward_batch
��
next_state_batch
��
mask_batch
�������а���״̬����������������һ��״̬�Լ����룬���ڱ�ʾ�Ƿ�Ϊ��ֹ״̬��
state_batch, action_batch, reward_batch, next_state_batch, mask_batch = memory.sample(batch_size=batch_size)
state_batch
����ǰ��״̬��
action_batch
���ڵ�ǰ״̬��ִ�еĶ�����
reward_batch
��ִ�иö������õĽ�����
next_state_batch
��ִ�ж����󵽴����һ��״̬��
mask_batch
�����룬���ڱ�ʾ�Ƿ�Ϊ��ֹ״̬��1 ��ʾ����ֹ��0 ��ʾ��ֹ����
���õ�ǰ���ԣ�policy�����磬������һ��״̬�Ķ���
next_state_action
�����Ӧ�ĸ��ʷֲ�����
next_state_log_pi
��Ȼ������Ŀ�� Q ����
critic_target
������һʱ�̵���С Q ֵ������Ͻ������ۿ�����
\(\gamma\)
������һ�� Q ֵ��
with torch.no_grad():
next_state_action, next_state_log_pi, _ = self.policy.sample(next_state_batch, causal_weight)
qf1_next_target, qf2_next_target = self.critic_target(next_state_batch, next_state_action)
min_qf_next_target = torch.min(qf1_next_target, qf2_next_target) - self.alpha * next_state_log_pi
next_q_value = reward_batch + mask_batch * self.gamma * (min_qf_next_target)
ͨ����������
self.policy
Ϊ��һ��״̬
next_state_batch
��������
next_state_action
����Ӧ�IJ�����
next_state_log_pi
��
ʹ��Ŀ�� Q �������
qf1_next_target
��
qf2_next_target
����ȡ���ߵ���Сֵ�����ٹ���ƫ�
����ʹ�ñ��������̼���
next_q_value
������ǰ�Ľ��������ۿ�����
\(\gamma\)
������һ��״̬�� Q ֵ��
���
\(\alpha\)
�������Ȩ�أ�����ƽ��̽�������õ�Ȩ�⣬��
mask_batch
��Ϊ�˴�����ֹ״̬�������
ʹ����ƫ����������Ŀ�� Q ֵ��ͨ��Ŀ������ (
critic_target
) �������һ��״̬�Ͷ����� Q ֵ����ʹ�ý�����������µ�ǰ Q ֵ
���ţ�ʹ�õ�ǰ Q ����
critic
���Ƶ�ǰ״̬�Ͷ����µ� Q ֵ
\(Q_1\)
��
\(Q_2\)
��������������Ŀ�� Q ֵ�ľ��������ʧ��
���� Q ���������ʧ������ Q ������ʧ֮�ͣ�
Ȼ��ͨ�����򴫲�
qf_loss
������ Q ����IJ�����
qf1, qf2 = self.critic(state_batch, action_batch)
qf1_loss = F.mse_loss(qf1, next_q_value)
qf2_loss = F.mse_loss(qf2, next_q_value)
qf_loss = qf1_loss + qf2_loss
self.critic_optim.zero_grad()
qf_loss.backward()
self.critic_optim.step()
qf1
��
qf2
������ Q �������������ڼ����������ƫ�
qf1_loss
��
qf2_loss
�ֱ�������� Q �����������������Ϊ�ܵ� Q ��ʧ
qf_loss
��
self.critic_optim
�Ż�������ʧ���з��򴫲��Ͳ������¡�
ÿ�����ɲ���ͨ��
target_update_interval
���ƣ�����ʼ���²�������
policy
�����ȣ����²�����ǰ״̬�µIJ���
\(\pi(a|s)\)
�������� Q ֵ����Ȩ���µIJ�����ʧ��
�����ʧͨ�����򴫲����²������硣
if updates % self.target_update_interval == 0:
pi, log_pi, _ = self.policy.sample(state_batch, causal_weight)
qf1_pi, qf2_pi = self.critic(state_batch, pi)
min_qf_pi = torch.min(qf1_pi, qf2_pi)
policy_loss = ((self.alpha * log_pi) - min_qf_pi).mean()
self.policy_optim.zero_grad()
policy_loss.backward()
self.policy_optim.step()
state_batch
���в������õ�����
pi
�����Ӧ�IJ�����
log_pi
��
policy_loss
����
\(\alpha\)
���IJ����ؼ�ȥ��С�� Q ֵ��
self.policy_optim
�Ż����Բ�����ʧ���з��򴫲��Ͳ������¡�
����������Զ����������
automatic_entropy_tuning
��������һ����������
\(\alpha\)
����ʧ��
��ͨ���ݶ��½����� \(\alpha\) ��
���
automatic_entropy_tuning
Ϊ�棬���������
if self.automatic_entropy_tuning:
alpha_loss = -(self.log_alpha * (log_pi + self.target_entropy).detach()).mean()
self.alpha_optim.zero_grad()
alpha_loss.backward()
self.alpha_optim.step()
self.alpha = self.log_alpha.exp()
alpha_tlogs = self.alpha.clone()
else:
alpha_loss = torch.tensor(0.).to(self.device)
alpha_tlogs = torch.tensor(self.alpha) # For TensorboardX logs
alpha_loss
����
self.alpha
���������Ե�̽��-����ƽ�⡣
qf1_loss
,
qf2_loss
: ���� Q �������ʧ
policy_loss
: �����������ʧ
alpha_loss
: ��Ȩ�ص���ʧ
alpha_tlogs
: ������־��¼����Ȩ��
next_q_value
: ƽ����һ�� Q ֵ
dormant_metrics
: ������Ԫ����ض���
���û���ģ���ڴ�������Ҫ������
update_parameters
�����У���ͨ��
�ݶ�������
(dominant metrics) ��
�Ŷ�����
(perturbation functions) ʵ�ֶԲ�������� Q ��������á�
���������趨��
reset_interval
�ж��Ƿ���Ҫ�Բ�������� Q ��������Ŷ������á�����ʹ����"����"��Ԫ�ĸ����һЩ���ݶȸ�����Ӱ���С����Ԫ�����ܻᱻ���������á�
�������������߶���
dormant_metrics
�����Ȩ�ز���
causal_diff
��ͨ���Ŷ�����
perturb_factor
�������Ƿ��������в��ֻ�ȫ�����Ŷ������á�
���û�����Ҫ�����²�����ɣ�
�ڸ��²���ʱ������
�����ݶ�
����ijЩ�ض���Ԫ������ڸ������������õı��ʡ�������ͨ������
cal_dormant_grad(self.policy, type='policy', percentage=0.05)
ʵ����һ���㣬������ȡ�� 5% �������ݶ�����Ϊ�ж����ӡ�
dormant_metrics = cal_dormant_grad(self.policy, type='policy', percentage=0.05)
���������� ($ \beta_\gamma$ ) ��Ȩ�� ($ w$ )�����Եõ����ЧӦ�IJ��졣��������
causal_diff
����ʾ������죺
�����û���ͨ��ƽ�����²�������� Q ���磬��������Ȩ�ظ��µ��µ����粻�ȶ������ڴ�������
soft_update
ʵ�֣�
soft_update(self.critic_target, self.critic, self.tau)
������˵�������µĹ�ʽΪ��
���У�( \(\tau\) ) ��һ����С�ij�����ͨ������ ( [0, 1] ) ֮�䣬ȷ��Ŀ������ĸ����ǻ����ģ������ѧϰ���ȶ��ԡ�
ÿ������һ�������ü��ʱ���ж��Ƿ���Ҫ�Ŷ����Ժ� Q ���硣ͨ������
perturb()
��
dormant_perturb()
ʵ�ֶ�������Ŷ���perturbation�����Ŷ��������ݶ������Ⱥ�������칲ͬ������
������ Q ������Ŷ�����������������·�����
������ÿ�����´���
updates
�ﵽ�趨�����ü��
self.reset_interval
������
updates > 5000
ʱ���Żᴥ�������� Q ����������߼�������Ϊ��ȷ���Ŷ�����Ƶ�������������ھ���һ�νϳ���ѵ��ʱ�����С�
�����������
if updates % self.reset_interval == 0 and updates > 5000:
�ڴﵽ�����ü�������Ȼ����
�ݶ�������
��
���ЧӦ�IJ���
�������ͨ�������������
causal_diff
���ݶ�������
dormant_metrics['policy_grad_dormant_ratio']
�������Ƿ���Ҫ�Ŷ���
�ݶ�������
���㷽ʽͨ��
cal_dormant_grad()
����ʵ�֣�����ݶ������Ƚϵͣ���ζ�������е�ijЩ��Ԫ���·��ȹ�С������Ҫ����������Ŷ���
���ЧӦ����
ͨ������
causal_diff = np.max(causal_weight) - np.min(causal_weight)
�õ��������������������Ҫ���á�
Ȼ�������Щֵͨ���Ŷ�����
factor
�����жϣ�
factor = perturb_factor(dormant_metrics['policy_grad_dormant_ratio'])
����Ŷ����� ( \(\text{factor} < 1\) )�����������Ŷ���
if factor < 1:
if self.reset == 'reset' or self.reset == 'causal_reset':
perturb(self.policy, self.policy_optim, factor)
perturb(self.critic, self.critic_optim, factor)
perturb(self.critic_target, self.critic_optim, factor)
updates > 5000
����
����������ͬʱ����ʱ�����Ժ� Q ���罫���Ŷ������á�
����δ����У�
factor
�ǻ����������ݶ������Ȼ������ЧӦ�������������Ŷ����ӡ��Ŷ�����ͨ������
perturb_factor()
���м��㣬�ú����������Ԫ���ݶ������ȣ�
dormant_ratio
�������ЧӦ���죨
causal_diff
��������
factor
�Ĵ�С��
�Ŷ�����
factor
�ļ��㹫ʽ���£�
����
( \(\text{dormant\_ratio}\) ) ���������ݶ������ȣ�����ʾ�ж�����Ԫ���ݶȱ仯��С�����߽ӽ��㣩�����ڡ����ߡ�״̬��
(
\(\text{min\_perturb\_factor}\)
) ����С�Ŷ�����ֵ���������趨Ϊ
0.2
��
(
\(\text{max\_perturb\_factor}\)
) ������Ŷ�����ֵ���������趨Ϊ
0.9
��
dormant_ratio :
dormant_ratio
Խ�󣬱�ʾԽ����Ԫ���ݶȱ仯��С��˵��������²���֣���Ҫ�Ŷ���
max_perturb_factor :
min_perturb_factor :
�ڼ������ЧӦ�IJ��֣��Ŷ�����
factor
����������ЧӦ����
causal_diff
��������
causal_diff
��ͨ���������ЧӦ�����ֵ����Сֵ�IJ�������õģ�
�������
causal_diff
��Ӱ��
causal_factor
������һ����
factor
�������
������ѡ����������ã�
causal_reset
�����Ŷ����ӽ�ʹ���������������
causal_factor
���ж��ε�����
����������
factor
������ֵ�����ݶ������Ȼ����ЧӦ���������Ƶģ���������Ԫ�����ϴ�����ЧӦ����ϴ�ʱ��
factor
���С��������������Ŷ���
��δ�����Ҫʵ������ǿ��ѧϰ��RL��ѵ�������У��������������壨agent�������ܣ�����ijЩ�����±������ģ�͵ļ��㡣���ǿ��Էֶν��͸ô��룺
if i_episode % config.eval_interval == 0 and config.eval is True:
�ⲿ�ִ��������ж��Ƿ�Ӧ��ִ�������������������Ϊ��
i_episode % config.eval_interval == 0
����ʾÿ��
config.eval_interval
��ѵ���غϣ�
i_episode
�ǵ�ǰ�غ���������һ��������
config.eval is True
��ȷ��
eval
����Ϊ
True
��Ҳ����˵���������ܿ�����
����������������������뽫��ʼִ������������
eval_reward_list = []
���ڴ洢ÿ�������غϣ�episode�����ۼƽ������Ա�֮�����ƽ��������
for _ in range(config.eval_episodes):
�����׶ν����ж���غϣ���
config.eval_episodes
ָ���Ļغ��������Ի��������ı��֡�
state = env.reset()
episode_reward = []
done = False
env.reset()
�����û�������ó�ʼ״̬
state
��
episode_reward
����ʼ��һ���б������ڴ洢��ǰ�غ����������õ����н�����
done = False
����
done
�����ٵ�ǰ�غ��Ƿ������
while not done:
action = agent.select_action(state, evaluate=True)
next_state, reward, done, info = env.step(action)
state = next_state
episode_reward.append(reward)
����ѡ��
��
agent.select_action(state, evaluate=True)
������ģʽ�¸��ݵ�ǰ״̬
state
ѡ������
evaluate=True
��ʾ��ѡ����������ģʽ�£�ͨ����ζ��̽����Ϊ���رգ������������̽��������ѡ�����Ŷ�������
��������
��
next_state, reward, done, info = env.step(action)
ͨ��ִ�ж���
action
������������һ��״̬
next_state
����ǰ����
reward
���غ��Ƿ�����ı�־
done
���Լ�������Ϣ
info
��
״̬����
����ǰ״̬������Ϊ
next_state
��������õĽ���
reward
�洢��
episode_reward
���
Ñ��������ֱ���غϽ�������
done == True
����
eval_reward_list.append(sum(episode_reward))
��ǰ�غϽ������ۼƽ�����
sum(episode_reward)
�������ӵ�
eval_reward_list
�����ں�������ƽ��������
avg_reward = np.average(eval_reward_list)
�����������غϽ����󣬼���
eval_reward_list
��ƽ��ֵ
avg_reward
�����ǵ�ǰ�����׶�������ı���ָ�ꡣ
if config.save_checkpoint:
if avg_reward >= best_reward:
best_reward = avg_reward
agent.save_checkpoint(checkpoint_path, 'best')
config.save_checkpoint
Ϊ
True
�����ʾ��Ҫ����Ƿ񱣴�ģ�͡�
avg_reward
�Ƿ񳬹���֮ǰ����ѽ���
best_reward
������ǣ������
best_reward
�������浱ǰģ�͵ļ��㡣
agent.save_checkpoint(checkpoint_path, 'best')
���д���Ὣ�������״̬���浽ָ����·��
checkpoint_path
�������Ϊ
"best"
����ʾ����������ѵ�ģ�͡�
�ȿȣ����Է��ֳ���ֻ��¼�� 0~1000 �����ݣ��� 1001 ��ʼ��ÿһ�����ݶ���ʾ�������Ա��������ˡ�
��������������github�������������ͬ���ı�����Ϣ
������Ϣ�ǣ����� X+1 �ִ��г��Լ��� X �ִ��е���Ϣ������������ݱ���������
���������������������ɣ����Լ�Ҳû�� bug
���������Ŀ�����ˣ���Ҫ���������Ŀ�IJ�ʿʦ��Ҳ��ҵ�ˣ�Ҳ����˵Щʲô����Ȼ������΢�ţ����������������ģ��ͦ���õİ����ֶ�������
ʹ��Blender���ɳ���ģ��
�Ķ�ȫ����������ERA5�����ط���
�Ķ�Xpath���������﷨
�Ķ�����ѧϰ�������繹�����£�
�Ķ���ΪMateƷ��ʢ�䣺HarmonyOS NEXT�ӳ�����Ϸ���ܵõ�����ͷ�
�Ķ�ʵ�ֶ��󼯺���DataTable���໥ת��
�Ķ�Ӳ�̵Ļ���֪ʶ��ѡ��ָ��
�Ķ�������й��ƶ��ı�ͼ��ײ�
�Ķ�����NEXTԪ�����������ѿ����ϼ���Ʒ
�Ķ��ᳲ���С������������Ƽ��رշ���
�Ķ������ArcMap�����н���դ��ͼ���ز�������
�Ķ��㷨�����ݽṹ 1 - ģ��
�Ķ���Ѷ�����߿ͷ���Ӫ��ϵͳ����
�Ķ���Ѷ��Ƶҹ��ģʽ���ý̳�
�Ķ����ں���NEXT��Ѫ���Ŵ���������������
�Ķ�5. Spring Cloud OpenFeign ����ʽ WebService �ͻ��˵ij���ϸʹ��
�Ķ�Java����ģʽ����̬�����Ͷ�̬�����ĶԱȷ���
�Ķ�Win11�ʼDZ����Զ�����Ӧ�õ���ɫ����ʾ����
�Ķ�˼�� V1.5.6 ��׿��
��ս�귨 V7.5.0 ��׿��
У��������������׵������� V1.0 ��׿��
��˸֮�� V1.9.7 ��׿��
������Ե����� v1.0.4 ��׿��
������֮ŠV5.2.3 ��׿��
��������������Դ V1.0 ��׿��
���֮Ϣ V1.0 ��׿��
��ħ������������䣩 V1.0 ��׿��
���ں�������ϵ�����������������վ�����������������Ƽ�����
Ƶ�� ����Ƶ��������ר������������׿�������app����
�Ƽ� ��Ô���������°��������ܿ������ز���
���� ����ɫ������������ ���������ս������������
ɨ��ά�����������ֻ��汾��
ɨ��ά����������΢�Ź��ںţ�
��վ�������������������ϴ��������ַ���İ�Ȩ���뷢�ʼ�[email protected]
��ICP��2022002427��-10 �湫��������43070202000427��© 2013~2025 haote.com ������