ಫ್ರೀಜ್-ಟ್ಯಾಗ್

Jules David

ಸೋಮವಾರ, ಸೆಪ್ಟೆಂಬರ್ 23, 2024 07:44:32 ಪೂರ್ವಾಹ್ನ

ರೇ ಮತ್ತು ಪೈಗೇಮ್‌ನೊಂದಿಗೆ ಕಸ್ಟಮ್ ಪರಿಸರಗಳನ್ನು ಸಲ್ಲಿಸುವಲ್ಲಿ ಸವಾಲುಗಳು

ಫ್ರೀಜ್-ಟ್ಯಾಗ್‌ನಂತಹ ಸಂಕೀರ್ಣ ಸಿಮ್ಯುಲೇಶನ್‌ಗಳಿಗಾಗಿ ಪೈಥಾನ್‌ನಲ್ಲಿ ಕಸ್ಟಮ್ ಪರಿಸರವನ್ನು ರಚಿಸುವುದು ಆಗಾಗ್ಗೆ ಅನಿರೀಕ್ಷಿತ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು, ವಿಶೇಷವಾಗಿ ಬಹು-ಏಜೆಂಟ್ ತರಬೇತಿಗಾಗಿ ರೇ ನಂತಹ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ. ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ, ಫ್ರೀಜ್-ಟ್ಯಾಗ್ ಪರಿಸ್ಥಿತಿಯನ್ನು ಅನುಕರಿಸಲು ಬಳಕೆದಾರರು ಪೈಗೇಮ್‌ನೊಂದಿಗೆ ಜಿಮ್ ಪರಿಸರವನ್ನು ರಚಿಸಿದ್ದಾರೆ, ಆದರೆ ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ಪರಿಸರವನ್ನು ನಿರೂಪಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ ಸಮಸ್ಯೆಗಳಿಗೆ ಸಿಲುಕುತ್ತಾರೆ.

ಮೂಲಭೂತ ಸಮಸ್ಯೆಯೆಂದರೆ, ಸಿಮ್ಯುಲೇಶನ್ ಉದ್ದೇಶಿತವಾಗಿ ನಿರೂಪಿಸುವುದಿಲ್ಲ ಮತ್ತು ಅನೇಕ ಪೈಗೇಮ್ ವಿಂಡೋಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ತರಬೇತಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸುತ್ತದೆ. ಜಿಮ್ ಪರಿಸರದ ಇತರ ಅಂಶಗಳು ವಿವಿಧ ವಿಧಾನಗಳೊಂದಿಗೆ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೂ ಸಹ, ರೇ ಅವರ ಮಲ್ಟಿ-ಏಜೆಂಟ್ ಪ್ರಾಕ್ಸಿಮಲ್ ಪಾಲಿಸಿ ಆಪ್ಟಿಮೈಸೇಶನ್ (MAPPO) ಅಲ್ಗಾರಿದಮ್ ಈ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ.

ವಿತರಿಸಲಾದ ತರಬೇತಿಗಾಗಿ ರೇ ಅದ್ಭುತ ಚೌಕಟ್ಟಾಗಿದೆ, ಆದರೆ ಪೈಗೇಮ್‌ನಂತಹ ರೆಂಡರಿಂಗ್ ಲೈಬ್ರರಿಗಳೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಇದು ವಿಂಡೋ ಉತ್ಪಾದನೆ ಮತ್ತು ರೆಂಡರಿಂಗ್ ಬದಲಾವಣೆಗಳ ಎಚ್ಚರಿಕೆಯ ನಿರ್ವಹಣೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ. ಈ ಕಾಳಜಿಗಳನ್ನು ಪರಿಹರಿಸದೆಯೇ, ತರಬೇತಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ಥಗಿತಗೊಳಿಸಬಹುದು, ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ನಿರಾಶಾದಾಯಕ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಮುಂದಿನ ಚರ್ಚೆಯಲ್ಲಿ, ಈ ರೆಂಡರಿಂಗ್ ತೊಂದರೆಗಳ ಸಂಭವನೀಯ ಕಾರಣಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ ಮತ್ತು ತಡೆರಹಿತ ಸಿಮ್ಯುಲೇಶನ್ ಅನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿರ್ದಿಷ್ಟ ಪರಿಹಾರಗಳನ್ನು ಒದಗಿಸುತ್ತೇವೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, Ray ನಲ್ಲಿ MAPPO ತರಬೇತಿಗಾಗಿ PyGame ಡಿಸ್ಪ್ಲೇ ಕಾರ್ಯನಿರ್ವಹಣೆಯನ್ನು ಇರಿಸಿಕೊಂಡು ಅನೇಕ ವಿಂಡೋ ನಿದರ್ಶನಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸುವುದು ಹೇಗೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ.

ಆಜ್ಞೆ	ಬಳಕೆಯ ಉದಾಹರಣೆ
pygame.display.set_mode()	PyGame ನ ರೆಂಡರಿಂಗ್ ವಿಂಡೋವನ್ನು ಈ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಲಾಗಿದೆ. ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ, ನಕಲು ವಿಂಡೋಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ರೇ ಅನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ.
pygame.draw.circle()	ಪರಿಸರದಲ್ಲಿರುವ ಪ್ರತಿ ಏಜೆಂಟ್ ಅನ್ನು ವೃತ್ತವನ್ನಾಗಿ ಮಾಡುತ್ತದೆ. ಫ್ರೀಜ್-ಟ್ಯಾಗ್ ಆಟದಲ್ಲಿ ಏಜೆಂಟ್‌ಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸುವಲ್ಲಿ ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಬಣ್ಣವನ್ನು ಆಧರಿಸಿ ಅವರ ಸ್ಥಿತಿಯನ್ನು ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ.
pygame.display.flip()	ರೆಂಡರಿಂಗ್ ಸಮಯದಲ್ಲಿ ಸಂಭವಿಸಿದ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸಲು ಪ್ರದರ್ಶನವನ್ನು ನವೀಕರಿಸುತ್ತದೆ. ಪರಿಸರದ ಗ್ರಾಫಿಕ್ಸ್ ಪ್ರತಿ ಬಾರಿಯ ಹಂತದೊಂದಿಗೆ ಬದಲಾಗುತ್ತದೆ ಎಂದು ಖಾತರಿಪಡಿಸಲು ಇದು ಬಹಳ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ray.init()	ವಿತರಣಾ ಪ್ರಕ್ರಿಯೆಗಾಗಿ ರೇ ಅನ್ನು ಆರಂಭದಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ. ಈ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ಸಿಮ್ಯುಲೇಶನ್‌ನಲ್ಲಿ ಹಲವಾರು ಏಜೆಂಟ್‌ಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸಲು ಇದು ಸಮಾನಾಂತರ ರೋಲ್‌ಔಟ್ ಕೆಲಸಗಾರರನ್ನು ಶಕ್ತಗೊಳಿಸುತ್ತದೆ.
register_env()	ರೇ ಜೊತೆಗೆ ಕಸ್ಟಮ್ ಜಿಮ್ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ನೋಂದಾಯಿಸುತ್ತದೆ, ಇದನ್ನು ಬಹು-ಏಜೆಂಟ್ ತರಬೇತಿಗಾಗಿ ಬಳಸಿಕೊಳ್ಳಲು ಅನುಮತಿಸುತ್ತದೆ. ತರಬೇತಿ ಲೂಪ್‌ನಲ್ಲಿರುವಾಗ ರೇ ಪರಿಸರವನ್ನು ಗುರುತಿಸುತ್ತಾರೆ ಎಂದು ಖಾತರಿಪಡಿಸಲು ಇದು ಅಗತ್ಯವಿದೆ.
algo.train()	ಇದು ರೇ ಚೌಕಟ್ಟಿನೊಳಗೆ PPO ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಏಜೆಂಟರ ತರಬೇತಿ ಹಂತವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ಫಲಿತಾಂಶಗಳು ಏಜೆಂಟ್ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಪ್ರತಿಫಲಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
rollouts()	ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ಬಳಸಿಕೊಳ್ಳಲು ರೋಲ್ಔಟ್ ಸಿಬ್ಬಂದಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಈ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, MAPPO ತರಬೇತಿಗಾಗಿ ಕಾರ್ಮಿಕರಲ್ಲಿ ಪರಿಸರವನ್ನು ಸರಿಯಾಗಿ ವಿತರಿಸಲಾಗಿದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
create_env_on_local_worker=True	ರೇಯಲ್ಲಿನ ನಿರ್ಣಾಯಕ ನಿಯತಾಂಕವು ಪರಿಸರವನ್ನು ಒಬ್ಬ ಕೆಲಸಗಾರನಿಗೆ ಸ್ಥಳೀಯವಾಗಿ ಉತ್ಪಾದಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ರೆಂಡರಿಂಗ್ ವಿಂಡೋದ ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ವಿಂಡೋ ನಿದರ್ಶನಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
config.build()	PPO ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ತರಬೇತಿಗಾಗಿ ಸಿದ್ಧವಾಗಿರುವ ಅಲ್ಗಾರಿದಮ್ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿ ಪರಿವರ್ತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಪರಿಸರ, ಮಾದರಿ ರಚನೆ ಮತ್ತು ರೋಲ್‌ಔಟ್‌ಗಳಂತಹ ಸೆಟಪ್ ನಿಯತಾಂಕಗಳನ್ನು ಒಟ್ಟಿಗೆ ತರುತ್ತದೆ.

ಪೈಗೇಮ್‌ನೊಂದಿಗೆ ರೇನಲ್ಲಿ ರೆಂಡರಿಂಗ್ ಮತ್ತು ತರಬೇತಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ನೀಡಲಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ರೇ ಅವರ ಮಲ್ಟಿ-ಏಜೆಂಟ್ ಪ್ರಾಕ್ಸಿಮಲ್ ಪಾಲಿಸಿ ಆಪ್ಟಿಮೈಸೇಶನ್ (MAPPO) ತಂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಬೆಸ್ಪೋಕ್ ಜಿಮ್ ಪರಿಸರವನ್ನು ನಿರೂಪಿಸುವಾಗ ಎದುರಾಗುವ ಎರಡು ಪ್ರಾಥಮಿಕ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸಲು ಉದ್ದೇಶಿಸಲಾಗಿದೆ. ಮೊದಲ ಸಂಚಿಕೆಯು ಹಲವಾರು PyGame ವಿಂಡೋಗಳ ರಚನೆಯನ್ನು ತಡೆಯುತ್ತದೆ. ಎಚ್ಚರಿಕೆಯ ವಿಂಡೋ ನಿರ್ಮಾಣ ತರ್ಕವನ್ನು ಬಳಸಿಕೊಂಡು ಒಮ್ಮೆ ಮಾತ್ರ PyGame ಪ್ರದರ್ಶನವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಇದನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತದೆ. ನಾವು ಬಳಸುತ್ತೇವೆ pygame.display.set_mode() ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ಕೇವಲ ಒಂದು ವಿಂಡೋವನ್ನು ಮಾತ್ರ ರಚಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪ್ರದರ್ಶನವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆಯೇ ಎಂಬ ಪರಿಶೀಲನೆಯೊಳಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಎರಡನೆಯ ಪ್ರಮುಖ ಸಾಮರ್ಥ್ಯವೆಂದರೆ ನಿರೂಪಿಸಲು ವಿಧಾನ, ಇದು ಪರಿಸರದ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ಪ್ರತಿ ಬಾರಿಯ ಉದ್ದಕ್ಕೂ ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಪರಿಸರದಲ್ಲಿರುವ ಏಜೆಂಟ್‌ಗಳನ್ನು ಬಳಸಿ ಚಿತ್ರಿಸಲಾಗಿದೆ pygame.draw.circle(), ಅವರ ಸ್ಥಾನ ಮತ್ತು ಬಣ್ಣವು ಅವರ ಸ್ಥಿತಿಯನ್ನು ಅವಲಂಬಿಸಿ ನಿರಂತರವಾಗಿ ಮಾರ್ಪಡಿಸಲ್ಪಡುತ್ತದೆ. ಫ್ರೀಜ್-ಟ್ಯಾಗ್ ಸನ್ನಿವೇಶದಲ್ಲಿ ಯಾವ ಏಜೆಂಟ್‌ಗಳನ್ನು ಫ್ರೀಜ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಅವು ಇನ್ನೂ ಸಕ್ರಿಯವಾಗಿವೆ ಎಂಬುದನ್ನು ನೋಡಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ದಿ pygame.display.flip() ವಿಧಾನವು ಪ್ರತಿ ರೆಂಡರಿಂಗ್ ಹಂತದ ನಂತರ ಪ್ರದರ್ಶನವನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡುತ್ತದೆ, ಪರಿಸರವು ಏಜೆಂಟ್‌ಗಳ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಕಸ್ಟಮ್ ಪರಿಸರವನ್ನು ರೇಗೆ ಹೇಗೆ ಸಂಯೋಜಿಸುವುದು ಎಂಬುದನ್ನು ಸ್ಕ್ರಿಪ್ಟ್ ತೋರಿಸುತ್ತದೆ. ದಿ env_creator ಕಾರ್ಯವು ರೇ ಮೂಲಕ ಪರಿಸರವನ್ನು ನೋಂದಾಯಿಸುತ್ತದೆ register_env() ಕಾರ್ಯ. ರೇ ಅವರ ತರಬೇತಿ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಈಗ ಕಸ್ಟಮೈಸ್ ಮಾಡಿದ ಫ್ರೀಜ್-ಟ್ಯಾಗ್ ಪರಿಸರವನ್ನು ಪತ್ತೆಹಚ್ಚಬಹುದು ಮತ್ತು ಬಳಸಬಹುದು. ಇದಲ್ಲದೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುತ್ತದೆ ray.init() ರೇ ಸ್ಥಾಪಿಸಲು ಮತ್ತು ತರಬೇತಿಯನ್ನು ಹಲವಾರು ಕೆಲಸಗಾರರಿಗೆ ವಿತರಿಸಬಹುದೆಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು. ಆದಾಗ್ಯೂ, ಈ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಹಲವಾರು ಕಾರ್ಮಿಕರಾದ್ಯಂತ ವಿಂಡೋ ರೆಂಡರಿಂಗ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಸಂಕೀರ್ಣತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಒಬ್ಬ ರೋಲ್‌ಔಟ್ ಕೆಲಸಗಾರನನ್ನು ಮಾತ್ರ ಬಳಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ.

ಅಂತಿಮವಾಗಿ, ತರಬೇತಿ ಲೂಪ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ algo.train() ಕಾರ್ಯ, ಒದಗಿಸಿದ ಸಂಚಿಕೆಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಸಮಯದ ಹಂತಗಳಿಗೆ ತರಬೇತಿ ವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ಫಲಿತಾಂಶಗಳು ಸರಾಸರಿ ಪ್ರತಿಫಲ ಮತ್ತು ಒಟ್ಟು ನಷ್ಟಗಳಂತಹ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಏಜೆಂಟ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ಕುರಿತು ಪ್ರಮುಖ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡುತ್ತವೆ. ನಂತಹ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿಸುವುದು ರೋಲ್ಔಟ್_ಫ್ರಾಗ್ಮೆಂಟ್_ಉದ್ದ ಮತ್ತು ರೈಲು_ಬ್ಯಾಚ್_ಗಾತ್ರ ತರಬೇತಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು. ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯುಲರ್ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳಬಲ್ಲದು, ಆದ್ದರಿಂದ ಇದನ್ನು ರೇ ಮತ್ತು ಪೈಗೇಮ್ ಒಳಗೊಂಡಿರುವ ಬಹು-ಏಜೆಂಟ್ ಬಲವರ್ಧನೆಯ ಕಲಿಕೆಯ ಸಮಸ್ಯೆಗಳಿಗೆ ಬಳಸಬಹುದು.

ಬಹು ಪೈಗೇಮ್ ವಿಂಡೋಸ್ ಸಮಸ್ಯೆಗಳನ್ನು ಸರಿಪಡಿಸುವುದು ಮತ್ತು ರೇ ಅವರ MAPPO ಸೆಟಪ್‌ನಲ್ಲಿ ರೆಂಡರಿಂಗ್ ಅನ್ನು ಸುಧಾರಿಸುವುದು.

ವಿಧಾನ 1: ಪೈಥಾನ್, PyGame ಮತ್ತು Ray's MAPPO ನೊಂದಿಗೆ ವಿಂಡೋ ನಿರ್ವಹಣೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ.

import pygame
from ray import init, shutdown
from ray.rllib.algorithms.ppo import PPOConfig
from ray.tune.registry import register_env
def render(self):
    if not hasattr(self, 'initialized') or not self.initialized:
        pygame.display.set_mode([1000, 1000])  # Prevent multiple windows
        self.initialized = True
    self.screen.fill((255, 255, 255))
    for agent in self.all_agents:
        color = agent.color if agent.status == 1 else (0, 255, 255)
        pygame.draw.circle(self.screen, color, (agent.x, agent.y), agent.size)
    pygame.display.flip()
def env_creator(config):
    return MyCustomEnv(screen=pygame.display.get_surface())  # Use existing display
register_env("Env_FTP", env_creator)
def train_and_evaluate(time_steps):
    init(ignore_reinit_error=True)
    config = PPOConfig().environment("Env_FTP").rollouts(num_rollout_workers=1)
    algo = config.build()
    for _ in range(episodes):
        results = algo.train()
    shutdown()

ರೇ ಜೊತೆ ಪೈಗೇಮ್‌ನಲ್ಲಿ ರೆಂಡರಿಂಗ್ ಮತ್ತು ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಮಲ್ಟಿಪಲ್ ಏಜೆಂಟ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು

ವಿಧಾನ 2: ಪರಿಸರವನ್ನು ಮಾಡ್ಯುಲರೈಸ್ ಮಾಡುವುದು ಮತ್ತು ಪೈಥಾನ್ ಮತ್ತು ರೇ ಬಳಸಿ ರೆಂಡರ್ ಲಾಜಿಕ್ ಅನ್ನು ಪ್ರತ್ಯೇಕಿಸುವುದು

import ray
from ray.rllib.algorithms.ppo import PPOConfig
import pygame
class EnvWithRendering:
    def __init__(self, screen, agents, adversaries, time_steps):
        self.screen = screen
        self.agents = agents
        self.adversaries = adversaries
        self.time_steps = time_steps
    def render(self):
        pygame.init()
        self.screen.fill((255, 255, 255))
        for agent in self.agents:
            color = agent.color if agent.status == 1 else (0, 255, 255)
            pygame.draw.circle(self.screen, color, (agent.x, agent.y), agent.size)
        pygame.display.update()
def env_creator(config):
    return EnvWithRendering(pygame.display.set_mode([1000, 1000]), 5, 2, 500)
ray.init()
register_env("Env_FTP", env_creator)
config = PPOConfig().rollouts(num_rollout_workers=1)
algo = config.build()
algo.train()

ಸರಿಯಾದ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ರೆಂಡರಿಂಗ್ನೊಂದಿಗೆ ರೇ ಅವರ ಬಹು-ಏಜೆಂಟ್ ತರಬೇತಿಯನ್ನು ಹೆಚ್ಚಿಸುವುದು

ರೆಂಡರಿಂಗ್ ಮತ್ತು ಏಜೆಂಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ದೋಷರಹಿತವಾಗಿ ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಖಾತ್ರಿಪಡಿಸುವುದು ಬೆಸ್ಪೋಕ್ ಪರಿಸರದಲ್ಲಿ ರೇ ಅವರ MAPPO ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಂಯೋಜಿಸುವ ನಿರ್ಣಾಯಕ ಅಂಶವಾಗಿದೆ. ಫ್ರೀಜ್-ಟ್ಯಾಗ್‌ನಂತಹ ಬಹು-ಏಜೆಂಟ್ ಸನ್ನಿವೇಶದಲ್ಲಿ, ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ಏಜೆಂಟ್ ಚಟುವಟಿಕೆಯನ್ನು ವೀಕ್ಷಿಸಲು ದೃಶ್ಯ ಇನ್‌ಪುಟ್ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ಪೈಗೇಮ್ ವಿಂಡೋಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ರೆಂಡರಿಂಗ್‌ನಲ್ಲಿನ ಪ್ರಾಥಮಿಕ ತೊಂದರೆಯು ಆಗಾಗ್ಗೆ ಸಂಪರ್ಕಗೊಳ್ಳುತ್ತದೆ. ಹಲವಾರು ವಿಂಡೋಗಳನ್ನು ತೆರೆಯುವುದನ್ನು ತಡೆಯಲು, ಷರತ್ತುಬದ್ಧ ತಪಾಸಣೆಗಳೊಂದಿಗೆ ಪೈಗೇಮ್ ವಿಂಡೋದ ಪ್ರಾರಂಭವನ್ನು ನಿರ್ವಹಿಸುವುದು ಒಂದು ಕಾರ್ಯಸಾಧ್ಯವಾದ ವಿಧಾನವಾಗಿದೆ. ಪರಿಸರವು ಸೂಕ್ತವಾಗಿ ಮತ್ತು ಅತಿಯಾದ ಓವರ್ಹೆಡ್ ಇಲ್ಲದೆ ನಿರೂಪಿಸುತ್ತದೆ ಎಂದು ಇದು ಖಾತರಿಪಡಿಸುತ್ತದೆ.

ಮತ್ತೊಂದು ಪ್ರಮುಖ ಪರಿಗಣನೆಯೆಂದರೆ ಏಜೆಂಟ್‌ಗಳ ನಡವಳಿಕೆಗಳನ್ನು ಸಿಮ್ಯುಲೇಶನ್‌ನಲ್ಲಿ ಹೇಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ. ರೇ ಅವರ ರೋಲ್‌ಔಟ್‌ಗಳು ವಿಭಿನ್ನ ಸಮಯ ಹಂತಗಳ ಅನುಭವಗಳನ್ನು ಹೇಗೆ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಏಜೆಂಟ್‌ಗಳಿಗೆ ಶಿಕ್ಷಣ ನೀಡಲು ಹೇಗೆ ಬಳಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಿರ್ದೇಶಿಸುತ್ತದೆ. ಪ್ರತಿ ಏಜೆಂಟ್ ಕ್ರಿಯೆಯನ್ನು ಮಾಡಿದಾಗ, ಪ್ರಾತಿನಿಧ್ಯವು ಅವರ ಹೊಸ ಸ್ಥಾನಗಳು ಮತ್ತು ರಾಜ್ಯಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸಬೇಕು. ಪೈಗೇಮ್ಸ್ pygame.display.flip() ಆಜ್ಞೆಯು ಇಲ್ಲಿ ಪ್ರಮುಖವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ನೈಜ ಸಮಯದಲ್ಲಿ ಪರದೆಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ, ಸಿಮ್ಯುಲೇಶನ್‌ನಾದ್ಯಂತ ಎಲ್ಲಾ ಏಜೆಂಟ್‌ಗಳ ಚಲನೆಗಳು ಮತ್ತು ಸ್ಥಿತಿಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿನ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಹಂತವೆಂದರೆ ರೇ ಮತ್ತು ಪೈಗೇಮ್ ನಡುವಿನ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡುವುದು. ವಿತರಿಸಲಾದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ನಿರ್ವಹಿಸುವ ರೇ ಅವರ ಸಾಮರ್ಥ್ಯವು ಪ್ರಭಾವಶಾಲಿಯಾಗಿದೆ, ಆದರೆ ದೃಶ್ಯ ರೆಂಡರಿಂಗ್ ಅಗತ್ಯವಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಳಸಿದಾಗ ಅದನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಬೇಕು. ರೇ ಅನ್ನು ಬಳಸುವುದು ಕ್ರಿಯೇಟ್_ಎನ್ವಿ_ಆನ್_ಲೋಕಲ್_ವರ್ಕರ್ ವಾದದ ಪ್ರಕಾರ, ರೆಂಡರಿಂಗ್ ಮಾಡುವ ಕೆಲಸಗಾರನ ಮೇಲೆ ಪರಿಸರವನ್ನು ಸ್ಥಳೀಯವಾಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆ, ತೆರೆದ ಕಿಟಕಿಗಳಿಗಾಗಿ ಹಲವಾರು ಕೆಲಸಗಾರರು ಸ್ಪರ್ಧಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ವಿತರಿಸಿದ ಕಲಿಕೆ ಮತ್ತು ನಿಖರವಾದ ರೆಂಡರಿಂಗ್‌ನ ಈ ಮಿಶ್ರಣವು ಯಶಸ್ವಿ ಸಿಮ್ಯುಲೇಶನ್‌ನಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುತ್ತದೆ, ಇದನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಹಲವಾರು ಏಜೆಂಟ್‌ಗಳಿಗೆ ಕಲಿಸಲು ಸುಲಭವಾಗಿ ವಿಸ್ತರಿಸಬಹುದು.

ಬಹು-ಏಜೆಂಟ್ ಪರಿಸರದಲ್ಲಿ ರೇ ಮತ್ತು ಪೈಗೇಮ್ ರೆಂಡರಿಂಗ್ ಕುರಿತು ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

ಬಹು PyGame ವಿಂಡೋಗಳು ತೆರೆಯುವುದನ್ನು ತಡೆಯುವುದು ಹೇಗೆ?
ಬಹು ಆರಂಭಗಳನ್ನು ತಪ್ಪಿಸಲು, ಕರೆ ಮಾಡುವ ಮೊದಲು ಷರತ್ತುಬದ್ಧ ಪರಿಶೀಲನೆಯನ್ನು ಬಳಸಿ pygame.display.set_mode().
ಪಾತ್ರ ಏನು rollouts ರೇ ನಲ್ಲಿ?
ರೋಲ್‌ಔಟ್‌ಗಳು ಪರಿಸರದೊಂದಿಗಿನ ಏಜೆಂಟ್ ಸಂವಹನಗಳಿಂದ ಡೇಟಾವನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತವೆ ಮತ್ತು ಉಳಿಸಿಕೊಳ್ಳುತ್ತವೆ, ನಂತರ ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ನೀತಿಯನ್ನು ನವೀಕರಿಸಲು ಬಳಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ.
ಹೇಗೆ ಮಾಡುತ್ತದೆ pygame.display.flip() ಕೆಲಸ?
ಈ ಆಜ್ಞೆಯು ಏಜೆಂಟ್‌ಗಳ ಸ್ಥಾನಗಳು ಮತ್ತು ಕ್ರಿಯೆಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಪ್ರಸ್ತುತ ಪರಿಸರದ ಸ್ಥಿತಿಯೊಂದಿಗೆ PyGame ವಿಂಡೋವನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡುತ್ತದೆ.
ರೇ ರೆಂಡರಿಂಗ್ ಮತ್ತು ತರಬೇತಿ ಎರಡನ್ನೂ ಏಕಕಾಲದಲ್ಲಿ ನಿಭಾಯಿಸಬಹುದೇ?
ರೇ ಎರಡನ್ನೂ ನಿಭಾಯಿಸಬಲ್ಲರು, ಆದರೆ create_env_on_local_worker ಸರಿಯಾದ ರೆಂಡರಿಂಗ್‌ಗಾಗಿ ಸ್ಥಳೀಯವಾಗಿ ಪರಿಸರವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.
ರೇ ತರಬೇತಿಯಲ್ಲಿ ಪೈಗೇಮ್ ವಿಂಡೋವನ್ನು ನಿಯಂತ್ರಿಸುವುದು ಏಕೆ ಮುಖ್ಯ?
ವಿಂಡೋ ಇನಿಶಿಯಲೈಸೇಶನ್ ಮೇಲೆ ನಿಯಂತ್ರಣವಿಲ್ಲದೆ, ಹಲವಾರು ವಿಂಡೋಗಳು ತೆರೆದುಕೊಳ್ಳಬಹುದು, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಕಾಳಜಿಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ ಮತ್ತು ಏಜೆಂಟ್ ನಡವಳಿಕೆಯನ್ನು ವೀಕ್ಷಿಸಲು ಅಸಾಧ್ಯವಾಗುತ್ತದೆ.

ರೇ ಮತ್ತು ಪೈಗೇಮ್ ರೆಂಡರಿಂಗ್ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವುದು

ಅಂತಿಮವಾಗಿ, ರೇ ಜೊತೆಗಿನ ಬಹು-ಏಜೆಂಟ್ ಪೈಗೇಮ್ ಸನ್ನಿವೇಶದಲ್ಲಿ ರೆಂಡರಿಂಗ್ ಸಮಸ್ಯೆಗಳನ್ನು ನಿಭಾಯಿಸಲು ವಿಂಡೋ ನಿರ್ವಹಣೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವ ಅಗತ್ಯವಿದೆ. ಪೈಗೇಮ್ ವಿಂಡೋದ ಹಲವಾರು ನಿದರ್ಶನಗಳ ಅಗತ್ಯವಿಲ್ಲದೆ ರೆಂಡರಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯು ಸರಾಗವಾಗಿ ಸಾಗುತ್ತದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಪರಿಸರ ಮತ್ತು ನಿಯತಾಂಕಗಳ ಎಚ್ಚರಿಕೆಯ ಸಂರಚನೆಯ ಅಗತ್ಯವಿದೆ.

ರೇ ಅವರ ರೋಲ್‌ಔಟ್ ಕೆಲಸಗಾರರನ್ನು ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ಮೂಲಕ ಮತ್ತು ಪರಿಸರವನ್ನು ಹೇಗೆ ರಚಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ, ನಾವು ಸಮರ್ಥ ತರಬೇತಿ ಮತ್ತು ಸರಿಯಾದ ರೆಂಡರಿಂಗ್ ಎರಡನ್ನೂ ಸಾಧಿಸುತ್ತೇವೆ. ಈ ಪರಿಹಾರವು ರೇ ಅವರ ವಿತರಣಾ ಕಲಿಕಾ ಸಾಮರ್ಥ್ಯಗಳ ಪ್ರಯೋಜನವನ್ನು ಪಡೆದುಕೊಳ್ಳುವಾಗ ಫ್ರೀಜ್-ಟ್ಯಾಗ್ ಸನ್ನಿವೇಶವನ್ನು ಉತ್ತಮವಾಗಿ ವೀಕ್ಷಿಸಲು ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅವಕಾಶ ನೀಡುವ ಮೂಲಕ ಸಿಮ್ಯುಲೇಶನ್ ವೇಗವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ರೇ ಮತ್ತು ಪೈಗೇಮ್ ಏಕೀಕರಣಕ್ಕಾಗಿ ಉಲ್ಲೇಖಗಳು ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳು

ಬಹು-ಏಜೆಂಟ್ ತರಬೇತಿಗಾಗಿ ರೇ ಅವರ RLlib ಅನ್ನು ಬಳಸುವ ಬಗ್ಗೆ ವಿವರವಾದ ದಾಖಲಾತಿಗಾಗಿ: ರೇ RLlib ಡಾಕ್ಯುಮೆಂಟೇಶನ್
PyGame ನ ರೆಂಡರಿಂಗ್ ಕಾರ್ಯಗಳು ಮತ್ತು ಬಹು ವಿಂಡೋಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಕುರಿತು ಮಾಹಿತಿ: ಪೈಗೇಮ್ ಪ್ರದರ್ಶನ ದಾಖಲೆ
ರೇ ಬಳಸಿಕೊಂಡು ವಿತರಿಸಲಾದ ತರಬೇತಿಗಾಗಿ ಸುಧಾರಿತ PPO ಸಂರಚನೆ: ರೇ PPO ಕಾನ್ಫಿಗರೇಶನ್ ಗೈಡ್
ರೇ ಜೊತೆಗೆ ಜಿಮ್ ಪರಿಸರವನ್ನು ಸಂಯೋಜಿಸಲು ಮೂಲ ಕೋಡ್ ಉದಾಹರಣೆಗಳು: ರೇ ಗಿಟ್‌ಹಬ್ ರೆಪೊಸಿಟರಿ

ಫ್ರೀಜ್-ಟ್ಯಾಗ್ ಸಿಮ್ಯುಲೇಶನ್‌ನಲ್ಲಿ ರೇ ಅವರ ಕಸ್ಟಮ್ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ರೆಂಡರಿಂಗ್ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದು