2 ಸೆಕೆಂಡುಗಳಲ್ಲಿ RL ಪೋಸ್ಟ್-ಟ್ರೈನಿಂಗ್‌ಗಾಗಿ ತೂಕ ವರ್ಗಾವಣೆ

ನಾವು ಇತ್ತೀಚೆಗೆ Kimi-K2 (1T ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು) ಗಾಗಿ 1.3-ಸೆಕೆಂಡ್ ಕ್ರಾಸ್-ಮಷೀನ್ ಪ್ಯಾರಾಮೀಟರ್ ಅಪ್‌ಡೇಟ್‌ಗಳನ್ನು ಸಾಧಿಸಿದ್ದೇವೆ, ಇದು 256 ಟ್ರೈನಿಂಗ್ GPUಗಳಿಂದ (BF16) 128 ಇನ್ಫರೆನ್ಸ್ GPUಗಳಿಗೆ (FP8) ತೂಕವನ್ನು ವರ್ಗಾಯಿಸುತ್ತದೆ.

ಅಸಿಂಕ್ರೋನಸ್ ರೀಇನ್‌ಫೋರ್ಸ್‌ಮೆಂಟ್ ಲರ್ನಿಂಗ್ ಫೈನ್-ಟ್ಯೂನಿಂಗ್‌ನಲ್ಲಿ, ಟ್ರೈನಿಂಗ್ ಮತ್ತು ಇನ್ಫರೆನ್ಸ್ ಪ್ರತ್ಯೇಕ GPUಗಳಲ್ಲಿ ರನ್ ಆಗುತ್ತವೆ. ಪ್ರತಿ ಟ್ರೈನಿಂಗ್ ಹಂತದ ನಂತರ, ಹೊಸ ತೂಕಗಳನ್ನು ಇನ್ಫರೆನ್ಸ್ ನೋಡ್‌ಗಳಿಗೆ ತಳ್ಳಬೇಕು. ಟ್ರಿಲಿಯನ್-ಪ್ಯಾರಾಮೀಟರ್ ಮಾದರಿಗಳಿಗಾಗಿ ಅನೇಕ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಹಲವಾರು ಸೆಕೆಂಡುಗಳನ್ನು—ಅಥವಾ ನಿಮಿಷಗಳನ್ನು ಸಹ—ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ.

RDMA ಪಾಯಿಂಟ್-ಟು-ಪಾಯಿಂಟ್ ಕಮ್ಯುನಿಕೇಷನ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ಇನ್ಫರೆನ್ಸ್ ಎಂಜಿನ್ ಅನ್ನು ಬದಲಾಯಿಸದೆ, ತೂಕ ವರ್ಗಾವಣೆಯನ್ನು ಅತ್ಯಂತ ವೇಗವಾಗಿ ಮಾಡಲು ಮತ್ತು ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಹಾಗೂ ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿಸಲು ನಮಗೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ನಮ್ಮ ಪರಿಹಾರವು RDMA WRITE ಅನ್ನು ಆಧರಿಸಿದೆ, ಇದು ಒನ್-ಸೈಡೆಡ್ ಪ್ರಿಮಿಟಿವ್ ಆಗಿದ್ದು, ಮೂಲವು ನೇರವಾಗಿ ಗಮ್ಯಸ್ಥಾನದ GPU ಮೆಮೊರಿಗೆ ಬರೆಯುತ್ತದೆ.

python

def rdma_write(src_ptr, dst_ptr, size, src_mr, dst_mr):
    # Write from local [src_ptr, src_ptr+size) to remote [dst_ptr, dst_ptr+size).
    # src_mr and dst_mr contains Memory Region metadata of both sides.
    ...

ವರ್ಗಾವಣೆಗಾಗಿ ಗಮ್ಯಸ್ಥಾನದ ಸೈಡ್‌ಗೆ ಯಾವುದೇ ಸೂಚನೆ ಸಿಗುವುದಿಲ್ಲ. ಇದು ನಮಗೆ ಕಡಿಮೆ-ಲೇಟೆನ್ಸಿ, ಹೆಚ್ಚಿನ ಥ್ರೋಪುಟ್, ಇನ್ಫರೆನ್ಸ್ ನೋಡ್‌ಗಳಲ್ಲಿ ಯಾವುದೇ ಕಂಟ್ರೋಲ್ ಲಾಜಿಕ್ ಇಲ್ಲದೆ ಟ್ರೈನಿಂಗ್ ನೋಡ್‌ಗಳಿಂದ ನಡೆಸಲ್ಪಡುವ ಜೀರೋ-ಕಾಪಿ ವರ್ಗಾವಣೆಗಳನ್ನು ನೀಡುತ್ತದೆ.

ಮೆಟಡೇಟಾ ಸಂಗ್ರಹಣೆ – ಕಂಟ್ರೋಲರ್ ಎಲ್ಲಾ ಟ್ರೈನಿಂಗ್ ಮತ್ತು ಇನ್ಫರೆನ್ಸ್ GPUಗಳಿಂದ ಪ್ಯಾರಾಮೀಟರ್ ಮೆಟಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

ಶೆಡ್ಯೂಲ್ ಗಣನೆ – ಕಂಟ್ರೋಲರ್ ಸ್ಟಾಟಿಕ್ ತೂಕ ವರ್ಗಾವಣೆ ಶೆಡ್ಯೂಲ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ, ಯಾವ ಟ್ರೈನಿಂಗ್ GPU ಯಾವ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಯಾವ ಇನ್ಫರೆನ್ಸ್ GPUಗೆ ಕಳುಹಿಸುತ್ತದೆ ಮತ್ತು ಯಾವ ಕ್ರಮದಲ್ಲಿ ಎಂಬುದನ್ನು ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ.

ಶೆಡ್ಯೂಲ್ ವಿತರಣೆ – ಕಂಟ್ರೋಲರ್ ಎಲ್ಲಾ ಟ್ರೈನಿಂಗ್ GPUಗಳಿಗೆ ಶೆಡ್ಯೂಲ್ ಅನ್ನು ಕಳುಹಿಸುತ್ತದೆ.

ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ – ಪ್ರತಿ ಟ್ರೈನಿಂಗ್ ಹಂತದ ನಂತರ, ಕಂಟ್ರೋಲರ್ ವರ್ಗಾವಣೆಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಟ್ರೈನಿಂಗ್ GPUಗಳಿಗೆ ಸಂಕೇತ ನೀಡುತ್ತದೆ.

ಉನ್ನತ-ಮಟ್ಟದ ಕಾರ್ಯಪ್ರವಾಹವನ್ನು ನಿರ್ಧರಿಸಿದ ನಂತರ, ಪ್ರಮುಖ ಸವಾಲು ಎಂದರೆ ಟ್ರಿಲಿಯನ್-ಪ್ಯಾರಾಮೀಟರ್ ಪ್ರಮಾಣದಲ್ಲಿ ತೂಕ ವರ್ಗಾವಣೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದು. ಇಲ್ಲಿ ನಾವು ನಿರ್ವಹಣಾ ಮಾರ್ಗದ ವಿವರಗಳನ್ನು ವಿವರಿಸುತ್ತೇವೆ.

ಟ್ರೈನಿಂಗ್‌ನಲ್ಲಿರುವ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು FSDP ಪ್ಲೇಸ್‌ಮೆಂಟ್‌ಗಳ ಪ್ರಕಾರ ವಿತರಿಸಲಾಗುತ್ತದೆ. full_tensor() ಅನ್ನು ಬಳಸಿಕೊಂಡು, DeviceMesh ನಲ್ಲಿರುವ ಎಲ್ಲಾ GPUಗಳು ಪೂರ್ಣ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಮರುನಿರ್ಮಿಸಬಹುದು, ಆದ್ದರಿಂದ ಎಲ್ಲವೂ ತೂಕ ವರ್ಗಾವಣೆಗೆ ಮೂಲವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು.

ಬಹು ಡಿಸೆಂಜಾಯಿಂಟ್ DeviceMeshಗಳು ಮೆಶ್ ಗುಂಪು ಅನ್ನು ರೂಪಿಸುತ್ತವೆ. ಒಂದೇ ಗುಂಪಿನಲ್ಲಿರುವ DeviceMeshಗಳು ಡಿಸೆಂಜಾಯಿಂಟ್ ಆಗಿರುವುದರಿಂದ, ಅವುಗಳ ವರ್ಗಾವಣೆಗಳು ಪರಸ್ಪರ ಅಡ್ಡಿಪಡಿಸುವುದಿಲ್ಲ ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿ ಸಮಾನಾಂತರವಾಗಿ ರನ್ ಆಗಬಹುದು. ಮೆಶ್ ಗುಂಪುಗಳ ನಡುವೆ, ಆರ್ಡರಿಂಗ್ ಅನ್ನು ಜಾರಿಗೆ ತರಲು ನಾವು ಜಾಗ್ಬಲ್ ಬ್ಯಾರಿಯರ್ ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ.

ವೇಟ್-ಟ್ರಾನ್ಸ್‌ಫರ್ ಪೈಪ್‌ಲೈನ್ host-to-device ನಕಲುಗಳು, tensor assembly, fusion ಮತ್ತು quantization, ಹಾಗು MeshGroups across RDMA transfers ಗಳನ್ನು ಒಟ್ಟಿಗೆ ನಡೆಸುತ್ತದೆ.

ನಾವು ಪ್ರತಿ ಪ್ಯಾರಾಮೀಟರ್ ಟೆನ್ಸಾರ್‌ನ ವರ್ಗಾವಣೆಯನ್ನು ಒಂದು ಟಾಸ್ಕ್ ಎಂದು ಪರಿಗಣಿಸುತ್ತೇವೆ. ತೂಕ ವರ್ಗಾವಣೆ ಪ್ರಕ್ರಿಯೆಯು ಬಹು ರೀತಿಯ ಹಾರ್ಡ್‌ವೇರ್ ಮೂಲಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ತೂಕ ವರ್ಗಾವಣೆ ಟಾಸ್ಕ್ ಅನ್ನು ಕಾಲಾನಂತರದಲ್ಲಿ ಅತಿವ್ಯಾಪಿಸುವ ವಿಭಿನ್ನ ಪೈಪ್‌ಲೈನ್ ಹಂತಗಳಾಗಿ ವಿಭಜಿಸುತ್ತೇವೆ:

ಹೋಸ್ಟ್ ಟು ಡಿವೈಸ್ ಮೆಮ್‌ಕಾಪಿ — FSDP ತೂಕವನ್ನು CPUಗೆ ಆಫ್‌ಲೋಡ್ ಮಾಡಿದರೆ

ಪ್ಯಾರಾಮೀಟರ್ ಸಿದ್ಧತೆ — full_tensor() ನೊಂದಿಗೆ ಪೂರ್ಣ ತೂಕವನ್ನು ಮರುನಿರ್ಮಿಸಿ, ಪ್ರೊಜೆಕ್ಷನ್ ಫ್ಯೂಷನ್ ಅನ್ನು ಅನ್ವಯಿಸಿ, ಅಗತ್ಯವಿದ್ದರೆ ಕ್ವಾಂಟೈಸ್ ಮಾಡಿ.

RDMA ವರ್ಗಾವಣೆ — ರಿಮೋಟ್ ಇನ್ಫರೆನ್ಸ್ GPU ಮೆಮೊರಿಗೆ ಜೀರೋ-ಕಾಪಿ ರೈಟ್

ಗ್ಲೋಬಲ್ ಬ್ಯಾರಿಯರ್ — ಎಲ್ಲಾ full_tensor() ಕರೆಗಳು ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಎಥರ್ನೆಟ್ ಮೂಲಕ GLOO ಬಳಸಿ ಮೆಶ್ ಗುಂಪುಗಳಾದ್ಯಂತ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಿ.

ಅಮ್ಲಿಮೆಂಟೇಷನ್‌ನಲ್ಲಿ, ನಾವು ಪ್ರತಿ ಪೈಪ್‌ಲೈನ್ ಹಂತಕ್ಕೂ ಟಾಸ್ಕ್‌ಗಳ FIFO ಕ್ಯೂ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತೇವೆ. ಕ್ಯೂ ಟಾಸ್ಕ್‌ನ ಹೆಡ್ ಹಂತವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದಾಗ, ಅದನ್ನು ಮುಂದಿನ ಹಂತದ ಕ್ಯೂನ ಟೈಲ್‌ಗೆ ಸರಿಸಲಾಗುತ್ತದೆ.

full_tensor() ಮತ್ತು ಇತರ GPU ಕಾರ್ಯಾಚರಣೆಗಳು ಹೆಚ್ಚುವರಿ GPU ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತವೆ. ಮೆಮೊರಿ ದೋಷದಿಂದ ಹೊರಗುಳಿಯುವುದನ್ನು ತಪ್ಪಿಸಲು, ಪ್ರಸ್ತುತ ಆನ್-ದಿ-ಫ್ಲೈ ಟಾಸ್ಕ್‌ಗಳು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದ ವಾಟರ್‌ಮಾರ್ಕ್‌ಗಿಂತ ಕಡಿಮೆ ತಾತ್ಕಾಲಿಕ GPU ಮೆಮೊರಿಯನ್ನು ಆಕ್ರಮಿಸಿಕೊಂಡರೆ ಮಾತ್ರ ನಾವು ಟಾಸ್ಕ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ.

ಹಲವಾರು ವಿನ್ಯಾಸ ಆಯ್ಕೆಗಳು ನಮ್ಮ ಸಿಸ್ಟಮ್ ಅನ್ನು ಸಾಮಾನ್ಯ ಓಪನ್-ಸೋರ್ ಪರಿಹಾರಗಳಿಗಿಂತ ರನ್ ಮಾಡಲು ಗಮನಾರ್ಹವಾಗಿ ವೇಗವಾಗಿ ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತವೆ.

Rank0 ಆಧಾರಿತ ವೇಟ್ ಟ್ರಾನ್ಸ್‌ಫರ್, inference node ಗೆ ವಿತರಿಸುವ ಮೊದಲು weights ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

Point-to-point ಸಂವಹನವು ಎರಡೂ training nodes ಗಳಿಂದ weights ಗಳನ್ನು inference node ನ network interfaces ಗಳಿಗೆ ವರ್ಗಾಯಿಸುತ್ತದೆ.

ಎಲ್ಲಾ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಶ್ರೇಣಿ-0 GPUಗಳ ಮೂಲಕ ಫನೆಲ್ ಮಾಡುವುದು ಸಾಮಾನ್ಯ ಮಾದರಿಯಾಗಿದೆ: ಟ್ರೈನಿಂಗ್ ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ-0, ಇನ್ಫರೆನ್ಸ್ ಶ್ರೇಣಿಗೆ ಕಳುಹಿಸಿ-0, ನಂತರ ಮತ್ತೆ ಸ್ಕ್ಯಾಟರ್ ಮಾಡಿ. ಇದು ಒಂದೇ GPU ನ PCIe ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಮತ್ತು NIC (ಉದಾ., 400 Gbps ≈ 50 GB/s) ನಿಂದ ಸೀಮಿತಗೊಂಡು ತ್ವರಿತವಾಗಿ ಚೋಕ್ ಪಾಯಿಂಟ್ ಆಗುತ್ತದೆ.

ಇದಕ್ಕೆ ವ್ಯತಿರಿಕ್ತವಾಗಿ, ನಮ್ಮ ಪಾಯಿಂಟ್-ಟು-ಪಾಯಿಂಟ್ ಸೆಟಪ್ ಪ್ರತಿ ಟ್ರೈನಿಂಗ್ GPU ಗೆ ಪ್ರತಿ ಇನ್ಫರೆನ್ಸ್ GPU ಗೆ ನೇರವಾಗಿ ಕಳುಹಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಇದು ಒಂದೇ ಲಿಂಕ್ ಬದಲಿಗೆ ಸಂಪೂರ್ಣ ನೆಟ್‌ವರ್ಕ್ ಫ್ಯಾಬ್ರಿಕ್ ಅನ್ನು ಸ್ಯಾಚುರೇಟ್ ಮಾಡುತ್ತದೆ.

RPC ಆಧಾರಿತ transfer ನಲ್ಲಿ inference-side buffer ಮತ್ತು worker calls ಬಳಸಲಾಗುತ್ತವೆ, ಆದರೆ one-sided transfer ನಲ್ಲಿ inference-worker ಭಾಗವಹಿಸುವಿಕೆ ಇಲ್ಲದೆ weights ಗಳನ್ನು ನೇರವಾಗಿ ಬರೆಯಲಾಗುತ್ತದೆ.

ಕೆಲವು ಸಿಸ್ಟಮ್‌ಗಳು ಪ್ರತಿ ಟೆನ್ಸಾರ್‌ಗಾಗಿ ಇನ್ಫರೆನ್ಸ್ ಎಂಜಿನ್‌ನ update_weight() ವಿಧಾನಕ್ಕೆ ಕರೆ ಮಾಡುವುದನ್ನು ಅವಲಂಬಿಸಿವೆ. ಇದರರ್ಥ ಇನ್ಫರೆನ್ಸ್ ಕೋಡ್‌ನಲ್ಲಿ ಒಳಹುಸುಳುವ ಬದಲಾವಣೆಗಳು, ಜೊತೆಗೆ RPCಗಳು, ಸೀರಿಯಲೈಸೇಶನ್ ಮತ್ತು ಕಂಟ್ರೋಲ್-ಪ್ಲೇನ್ ಸಮನ್ವಯದಿಂದ ಓವರ್‌ಹೆಡ್.

RDMA WRITE ಪ್ರಿಮಿಟಿವ್‌ನೊಂದಿಗೆ, ಹೆಚ್ಚುವರಿ ನಕಲುಗಳಿಲ್ಲದೆ ನಾವು ಇನ್ಫರೆನ್ಸ್ GPU ಮೆಮೊರಿಯಲ್ಲಿ ತೂಕವನ್ನು ಮೂಕವಾಗಿ ಅಪ್‌ಡೇಟ್ ಮಾಡುತ್ತೇವೆ. ಯಾವುದೇ ಕಂಟ್ರೋಲ್ ಪ್ಲೇನ್ ಸಂದೇಶವಿಲ್ಲ ಮತ್ತು ಯಾವುದೇ CPU ಕಂಟ್ರೋಲ್ ಲಾಜಿಕ್ ಭಾಗಿಯಾಗಿಲ್ಲ. ಇನ್ಫರೆನ್ಸ್ ಎಂಜಿನ್‌ಗೆ ಯಾವುದೇ ಮಾರ್ಪಾಡು ಅಗತ್ಯವಿಲ್ಲ.

ತೂಕ ವರ್ಗಾವಣೆ ಪ್ರಕ್ರಿಯೆಯು ನಾಲ್ಕು ರೀತಿಯ ಹಾರ್ಡ್‌ವೇರ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು: (1) ಹೋಸ್ಟ್-ಡಿವೈಸ್ ಡೇಟಾ ಮೂವ್‌ಮೆಂಟ್ (2) ಪ್ರೊಜೆಕ್ಷನ್ ಫ್ಯೂಷನ್ ಮತ್ತು ಕ್ವಾಂಟೈಸೇಶನ್‌ಗಾಗಿ GPU ಗಣನೆ (3) ಡೇಟಾ ಪ್ಲೇನ್‌ಗಾಗಿ RDMA ನೆಟ್‌ವರ್ಕ್ (4) ಕಂಟ್ರೋಲ್ ಪ್ಲೇನ್‌ಗಾಗಿ ಎಥರ್ನೆಟ್.

ನಮ್ಮ ವಿನ್ಯಾಸವು ತೂಕ ವರ್ಗಾವಣೆ ಟಾಸ್ಕ್‌ಗಳನ್ನು ಪೈಪ್‌ಲೈನ್ ಹಂತಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ, ವಿವಿಧ ಹಾರ್ಡ್‌ವೇರ್ ಸಂಪನ್ಮೂಲಗಳಾದ್ಯಂತ ಸುಲಭವಾಗಿ ಅತಿವ್ಯಾಪಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಕೆಲವು ಇಂಪ್ಲಿಮೆಂಟೇಷನ್‌ಗಳು ಪ್ರತಿ ಟ್ರೈನಿಂಗ್ ಹಂತದಲ್ಲಿ ವರ್ಗಾವಣೆ ಶೆಡ್ಯೂಲ್ ಅನ್ನು ಮರುಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತವೆ, ಮೆಟಡೇಟಾವನ್ನು ಪದೇ ಪದೇ ಸಂಗ್ರಹಿಸುತ್ತವೆ ಮತ್ತು ಸೂಚನೆಗಳನ್ನು ವಿತರಿಸುತ್ತವೆ. ಇದು ಅನಗತ್ಯ ಕಂಟ್ರೋಲ್-ಪ್ಲೇನ್ ಲೇಟೆನ್ಸಿಯನ್ನು ಸೇರಿಸುತ್ತದೆ.

ನಮ್ಮ ಶೆಡ್ಯೂಲ್ ಅನ್ನು ಆರಂಭಿಕ ಹಂತದಲ್ಲಿ ಒಮ್ಮೆ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ. ಪ್ರತಿ ಟ್ರೈನಿಂಗ್ ಇಟರೇಷನ್ ಸರಳವಾಗಿ ಯೋಜನೆಯನ್ನು ಮರುಪ್ರಸಾರ ಮಾಡುತ್ತದೆ: ಕಂಟ್ರೋಲರ್ “go” ಸಿಗ್ನಲ್ ಅನ್ನು ನೀಡುತ್ತದೆ, ಮತ್ತು GPUಗಳು ತಮ್ಮ ಪೂರ್ವ-ನಿಯೋಜಿತ ಮಾರ್ಗಗಳನ್ನು ಅನುಸರಿಸುತ್ತವೆ. ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಊಹಿಸಬಹುದಾದ ಮತ್ತು ಹಗುರವಾಗಿರುತ್ತದೆ.

ಸಂಪೂರ್ಣ ತೂಕ ಅಪ್‌ಡೇಟ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಒಂದು ಮೊಲಿಥಿಕ್ ಕಾರ್ಯದಲ್ಲಿ ಸಿಲುಕಿಸುವುದು ಪ್ರಲೋಭನಕಾರಿಯಾಗಿದೆ: ಮೆಟಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ, ಹೆಸರು ಹೊಂದಾಣಿಕೆ, ಇಂಟ್ರಾ-ನೋಡ್ ಗ್ಯಾದರಿಂಗ್, ಪ್ರೊಜೆಕ್ಷನ್ ಫ್ಯೂಷನ್, ಕ್ವಾಂಟೈಸೇಶನ್, ಸಬ್‌ಸ್ಲೈಸಿಂಗ್ ಕಮ್ಯುನಿಕೇಷನ್ ವರ್ಲ್ಡ್, ಇಂಟರ್-ನೋಡ್ ನೆಟ್‌ವರ್ಕ್ ವರ್ಗಾವಣೆ. ಇದನ್ನು ಸರಿಯಾಗಿ ಪ್ರೋಗ್ರಾಂ ಮಾಡುವುದು ಕಷ್ಟ, ಮತ್ತು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು ಇನ್ನಷ್ಟು ಕಷ್ಟ.

ನಮ್ಮ ಎಂಜಿನಿಯರಿಂಗ್‌ನಲ್ಲಿ, ನಾವು ಈ ಹಂತಗಳನ್ನು ಪ್ರತ್ಯೇಕ ಘಟಕಗಳಾಗಿ ಪ್ರತ್ಯೇಕಿಸುತ್ತೇವೆ. ಪ್ರತಿ ಘಟಕವನ್ನು ಯೂನಿಟ್ ಪರೀಕ್ಷಿಸಬಹುದು, ತರ್ಕಿಸಬಹುದು ಮತ್ತು ಪ್ರತ್ಯೇಕವಾಗಿ ಆಪ್ಟಿಮೈಜ್ ಮಾಡಬಹುದು.

ವೇಗವಾದ, ವಿಶ್ವಾಸಾರ್ಹ ತೂಕ ವರ್ಗಾವಣೆಯು ದೊಡ್ಡ ಪ್ರಮಾಣದ RL ಫೈನ್-ಟ್ಯೂನಿಂಗ್‌ಗೆ ನಿರ್ಣಾಯಕ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್ ಆಗಿದೆ. RDMA WRITE primitive, ಸ್ಟಾಟಿಕ್ ವರ್ಗಾವಣೆ ಶೆಡ್ಯೂಲ್, ಮತ್ತು ಪೈಪ್‌ಲೈನ್ಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಅನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ನಾವು Kimi-K2 ನಲ್ಲಿ ಟ್ರಿಲಿಯನ್-ಪ್ಯಾರಾಮೀಟರ್ ಅಪ್‌ಡೇಟ್‌ಗಳನ್ನು ಕೇವಲ 1.3 ಸೆಕೆಂಡುಗಳಿಗೆ ಇಳಿಸಿದ್ದೇವೆ. ಈ ವಿಧಾನವು ತರ್ಕಿಸಲು ಸರಳವಾಗಿದೆ, ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿದೆ ಮತ್ತು ಸಾಂಪ್ರದಾಯಿಕ ವಿನ್ಯಾಸಗಳ ಬಾಟಲ್‌ನೆಕ್‌ಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

BibTeX

@online{perplexity2025WeightTransferForRlPostTrainingInUnder2Seconds,
  author = {{Perplexity} and Lequn Chen and Erin McKnight and Vivian Wang},
  title = {{Weight transfer for RL post-training in under 2 seconds}},
  date = {2025-09-24},
  url = {https://www.perplexity.ai/hub/blog/weight-transfer-for-rl-post-training-in-under-2-seconds}
}

RDMA WRITE: ಒನ್-ಸೈಡೆಡ್ ವರ್ಗಾವಣೆಗಳು

ಉನ್ನತ ಮಟ್ಟದ ಕಾರ್ಯಪ್ರವಾಹ

ತೂಕ ವರ್ಗಾವಣೆ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ

ಡೀವ್ಸ್‌ಮೆಶ್ ಮತ್ತು ಮೆಶ್ ಗುಂಪುಗಳು

ಟಾಸ್ಕ್ ಪೈಪ್‌ಲೈನ್

GPU ಮೆಮೊರಿ ಬಳಕೆಯ ನಿಯಂತ್ರಣ

ಇದು ಏಕೆ ವೇಗವಾಗಿದೆ ಮತ್ತು ಸರಳವಾಗಿದೆ

ಪಾಯಿಂಟ್-ಟು-ಪಾಯಿಂಟ್ ಕಮ್ಯುನಿಕೇಷನ್

ಒನ್-ಸೈಡೆಡ್ ಡೇಟಾ ವರ್ಗಾವಣೆ

ಪೈಪ್‌ಲೈನಿಂಗ್

ಸ್ಟಾಟಿಕ್ ಶೆಡ್ಯೂಲ್

ಕ್ಲೀನ್ ಸೆಪರೇಷನ್

ತೀರ್ಮಾನ

ಉಲ್ಲೇಖ