teramiku39 님의 블로그

2025-03-01~2025-09-01까지의 진행사항 요약

teramiku39 — Wed, 24 Sep 2025 18:11:28 +0900

# 핵심 요약

Ubuntu 22.04 부팅, Isaac Sim 4.5.0, Lab 2.1.0 설치, 데이비드 실버 RL 강의 듣기

Ubuntu Terminal 환경 적응, 로보틱스/AI 조사용 에세이 작성

Isaac Sim gui, script 튜토리얼 진행, 이륜 로봇 모델 제작, Isaac Lab 튜토리얼 진행

그래픽 카드 교체 후 Pytorch 호환성 문제 해결, Isaac Sim 5.0, Isaac Lab branch 빌드

★이륜 로봇 목표 지점 유도 제어

Ubuntu 24.04 듀얼부팅, 카메라, 라이다 센서 부착 시도, ROS 2 설치

Windows 듀얼부팅, 문서 작성, Github repository 생성

# 2025년 3월

Ubuntu 22.04 부팅, Isaac Sim 4.5.0, Lab 2.1.0 설치, 데이비드 실버 RL 강의 듣기

- 빠른 적응을 위해 듀얼부팅 없이 윈도우 11에서 우분투로 OS 교체 결정. isaac lab stable과 호환되는 22.04 LTS 설치

- 윈도우에 있던 자료는 하드 드라이브에 백업

- Gnome 환경 윈도우와 유사하게 구성, GUI 신뢰성이 떨어져서 터미널로 작업

(모르는 명령어는 함부로 치지 않기!!!)

- 문서 보고 아이작 심 빌드 https://github.com/isaac-sim/IsaacSim (pip 패키지로 설치하면 더 효율적)

- 아이작 랩 빌드 https://github.com/isaac-sim/IsaacLab

- 각각을 빌드했을때는 프로젝트 디렉토리를 isaaclab.sh에서 수동으로 연결해야 함

- 설치 테스트 코드

./isaaclab.sh -p scripts/reinforcement_learning/rsl_rl/train.py --task=Isaac-Ant-v0 --headless

- 데이비드 실버 RL course 듣기

https://www.youtube.com/watch?v=2pWv7GOvuf0&list=PLqYmG7hTraZDM-OYHWgPebj2MfCFzFObQ

- MDP, Model-Free, Value Function, Policy gradient 학습

- 이해 안되는 개념(대부분 수식)은 gemini에게 물어보며 진행

# 2025년 4월 ~ 6월

Ubuntu Terminal 환경 적응, 로보틱스/AI 조사용 에세이 작성

- 1학기 진행중 산발적으로 터져 나오는 Ubuntu 에러, 문제 해결.

(Windows와 다르게 사용자가 직접 터미널로 수정해야 하는 부분이 많음.)

- Windows에서만 실행되는 프로그램들 대체재 찾기. --> github에 있는 프로젝트들 찾은 후 설치/빌드해서 사용

- 최근 로보틱스 업계 동향 자투리 시간에 검색

=> 국내에서는 4족(quadrupedal), 바퀴 로봇 많이 사용, 이동 플랫폼과 팔/손 만드는 업체가 다른 경우 많음

- 전문학술영어 시간에 주제를 로봇 강화학습 제어로 선정해서 개념 복습 겸 과거 논문들 훑어보고 분석글 작성후 발표

=> PILCO, SAC 등이 있지만 아직은 PPO가 주류

Evaluating The efficiency of Reinforcement Learning in Robotic control systems-1.pdf

0.06MB

# 2025년 7월 초 ~ 7월 2주차

Isaac Sim gui, script 튜토리얼 진행, 이륜 로봇 모델 제작, Isaac Lab 튜토리얼 진행

- 본격적인 학습 진행. 드라이브 위치가 바뀌었더니 작동이 안되서 재설치

- 문서가 업데이트되서 Pip 패키지 설치 방법으로 수월하게 진행

- Isaac Sim 튜토리얼로 간단한 이륜 로봇 모델링

https://docs.isaacsim.omniverse.nvidia.com/latest/robot_setup_tutorials/index.html

- 추후 Articulation을 심층 시뮬레이션하려면 Mujoco 등 사용

- Isaac Lab 튜토리얼 진행 (python 스크립트 방식에 적응)

https://isaac-sim.github.io/IsaacLab/release/2.1.0/source/tutorials/03_envs/modify_direct_rl_env.html

# 2025년 7월 3주차

그래픽 카드 교체 후 Pytorch 호환성 문제 해결, Isaac Sim 5.0, Isaac Lab branch 빌드

- 컴퓨터 그래픽 카드를 반강제로 5080으로 교체. Blackwell 아키텍처와 Pytorch, Isaac Sim 의존성 지옥 해결

- Isaac Sim 예제 실행은 가능하나 렌더링에 심각한 노이즈가 발생

- 공식 디스코드 탐색 결과 isaac sim 5.0.0 unstable branch로 버전업밖에 없음

https://discord.com/channels/827959428476174346/1288159667973001347

- Github에서 5.0.0 branch를 찾아서 직접 터미널로 빌드

- 5.0.0과의 호환을 위해 Isaac Lab도 2.2.0을 직접 빌드한 후 두 프로그램과 외부 프로젝트를 연결

- 수많은 버그와 에러 해결 후 Isaac Lab scene과 robotCfg 로드 성공

# 2025년 7월 4주차 ~ 8월 1주차

이륜 로봇 목표 지점 유도 제어

- Direct RL Environment, SKRL PPO로 외부 프로젝트 MyFirstCar 생성

- 지정된 방향을 따라가는 예제 환경을 지정된 목표 지점까지 도달후 정지하게 수정

- 자세한 사항은 하위 문서 참조

2025.08.13 - [아이작 랩] - 아이작 랩 - 이륜 로봇 강화학습 제어

# 2025년 8월 2주차 ~ 8월 3주차

Ubuntu 24.04 듀얼부팅, 카메라, 라이다 센서 부착 시도, ROS 2 설치

- 8월 9일 드디어 Isaac Sim 5.0.0 정식 버전 출시

- 22.04를 기본 OS로 쓰기에는 업무 외 프로그램 호환성 문제가 계속 심해져서 외장 드라이브에 24.04를 듀얼부팅

- 듀얼 부팅 후 안정성 검증을 위해 프로젝트는 22.04 유지

- 유도 제어 마친 후 카메라 부착해 목표 지점 인식 시도

- 목표 지점에 박아놓은 object 인식이 잘 작동하지 않고, 설령 object 인식해도 거리 인지를 못함

- LIDAR 센서 시뮬레이션을 위해 ROS 2 extension 설치

- 센서는 Sim이 아니라 Isaac Lab에서 설정

- 예제에 있던 LIDAR 거리 센서를 사용해보려 했으나 프로젝트에 센서 로딩 실패

- 적절한 예제 코드가 없으니 작업이 급격하게 늘어짐을 체감

# 2025년 8월 4주차

Windows 듀얼부팅, 문서 작성, Github Repository 생성

- 키보드 보안 프로그램, Microsoft 365 미지원 등 linux 단독 OS으로는 어려운 점 발생

- NVME쪽 SSD에 윈도우11을 듀얼부팅, 외장드라이브는 24.04 유지(듀얼 드라이브/듀얼 부트로더 부팅)

- 22.04에서 파일 백업하여 전부 이동, 24.04용으로 Isaac Sim, Isaac Lab 빌드해 개발 환경 통합

8월 4주차 프로젝트 폴더 상태

- 이륜 로봇 제어 부분 까먹지 않게 문서화 완료

- 오픈 소스화 후 Isaac Lab 공식 문서도 업데이트가 활발하게 진행중(좋은 문서들은 왜 이렇게 늦게 올라오는가...)

https://isaac-sim.github.io/IsaacLab/main/source/setup/ecosystem.html

- 여러가지 로보틱스 분야 정보 탐색

- github repository 생성 https://github.com/teramiku39/IsaacLab

# 진로 관련 질문

- 수식(이론)과 코드(실무)를 잘 연결하려면?

배웠던 지식을 코드로 바꾸는 과정이 많은 어려움이 있고, 튜토리얼이나 예제 코드가 없으면 쉽게 진행할 수가 없었습니다. 이론과 실무, 어떤 부분에 집중을 해야 문제해결역량을 성장시킬 수 있을까요?

- 대학원 진학은 필수일까요?

이 외에도 프로젝트를 진행하면서 부족한 점이 많음을 느꼈습니다. 제대로 된 실무를 수행하려면 학부 때 선행경험뿐만 아니라 대학원에서의 전문적 경험을 따로 쌓아야 할까요?

- 군 입대 전까지 무엇을 하면 좋을까요?

현재 1월~2월 중에 공군 입대 예정인데, 남은 기간(2학기 중~전역 후) 동안 어떤 경험을 쌓으면 좋을지 궁금합니다.

Mujoco, robosuite, ROS 등 다른 프레임워크를 다뤄볼지, SAC, Dagger나 다익스트라 등 다른 방법론, 알고리즘을 공부할지, 아니면 Jetson nano 등 하드웨어를 다뤄볼지 어떤 조언이든 도움이 될 것 같습니다.

# 궁금한 점

- 마블, 디든30 설계 차이의 이유?

각각 다리 길이, 동체 비율, 액추에이터 위치가 다른데, 해당 공학적 설계가 왜 적용되었는지가 궁금합니다.

디든워커 <-> KAIST DRCD Lab humanoid와의 연관관계?

- 최근 로보틱스 랩실에서의 창업이 활발한 이유?

- world model, model-based RL의 전망?

https://arxiv.org/abs/2506.01622v2

해당 논문 초록, 서론 결론을 보고 궁금해졌습니다. 로봇이 특정 작업이 아니라 범용적인 작업을 수행하려면 model이 꼭 필요할지 대표님의 의견이 궁금합니다.

아이작 랩 - 이륜 로봇 목표 지점 유도 제어

teramiku39 — Wed, 13 Aug 2025 02:38:34 +0900

https://docs.isaacsim.omniverse.nvidia.com/latest/robot_setup_tutorials/index.html

Robot Setup Tutorials Series — Isaac Sim Documentation

Robot Setup Tutorials Series The GUI tutorials walk you through setting up your virtual world and building robot digital twins with various NVIDIA Isaac Sim features. In the process, you will learn where to find frequently used properties, settings, and to

docs.isaacsim.omniverse.nvidia.com

해당 문서를 참고하여 강화학습 제어용 이륜 로봇을 제작하였다.

https://isaac-sim.github.io/IsaacLab/main/source/setup/walkthrough/training_jetbot_gt.html

Training the Jetbot: Ground Truth — Isaac Lab Documentation

Training the Jetbot: Ground Truth With the environment defined, we can now start modifying our observations and rewards in order to train a policy to act as a controller for the Jetbot. As a user, we would like to be able to specify the desired direction f

isaac-sim.github.io

또한 해당 예제를 통해 같은 종류의 이륜 로봇의 방향을 제어하는 예제 코드를 기반으로 시작하였다.

주로 수정한 파일은 Task의 env.py 파일이다.

https://github.com/isaac-sim/IsaacLabTutorial/blob/jetbot-intro-1-2/source/isaac_lab_tutorial/isaac_lab_tutorial/tasks/direct/isaac_lab_tutorial/isaac_lab_tutorial_env.py

1. RL 에이전트가 수행할 작업(Task) 변경

원래 코드

- _reset_idx 함수에서 self.commands라는 임의의 방향 벡터 생성

- 에이전트가 self.commands 벡터 방향으로 최대한 정렬, 해당 방향으로 빠르게 나아가는 것이 목표

- 목표 시각화를 위한 waypoint 마커가 존재

수정된 코드

- _reset_idx 함수에서 self.waypoint_locations 목표 좌표 생성

- self.commands 벡터 생성은 삭제

- 에이전트는 현재 위치에서 self.waypoint_locations까지 스스로 경로를 찾아 도달하는 것이 목표

- 조금 더 복잡하고 일반적인 내비게이션(Navigation) 문제

2. 시각화(Visualization) 마커 로직 변경

학습 환경 시각화를 도와주는 마커(_visualize_markers) 작동 방식 변경

원래 코드

- forward 마커(파란색 화살표)는 로봇의 전진 방향 벡터 표시

- command 마커(빨간색 화살표)는 임의로 생성된 self.commands 벡터 방향 표시

수정된 코드

- waypoint 마커 추가해 목표 지점 (녹색 화살표) 시각화

- command 마커가 현재 로봇 위치에서 목표 지점(waypoint)을 가리키는 방향을 실시간으로 계산

- 현재 로봇이 목표를 향해 주행중인지 직관적으로 파악 가능

3. 관측 (_get_observations) 재구성

원래 코드

- 로봇의 foward.commands 와 self.commands 벡터 간의 관계 관측

- dot: 두 벡터의 내적 (방향 일치도).

- cross: 두 벡터의 외적 (방향 차이).

- forward_speed: 로봇의 전진 속도.

수정된 코드

- 목표 지점 도달에 필수적인 정보들로 관측 데이터 구성

- vec_to_target_local: 로봇의 현재 위치와 방향 기준 목표 지점까지의 상대 위치 벡터

- robot_lin_vel_local: 로봇의 로컬 좌표계 기준 선속도

- robot_ang_vel_local: 로봇의 로컬 좌표계 기준 각속도

4. 보상 (Reward) 시스템 설계 변경 (_get_rewards)

원래 코드

- 전진 속도 보상 (forward_reward)

- 명령 방향 정렬 보상 (alignment_reward)

수정된 코드

- 목표 지점 도달을 위한 복합적이고 정교한 보상 구조 도입

- progress_reward: 목표 지점과의 거리에 따른 보상 (포텐셜 기반)

- velocity_reward: 목표 지점을 향해 움직이는 속도에 대한 보상

- heading_reward: 로봇이 목표 지점을 바라보도록 유도하는 보상

- success_reward: 목표 근접 시 주어지는 큰 성공 보상

- action_penalty, time_penalty: 불필요한 움직임, 시간 단축을 위한 페널티

- 이론 지식이 부족해서 대부분의 시간이 Reward function 수정에 소요

5. episode 관리 로직 변경 (_get_dones, _reset_idx)

원래 코드

- 종료 조건: 최대 스텝 도달 시

- 리셋: 무작위 '방향' 벡터(commands) 생성

수정된 코드

- 종료 조건: 목표 지점 도달 조건 추가

- 리셋: 무작위 '목표 지점'(waypoint_locations) 반경 내 생성

- 리셋 시, 거리 기반 보상(potentials) 값 초기화

6. env_cfg 설정 변경

- 환경 이름 외부 프로젝트(Myfirstcar)에 맞춰 수정

- robot_cfg를 jetbot에서 직접 설계한 이륜 로봇으로 교체 (ground plane 간섭 방지용 pos 옵션 추가)

- episode 세션 시간 2배로 증가(waypoint 도달 전에 episode 종료 막음)

- action scale 값 0.5로 최적화 episode 세션 시간 2배로 증가

4800 epoch 학습 결과

스크린캐스트 2025-10-03 18-24-11.webm

2.94MB

수정된 env.py 코드

# Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

from __future__ import annotations

import math
import torch
from collections.abc import Sequence

import isaaclab.sim as sim_utils
from isaaclab.assets import Articulation
from isaaclab.envs import DirectRLEnv
from isaaclab.sim.spawners.from_files import GroundPlaneCfg, spawn_ground_plane
from isaaclab.utils.math import sample_uniform

from isaaclab.assets import RigidObject, RigidObjectCfg
from isaaclab.sensors.ray_caster import RayCaster, RayCasterCfg, patterns

from .myfirstcar_env_cfg import MyfirstcarEnvCfg

from isaaclab.markers import VisualizationMarkers, VisualizationMarkersCfg
from isaaclab.utils.timer import Timer
from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR
import isaaclab.utils.math as math_utils

def define_markers() -> VisualizationMarkers:
    """Define markers with various different shapes."""
    marker_cfg = VisualizationMarkersCfg(
        prim_path="/Visuals/myMarkers",
        markers={
                "forward": sim_utils.UsdFileCfg(
                    usd_path=f"{ISAAC_NUCLEUS_DIR}/Props/UIElements/arrow_x.usd",
                    scale=(0.25, 0.25, 0.5),
                    visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 1.0, 1.0)),
                ),
                "command": sim_utils.UsdFileCfg(
                    usd_path=f"{ISAAC_NUCLEUS_DIR}/Props/UIElements/arrow_x.usd",
                    scale=(0.25, 0.25, 0.5),
                    visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(1.0, 0.0, 0.0)),
                ),
                "waypoint": sim_utils.UsdFileCfg(
                    usd_path=f"{ISAAC_NUCLEUS_DIR}/Props/UIElements/arrow_x.usd",
                    scale=(0.3, 0.3, 0.6),
                    visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 1.0, 0.0)),
                ),
                "lidar": sim_utils.UsdFileCfg(
                    usd_path=f"{ISAAC_NUCLEUS_DIR}/Props/UIElements/arrow_x.usd",
                    scale=(0.3, 0.3, 0.6),
                    visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.5, 1.0, 0.0)),
                )
        },
    )
    return VisualizationMarkers(cfg=marker_cfg)

class MyfirstcarEnv(DirectRLEnv):
    cfg: MyfirstcarEnvCfg

    def __init__(self, cfg: MyfirstcarEnvCfg, render_mode: str | None = None, **kwargs):
        super().__init__(cfg, render_mode, **kwargs)

        self.dof_idx, _ = self.robot.find_joints(self.cfg.dof_names)
        self.action_scale = torch.tensor(self.cfg.action_scale, device=self.device)

    def _define_sensor(self) -> RayCaster:
        """Defines the ray-caster sensor to add to the scene."""
        # Lidar sensor configuration
        self.ray_caster_cfg = RayCasterCfg(
            prim_path="/World/envs/env_.*/Robot/",
            mesh_prim_paths=["/World/ground"],
            update_period=0.02,
            pattern_cfg=patterns.GridPatternCfg(resolution=0.1, size=(1.6, 1.0)),
            offset=RayCasterCfg.OffsetCfg(pos=(0.2, 0.0, 0.05)),
            ray_alignment="yaw",
            debug_vis=True,
        )
        return RayCaster(cfg=self.ray_caster_cfg)

    def _setup_scene(self):
        self.robot = Articulation(self.cfg.robot_cfg)
        # add ground plane
        spawn_ground_plane(prim_path="/World/ground", cfg=GroundPlaneCfg())
        # clone and replicate
        self.scene.clone_environments(copy_from_source=False)
        # add articulation to scene
        self.scene.articulations["robot"] = self.robot
        # add lights
        light_cfg = sim_utils.DomeLightCfg(intensity=2000.0, color=(0.75, 0.75, 0.75))
        light_cfg.func("/World/Light", light_cfg)

        self.visualization_markers = define_markers()

        # Initialize sensors and add them to the scene
        self.ray_caster = self._define_sensor()
        self.scene.sensors["lidar"] = self.lidar

        # setting aside useful variables for later
        self.up_dir = torch.tensor([0.0, 0.0, 1.0], device=self.device)
        self.waypoint_locations = torch.zeros((self.cfg.scene.num_envs, 3), device=self.device)

        # initialize buffers
        self.dist_to_target = torch.zeros(self.num_envs, device=self.device)
        self.potentials = torch.zeros(self.num_envs, device=self.device)

        self.marker_offset = torch.zeros((self.cfg.scene.num_envs, 3), device=self.device)
        self.marker_offset[:,-1] = 0.5

    def _visualize_markers(self):
        # get marker locations and orientations
        robot_locations = self.robot.data.root_pos_w + self.marker_offset
        forward_orientations = self.robot.data.root_quat_w

        # Command marker points towards the waypoint
        vec_to_target = self.waypoint_locations - robot_locations
        vec_to_target[:, 2] = 0

        # Normalize the target vector
        vec_to_target_norm = torch.linalg.norm(vec_to_target, dim=1, keepdim=True)
        vec_to_target_safe = vec_to_target / (vec_to_target_norm + 1e-6)

        # The command marker (arrow_x.usd) points along the x-axis by default.
        # This is our starting vector for the rotation calculation.
        start_vec = torch.tensor([1.0, 0.0, 0.0], device=self.device).expand_as(vec_to_target_safe)

        # Calculate angle and axis for rotation
        dot_product = torch.sum(start_vec * vec_to_target_safe, dim=-1).clamp(-1.0, 1.0)
        angle = torch.acos(dot_product)
        axis = torch.cross(start_vec, vec_to_target_safe, dim=-1)

        # Normalize the rotation axis
        axis_norm = torch.linalg.norm(axis, dim=-1, keepdim=True)
        # Handle cases where vectors are collinear (axis norm is near zero)
        up_vec = torch.tensor([0.0, 0.0, 1.0], device=self.device).expand_as(axis)
        axis = torch.where(axis_norm > 1e-6, axis / (axis_norm + 1e-8), up_vec)

        # Create quaternion from angle and axis
        command_orientations = math_utils.quat_from_angle_axis(angle, axis)

        # -- waypoint marker is at the target location
        waypoint_locations = self.waypoint_locations
        # waypoint orientation is fixed (identity)
        waypoint_orientations = torch.tensor([-0.7071, 0.0, -0.7071, 0.0], device=self.device).repeat(self.num_envs, 1)

        # stack all marker information
        locs = torch.vstack((robot_locations, robot_locations, waypoint_locations))
        rots = torch.vstack((forward_orientations, command_orientations, waypoint_orientations))

        # render the markers
        all_envs = torch.arange(self.num_envs, device=self.device)
        indices = torch.hstack((torch.zeros_like(all_envs), torch.ones_like(all_envs), torch.full_like(all_envs, 2)))
        self.visualization_markers.visualize(locs, rots, marker_indices=indices)

    def _pre_physics_step(self, actions: torch.Tensor) -> None:
        self.actions = actions.clone()
        self._visualize_markers()

    def _apply_action(self) -> None:
        # apply action scaling
        scaled_actions = self.actions * self.action_scale
        self.robot.set_joint_velocity_target(scaled_actions, joint_ids=self.dof_idx)

    def _get_observations(self) -> dict:
        # robot position and orientation
        robot_pos = self.robot.data.root_pos_w
        robot_quat = self.robot.data.root_quat_w

        # vector to target in world frame
        self.vec_to_target_world = self.waypoint_locations - robot_pos
        self.dist_to_target = torch.norm(self.vec_to_target_world[:, :2], p=2, dim=-1)

        # vector to target in robot's local frame
        vec_to_target_local = math_utils.quat_apply_inverse(robot_quat, self.vec_to_target_world)

        # robot velocities
        robot_lin_vel_local = math_utils.quat_apply_inverse(robot_quat, self.robot.data.root_lin_vel_w)
        robot_ang_vel_local = math_utils.quat_apply_inverse(robot_quat, self.robot.data.root_ang_vel_w)

        # lidar data - 거리 값만 사용
    #lidar_scan = self.lidar.data.distance.squeeze(1) # (num_envs, num_rays)

        # observations
        obs = torch.cat(
            (
                vec_to_target_local,
                robot_lin_vel_local,
                robot_ang_vel_local,
                #lidar_scan,
            ),
            dim=-1,
        )

        observations = {"policy": obs}
        return observations

    def _get_rewards(self) -> torch.Tensor:
        # -- distance-based reward (potential-based)
        progress_reward = 2.0 * (self.potentials - self.dist_to_target)
        self.potentials = self.dist_to_target.clone()

        # -- velocity reward (towards target)
        # get the unit vector to the target
        vec_to_target_unit = self.vec_to_target_world / (torch.norm(self.vec_to_target_world, dim=1, keepdim=True) + 1e-6)
        # project the robot's velocity onto the vector to the target
        velocity_to_target = torch.sum(self.robot.data.root_lin_vel_w * vec_to_target_unit, dim=1)
        # reward for moving towards the target
        velocity_reward = 1.0 * torch.clamp(velocity_to_target, min=0)

        # -- orientation reward (facing target)
        # get the robot's forward direction vector
        forward_vec = torch.tensor([1.0, 0.0, 0.0], device=self.device).repeat(self.num_envs, 1)
        robot_fwd_vec = math_utils.quat_apply(self.robot.data.root_quat_w, forward_vec)
        # compute the cosine similarity to reward facing the target
        heading_reward = 0.1 * torch.sum(robot_fwd_vec * vec_to_target_unit, dim=1)

        # -- success reward
        success_reward = torch.zeros_like(progress_reward)
        success_reward[self.dist_to_target < 0.5] = 50.0
        # reward for reaching the goal

        # -- action penalty
        action_penalty = -0.001 * torch.sum(torch.square(self.actions), dim=-1)

        # -- time penalty (to encourage speed)
        time_penalty = -0.01

        # -- total reward
        total_reward = (
            progress_reward
            + velocity_reward
            + heading_reward
            + success_reward
            + action_penalty
            + time_penalty
        )
        return total_reward.unsqueeze(1)

    def _get_dones(self) -> tuple[torch.Tensor, torch.Tensor]:
        time_out = self.episode_length_buf >= self.max_episode_length - 1

        # reset if goal is reached
        reset_goal = self.dist_to_target < 0.5

        return reset_goal, time_out

    def _reset_idx(self, env_ids: Sequence[int] | None):
        if env_ids is None:
            env_ids = self.robot._ALL_INDICES
        super()._reset_idx(env_ids)

        # -- Waypoint goal
        # sample new goal locations
        radius_minimum = 0.5
        radius = 4.5
        rand_dist = torch.rand(len(env_ids), device=self.device) * radius + radius_minimum
        rand_angle = torch.rand(len(env_ids), device=self.device) * 2 * math.pi
        # set the new goals
        self.waypoint_locations[env_ids, 0] = self.scene.env_origins[env_ids, 0] + rand_dist * torch.cos(rand_angle)
        self.waypoint_locations[env_ids, 1] = self.scene.env_origins[env_ids, 1] + rand_dist * torch.sin(rand_angle)
        self.waypoint_locations[env_ids, 2] = 0.3
        # fixed height

        # set the root state for the reset envs
        default_root_state = self.robot.data.default_root_state[env_ids]
        default_root_state[:, :3] += self.scene.env_origins[env_ids]

        self.robot.write_root_state_to_sim(default_root_state, env_ids)

        # reset potentials
        robot_pos = self.robot.data.root_pos_w[env_ids]
        vec_to_target_world = self.waypoint_locations[env_ids] - robot_pos
        self.dist_to_target[env_ids] = torch.norm(vec_to_target_world[:, :2], p=2, dim=-1)
        self.potentials[env_ids] = self.dist_to_target[env_ids].clone()
        # self.lidar.reset(env_ids)
        self._visualize_markers()

수정된 env_cfg.py 코드

# Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

from MyFirstCar.robots.jetbot import JETBOT_CONFIG

from isaaclab.assets import ArticulationCfg
from isaaclab.envs import DirectRLEnvCfg
from isaaclab.scene import InteractiveSceneCfg
from isaaclab.sim import SimulationCfg
from isaaclab.utils import configclass

@configclass
class MyfirstcarEnvCfg(DirectRLEnvCfg):
    # env
    decimation = 2
    episode_length_s = 10.0
    # - spaces definition
    action_space = 2
    observation_space = 3  #Lidar scan data
    state_space = 0
    # simulation
    sim: SimulationCfg = SimulationCfg(dt=1 / 120, render_interval=decimation)
    # robot(s)
    robot_cfg: ArticulationCfg = JETBOT_CONFIG.replace(prim_path="/World/envs/env_.*/Robot",init_state=ArticulationCfg.InitialStateCfg(
        pos=(0.0, 0.0, 0.8)))

    # scene
    scene: InteractiveSceneCfg = InteractiveSceneCfg(num_envs=16, env_spacing=20, replicate_physics=True)
    dof_names = ["wheel_joint_left", "wheel_joint_right"]
    action_scale = (0.5, 0.5)