added links for lander

Author: steven-ja

assets/styles/components/misc.scss

@@ -18,6 +18,8 @@
 
 pre {
   margin: 5px;
+  border-bottom-right-radius: 18px;
+
   & > code {
     padding: 10px !important;
   }

content/posts/physics/lunar_lander/game.py

@@ -0,0 +1,119 @@
+import pygame
+from pygame.math import Vector3
+from OpenGL.GL import *
+from OpenGL.GLU import *
+import numpy as np
+
+class LunarLander:
+    def __init__(self):
+        self.position = Vector3(0, 10, 0)
+        self.velocity = Vector3(0, 0, 0)
+        self.acceleration = Vector3(0, -1.62, 0)  # Moon's gravity
+        self.fuel = 1000.0
+        self.thrust = Vector3(0, 0, 0)
+
+    def update(self, dt):
+        self.velocity += (self.acceleration + self.thrust) * dt
+        self.position += self.velocity * dt
+        self.fuel -= self.thrust.length() * dt
+
+    def apply_thrust(self, thrust_vector):
+        if self.fuel > 0:
+            self.thrust = thrust_vector
+        else:
+            self.thrust = Vector3(0, 0, 0)
+
+class Terrain:
+    def __init__(self, size, resolution):
+        self.size = size
+        self.resolution = resolution
+        self.heights = np.random.uniform(0, 1, (resolution, resolution))
+        # Apply some smoothing here for more realistic terrain
+
+def draw_cube():
+    vertices = [
+        ( 0.5,  0.5,  0.5), (-0.5,  0.5,  0.5), (-0.5, -0.5,  0.5), ( 0.5, -0.5,  0.5),
+        ( 0.5,  0.5, -0.5), (-0.5,  0.5, -0.5), (-0.5, -0.5, -0.5), ( 0.5, -0.5, -0.5)
+    ]
+    
+    edges = [
+        (0,1), (1,2), (2,3), (3,0),
+        (4,5), (5,6), (6,7), (7,4),
+        (0,4), (1,5), (2,6), (3,7)
+    ]
+    
+    glBegin(GL_LINES)
+    for edge in edges:
+        for vertex in edge:
+            glVertex3fv(vertices[vertex])
+    glEnd()
+
+def draw_lander(lander):
+    glPushMatrix()
+    glTranslatef(lander.position.x, lander.position.y, lander.position.z)
+    glColor3f(1, 1, 1)
+    draw_cube()
+    glPopMatrix()
+
+def draw_terrain(terrain):
+    glBegin(GL_TRIANGLES)
+    for i in range(terrain.resolution - 1):
+        for j in range(terrain.resolution - 1):
+            x1, z1 = i * terrain.size / terrain.resolution, j * terrain.size / terrain.resolution
+            x2, z2 = (i + 1) * terrain.size / terrain.resolution, (j + 1) * terrain.size / terrain.resolution
+            y11, y12, y21, y22 = (terrain.heights[i,j], terrain.heights[i,j+1],
+                                  terrain.heights[i+1,j], terrain.heights[i+1,j+1])
+            
+            glColor3f(0.5, 0.5, 0.5)
+            glVertex3f(x1, y11, z1)
+            glVertex3f(x1, y12, z2)
+            glVertex3f(x2, y22, z2)
+            
+            glVertex3f(x1, y11, z1)
+            glVertex3f(x2, y22, z2)
+            glVertex3f(x2, y21, z1)
+    glEnd()
+
+def main():
+    pygame.init()
+    display = (800, 600)
+    pygame.display.set_mode(display, pygame.DOUBLEBUF | pygame.OPENGL)
+    
+    gluPerspective(45, (display[0] / display[1]), 0.1, 50.0)
+    glTranslatef(0.0, 0.0, -20)
+    
+    lander = LunarLander()
+    terrain = Terrain(20, 50)
+    
+    clock = pygame.time.Clock()
+    
+    while True:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                quit()
+        
+        keys = pygame.key.get_pressed()
+        thrust = Vector3(0, 0, 0)
+        if keys[pygame.K_UP]:
+            thrust.y = 100
+            print(thrust)
+        if keys[pygame.K_LEFT]:
+            thrust.x = -1.0
+            print(thrust)
+        if keys[pygame.K_RIGHT]:
+            thrust.x = 1.0
+        
+        lander.apply_thrust(thrust)
+        lander.update(0.01)
+        
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+        
+        draw_terrain(terrain)
+        draw_lander(lander)
+        
+        pygame.display.flip()
+        clock.tick(60)
+
+if __name__ == "__main__":
+    main()

content/posts/physics/lunar_lander/lander.py

@@ -0,0 +1,123 @@
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from collections import deque
+import random
+
+
+class DQN(nn.Module):
+    def __init__(self, state_size, action_size):
+        super(DQN, self).__init__()
+        self.fc1 = nn.Linear(state_size, 64)
+        self.fc2 = nn.Linear(64, 64)
+        self.fc3 = nn.Linear(64, action_size)
+
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        x = torch.relu(self.fc2(x))
+        return self.fc3(x)
+
+
+class DQNAgent:
+    def __init__(self, state_size, action_size):
+        self.state_size = state_size
+        self.action_size = action_size
+        self.memory = deque(maxlen=100000)
+        self.gamma = 0.99    # discount rate
+        self.epsilon = 1.0   # exploration rate
+        self.epsilon_min = 0.01
+        self.epsilon_decay = 1 - 1e-5
+        self.learning_rate = 0.002
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = DQN(state_size, action_size).to(self.device)
+        self.target_model = DQN(state_size, action_size).to(self.device)
+        self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)
+        self.criterion = nn.MSELoss()
+
+    def update_target_model(self):
+        self.target_model.load_state_dict(self.model.state_dict())
+
+    def remember(self, state, action, reward, next_state, done):
+        self.memory.append((state, action, reward, next_state, done))
+
+    def act(self, state):
+        if np.random.rand() <= self.epsilon:
+            return random.randrange(self.action_size)
+        state = torch.FloatTensor(state).unsqueeze(0).to(self.device)
+        with torch.no_grad():
+            act_values = self.model(state)
+        return np.argmax(act_values.cpu().data.numpy())
+
+    def replay(self, batch_size):
+        minibatch = random.sample(self.memory, batch_size)
+        states, actions, rewards, next_states, dones = zip(*minibatch)
+
+        states = torch.FloatTensor(states).to(self.device)
+        actions = torch.LongTensor(actions).to(self.device)
+        rewards = torch.FloatTensor(rewards).to(self.device)
+        next_states = torch.FloatTensor(next_states).to(self.device)
+        dones = torch.FloatTensor(dones).to(self.device)
+
+        current_q_values = self.model(states).gather(1, actions.unsqueeze(1))
+        next_q_values = self.target_model(next_states).max(1)[0].detach()
+        target_q_values = rewards + (self.gamma * next_q_values * (1 - dones))
+
+        loss = self.criterion(current_q_values, target_q_values.unsqueeze(1))
+        self.optimizer.zero_grad()
+        loss.backward()
+        self.optimizer.step()
+
+        if self.epsilon > self.epsilon_min:
+            self.epsilon *= self.epsilon_decay
+
+def main():
+    env = gym.make("LunarLander-v2", render_mode='human')
+    state_size = env.observation_space.shape[0]
+    action_size = env.action_space.n
+    agent = DQNAgent(state_size, action_size)
+    batch_size = 32
+    episodes = 1000
+    
+    for episode in range(episodes):
+        state, _ = env.reset()
+        score = 0
+        max_steps = 1000
+        for time in range(max_steps):
+            action = agent.act(state)
+            next_state, reward, done, _, _ = env.step(action)
+            agent.remember(state, action, reward, next_state, done)
+            state = next_state
+            score += reward
+            if len(agent.memory) > batch_size:
+                agent.replay(batch_size)
+            if done:
+                agent.update_target_model()
+                break
+        
+        print(f"Episode: {episode+1}/{episodes}, Score: {score:.2f}, Epsilon: {agent.epsilon:.2f}")
+        
+        # Render every 50 episodes
+        if (episode + 1) % 50 == 0:
+            env.render()
+    
+    env.close()
+    # state, _ = env.reset()
+    # score = 0
+    # max_steps = 1000
+    # for time in range(max_steps):
+    #     action = agent.act(state)
+    #     next_state, reward, done, _, _ = env.step(action)
+    #     agent.remember(state, action, reward, next_state, done)
+    #     state = next_state
+    #     score += reward
+    #     if len(agent.memory) > batch_size:
+    #         agent.replay(batch_size)
+    #     if done:
+    #         agent.update_target_model()
+    #         break
+    #     env.render("human")
+
+if __name__ == "__main__":
+    main()

content/posts/physics/lunar_lander/links.md

@@ -0,0 +1,2 @@
+* https://aayala4.github.io/Lunar-Lander-Python/
+* https://github.com/arda-guler/miniLanding3D/tree/master