शुरू करेंमुफ़्त में शुरू करें

पूरे DQN एल्गोरिदम को इम्प्लीमेंट करना

वक़्त आ गया है! सारी पूर्व-आवश्यकताएँ पूरी हो चुकी हैं; अब आप पूरा DQN एल्गोरिदम इम्प्लीमेंट करेंगे और उसे Lunar Lander एजेंट को ट्रेन करने में इस्तेमाल करेंगे. इसका मतलब है कि आपका एल्गोरिदम केवल Experience Replay ही नहीं, बल्कि Decayed Epsilon-Greediness और Fixed Q-Targets भी उपयोग करेगा.

Decayed Epsilon Greediness को इम्प्लीमेंट करने वाला select_action() फंक्शन आपके लिए उपलब्ध है, और पिछले अभ्यास का update_target_network() फंक्शन भी. अब बस इन फंक्शनों को DQN ट्रेनिंग लूप में फिट करना है और यह सुनिश्चित करना है कि आप लॉस कैलकुलेशन में टार्गेट नेटवर्क का सही उपयोग कर रहे हैं.

आपको एक नया स्टेप काउंटर total_steps रखना होगा, ताकि समय के साथ \(\varepsilon\) का मान डिके हो सके. यह वैरिएबल आपके लिए 0 मान के साथ इनिशियलाइज़ किया गया है.

यह अभ्यास पाठ्यक्रम का हिस्सा है

Python में Deep Reinforcement Learning

पाठ्यक्रम देखें

अभ्यास निर्देश

  • एजेंट की ऐक्शन चुनने और Decayed Epsilon Greediness लागू करने के लिए select_action() का उपयोग करें; आपको total_steps देना होगा, जो एपिसोड्स के पार चलने वाला कुल योग है.
  • TD टार्गेट कैलकुलेट करने से पहले ग्रेडिएंट ट्रैकिंग बंद करें.
  • अगली स्थिति प्राप्त करने के बाद, अगली स्थिति के Q-values लें.
  • हर स्टेप के अंत में टार्गेट नेटवर्क अपडेट करें.

इंटरैक्टिव व्यावहारिक अभ्यास

इस अभ्यास को इस नमूना कोड को पूरा करके आज़माएँ।

for episode in range(10):
    state, info = env.reset()
    done = False
    step = 0
    episode_reward = 0
    while not done:
        step += 1
        total_steps += 1
        q_values = online_network(state)
        # Select the action with epsilon greediness
        action = ____(____, ____, start=.9, end=.05, decay=1000)
        next_state, reward, terminated, truncated, _ = env.step(action)
        done = terminated or truncated
        replay_buffer.push(state, action, reward, next_state, done)        
        if len(replay_buffer) >= batch_size:
            states, actions, rewards, next_states, dones = replay_buffer.sample(64)
            q_values = online_network(states).gather(1, actions).squeeze(1)
            # Ensure gradients are not tracked
            with ____:
                # Obtain the next state Q-values
                next_q_values = ____(next_states).amax(1)
                target_q_values = rewards + gamma * next_q_values * (1-dones)
            loss = nn.MSELoss()(q_values, target_q_values)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()   
            # Update the target network weights
            ____(____, ____, tau=.005)
        state = next_state
        episode_reward += reward    
    describe_episode(episode, reward, episode_reward, step)
कोड संपादित करें और चलाएँ