Archives

A PyTorch implementation of Rotary Position Embedding (RoPE): inverse frequency buffer, precomputed cos/sin cache, query/key rotation, and shape verification.

Master multi-agent embodied systems: CTDE reinforcement learning, shared 3DGS maps, dynamic role allocation, and heterogeneous robot team deployment.

Master World Models for Embodied AI: Recurrent State Space Models (RSSM), latent dynamics, model-based MPC planning, and VLA policy integration in PyTorch.

A minimal PyTorch implementation of a Denoising Diffusion Probabilistic Model (DDPM): sinusoidal time embeddings, U-Net with skip connections, forward noising, reverse denoising, and ancestral sampling.

Master NeRF (Neural Radiance Fields): 5D radiance fields, differentiable volume rendering, Fourier positional encoding, hierarchical sampling, and PyTorch.

Train Qwen3-VL-8B Vision with GRPO: multimodal policy optimization, two-tier visual reward functions, and 16-bit LoRA under 15GB VRAM.

Fine-tune Qwen3.5-4B Vision using Unsloth: 16-bit LoRA optimization, multi-modal patch projection, and Q4_K_M GGUF edge deployment on consumer GPUs.

Master Vision-Language-Action (VLA) models: continuous Flow Matching action heads, cross-embodiment datasets, Action Chunking, and Isaac Lab sim-to-real.

A compact PyTorch implementation of a Transformer encoder with multi-head self-attention, sinusoidal positional encoding, feed-forward layers, residual connections, and padding masks.

Train FLUX.2 Klein LoRA on 8GB GPUs using Kohya_ss: compact 4B MMDiT flow matching, CLIP-L conditioning, latent caching, and ComfyUI deployment.

Train Qwen3.5-4B Vision with GRPO: multimodal policy optimization, two-tier visual reward functions, and 16-bit LoRA under 15GB VRAM.

Fine-tune OpenAI gpt-oss-20B MoE using Unsloth on 16GB GPUs: 4-bit QLoRA, Harmony chat templates, channel separation, and SFTTrainer pipeline.

Fine-tune Qwen3-VL-8B Vision on LaTeX OCR tasks with Unsloth: 4-bit NF4 QLoRA, multimodal token collation, and GGUF export under 8.5GB VRAM.

Master Video Generation Foundation Models: 3D Diffusion Transformers, continuous Flow Matching, 3D VAE compression, and open-source PyTorch pipelines.

Fine-tune Qwen3.5-0.8B Vision on VQA tasks using Unsloth: BF16 LoRA optimization, multi-modal token alignment, and GGUF edge deployment under 3GB VRAM.

Fine-tune Qwen3.5-2B Vision on document VQA using Unsloth: 16-bit LoRA optimization, multi-modal OCR token alignment, and GGUF export under 5GB VRAM.

Master OpenClaw: self-hosted gateway routing, Docker sandbox isolation, SKILL.md progressive disclosure, MCP servers, and multi-channel messaging deployment.

Fine-tune Qwen3-4B-Thinking on DeepSeek-R1 CoT traces with Unsloth: OpenMathReasoning alignment, thinking-mode toggles, and GGUF multi-quant export.

Fine-tune Qwen3-14B dual-mode reasoning and chat: 75/25 mixed-dataset distillation, 4-bit QLoRA, and GGUF multi-quant export on 12GB VRAM.

Train gpt-oss-20B MoE using GRPO: AST sandboxing, anti-reward hacking, 4-bit QLoRA, and execution benchmark reward engineering.

Master FLUX.1 Dev LoRA fine-tuning with Kohya_ss: MMDiT joint attention, Flow Matching velocity loss, text encoder freezing, and ComfyUI deployment.

Master Microsoft TRELLIS: Structured 3D Latents (SLAT), Rectified Flow Transformers, and unified decoding into 3D Gaussian Splats, NeRFs, and meshes.

Train high-fidelity SDXL LoRAs with Kohya_ss: latent diffusion objective, cross-attention projection tuning, multi-aspect bucketing, and ComfyUI deployment.

Train Qwen3-4B with GRPO on 16GB GPUs: two-stage format pre-tuning, 4-tier composite reward shaping, rsLoRA, and vLLM acceleration.

Train Qwen3-8B in native FP8 precision using GRPO reinforcement learning: memory-efficient policy updates, multi-tier reward functions, and 20GB VRAM execution.

Master Tencent's Hunyuan3D-2: explore the decoupled Hunyuan3D-DiT shape generator, Hunyuan3D-Paint 2K PBR texture synthesis, and Blender pipeline.

Fine-tune Qwen3-4B-Instruct with Unsloth: response-only loss masking, 4-bit QLoRA, memory profiling under 8GB VRAM, and GGUF multi-quant export.

Train 20B Qwen-Image LoRA on 24GB GPUs using AI-Toolkit: uint3 quantization, Accuracy Recovery Adapters (ARA), Flow Matching, and ComfyUI deployment.

Master multimodal embodied agents: Vision-Language-Action (VLA) backbones, flow-matching continuous control, hierarchical memory, and Isaac Lab sim-to-real.

Fine-tune Qwen2.5-Coder-1.5B for tool calling using Unsloth: Hermes JSON schema formatting, 4-bit QLoRA, multi-tool dispatch, and edge deployment.

Master LTX-2 Character-Consistent Video LoRA training: in-context conditioning (IC-LoRA), paired dataset curation, YAML configs, and ComfyUI deployment.

Master FLUX.2-dev LoRA fine-tuning with AI-Toolkit: MMDiT flow matching, dataset curation, Prodigy adaptive optimization, and ComfyUI deployment.

Train Qwen-Image-Edit-2511 LoRA using AI-Toolkit: paired MMDiT datasets, qfloat8 quantization, Diff Output Preservation, and ComfyUI deployment.

Accelerate MoE LLM fine-tuning with Unsloth Faster MoE: torch._grouped_mm, Triton fused kernels, Split LoRA memory optimization, and benchmarks.

Master Tencent's HunyuanVideo: 13B parameter flow-matching DiT, Causal 3D VAE compression, MLLM text conditioning, and PyTorch deployment.

Master 3D Gaussian Splatting from scratch: anisotropic covariance decomposition, spherical harmonics, tile-based CUDA rasterization, and PyTorch training.

Master Text-to-3D with Gaussian Splatting: Score Distillation Sampling (SDS), diffusion guidance, differentiable gsplat rendering, and PyTorch pipelines.

Train Llama 3.2 (3B) with GRPO and LoRA: multi-reward optimization, SFT format warm-up, cosine similarity scoring, and PyTorch deployment.

Master Hermes Agent by Nous Research: explore the closed learning loop, hierarchical memory, progressive skill discovery, and multi-backend MCP integration.

Deploy GS-SLAM with VLA models for robotic manipulation: 3D Gaussian spatial grounding, cross-attention feature fusion, and closed-loop control.

Master Scaffold-GS: sparse voxel anchor grids, shared neural MLP predictors, view-dependent LOD rendering, and 10x-100x Gaussian splat compression.

Master distributed LLM pretraining (13B–70B+) with DeepSpeed and Megatron-LM: 3D Parallelism (TP/PP/DP), ZeRO-3, FP8 TransformerEngine, and multi-node NCCL.

Train Llama 3.2 1B using hardware FP8 quantization and GRPO: 4-layer reward shaping, vLLM weight sharing, and 60% VRAM reduction.

Train Llama 3.1 8B with GRPO using Unsloth on a single 16GB GPU: 5-tier composite reward functions, 4-bit QLoRA, XML reasoning, and vLLM acceleration.

Master Gaussian Splatting SLAM (GS-SLAM): real-time pose tracking, incremental Gaussian mapping, loop closure, and PyTorch deployment on RGB-D streams.

Train DeepSeek-R1 distilled Qwen3 (8B) using GRPO: multi-signal reward functions, group advantage normalization, and single-GPU fine-tuning.

Master 4D Gaussian Splatting: canonical space formulation, HexPlane vs. MLP deformation fields, real-time PyTorch training, and robotics digital twins.

Deploy 3D Gaussian Splatting in robotics: real-time scene reconstruction, Mahalanobis collision checking, 6-DoF grasp planning, and sim-to-real transfer.

Master LTX-2: asymmetric dual-stream video/audio DiT, 1D/3D RoPE alignment, cross-modality adaLN, multimodal guidance (CFG/STG), and PyTorch pipelines.

A PyTorch implementation of Direct Preference Optimization (DPO): a small LSTM language model, a preference dataset, and a DPO trainer that optimizes a policy against a frozen reference via the sigmoid logistic DPO loss on chosen/rejected pairs.

A PyTorch implementation of Group Relative Policy Optimization (GRPO): a Group-relative RL approach that partitions sorted trajectories into groups, weights group-relative advantages, and applies clipped surrogate updates with PPO-style ratios.

A PyTorch implementation of Deep Deterministic Policy Gradient (DDPG): an Actor that outputs tanh-bounded deterministic actions, a Q-value Critic over state-action pairs, a replay buffer, target networks with soft updates, and a smoke test that exercises action selection and a short training loop.

A PyTorch implementation of LLaVA: a ResNet-50 vision encoder, a Transformer-based language model, a custom cross-attention fusion layer, and an enhanced tokenizer for image-grounded text generation.

Master Diffusion Transformers (DiT): latent patchification, adaLN-Zero conditioning, multi-modal MMDiT joint attention, scaling laws, and PyTorch pipelines.

A PyTorch implementation of the Diffusion Transformer (DiT): a patch-embedded Vision Transformer with sinusoidal timestep conditioning, multi-head self-attention, MLP blocks, and a transposed-conv head that predicts the image-space noise.

A PyTorch implementation of Deep Q-Network (DQN): a Q-value MLP, a replay buffer, an ε-greedy agent with target network, Bellman loss update, and a CartPole-v1 training/test loop using Gymnasium.

A PyTorch implementation of Low-Rank Adaptation (LoRA): low-rank A/B matrices wrapped around a frozen linear layer, scaled by alpha/rank, with shape, freezing, and rank-property tests.

A PyTorch implementation of a Denoising Diffusion Probabilistic Model (DDPM): a linear-beta forward diffusion, a reverse sampling loop, a time-conditioned UNet denoising network, and a training-free smoke test that forward-diffuses, predicts noise, and samples images.

A PyTorch implementation of FlashAttention-style multi-head attention: a softmax-scaled dot-product attention block, a tiled/blocked variant that processes sequence chunks for memory efficiency, and basic shape tests.

A PyTorch implementation of the Mixture of Experts (MoE) layer with a top-k gating network, multiple expert MLPs, and weighted expert outputs for sparse expert routing.

A minimal PyTorch ControlNet implementation: a control encoder with conv blocks, residual skip connections, channel attention, and a zero-initialized projection that adds residual control features into a backbone so that the model behaves as identity at init.

A PyTorch implementation of a Denoising Diffusion Implicit Model (DDIM) sampler: a UNet denoiser with GELU time conditioning, an eta-controlled stochastic-to-deterministic reverse process on a sub-sequence of timesteps, and a smoke test that verifies noise addition, model output, sampling shapes, and deterministic reproducibility.

A PyTorch implementation of a Denoising Diffusion Probabilistic Model (DDPM): a UNet denoiser with sinusoidal-free linear time conditioning, a linear-beta forward diffusion, an iterative reverse sampling loop, and a smoke test that verifies noise addition, model output, and sampling shapes.

Master PagedAttention: virtual memory KV cache paging, block tables, prefix caching (CoW), continuous batching, memory fragmentation math, and PyTorch kernels.

A PyTorch implementation of the DeepSeek-style architecture: RMSNorm pre-norm blocks, a multi-head latent attention module, a Mixture-of-Experts (MoE) feed-forward router, and a stack of DeepSeek blocks with token-level residual paths.

Master DDIM (Denoising Diffusion Implicit Models): non-Markovian sampling, probability-flow ODE derivations, deterministic inference, and PyTorch pipelines.

A PyTorch implementation of the Vision Transformer (ViT) with patch embedding, learnable class token and position embeddings, multi-head self-attention, MLP blocks, and classification head.

Master the Vision Transformer (ViT): patch projection, class tokens, multi-head self-attention over patches, DeiT augmentation, and PyTorch implementations.

A from-scratch PyTorch implementation of the LLaMA-style Transformer: RMSNorm, Rotary Position Embeddings (RoPE), GQA-style multi-head attention with causal mask, SwiGLU MLP, and a stack of pre-norm decoder layers.

Master RoPE (Rotary Position Embedding): complex rotation algebra, relative distance invariance proof, long-context scaling (YaRN), and PyTorch kernels.

Master DDPM: forward and reverse Gaussian Markov chains, closed-form ELBO derivation, noise-prediction parameterization, and PyTorch training pipelines.

A PyTorch implementation of 3D Gaussian Splatting from scratch: per-Gaussian learnable positions, scales, quaternions and RGBA, 3D covariance via R S Sᵀᵀ, projection to 2D via the perspective Jacobian, splat-based alpha compositing over a pixel grid, and a smoke test that checks initialization, symmetry/orthogonality of covariances, and the rendering output shape and value range.

Master diffusion models: forward Markov perturbations, reverse ELBO derivations, score-based SDE unifications, and production PyTorch training pipelines.

A PyTorch implementation of Asynchronous Advantage Actor-Critic (A3C): a shared Actor-Critic network with a softmax policy head, multiple Worker processes that collect CartPole trajectories, compute n-step returns and advantages, and sync gradients into a global model, plus a greedy test harness that runs the trained policy in render mode.

Master 4D Gaussian Splatting (4DGS): HexPlane spatiotemporal neural fields, canonical deformation fields, and real-time dynamic novel view synthesis.

Master 3D Gaussian Splatting (3DGS): covariance matrix decomposition, tile-based differentiable rasterization, adaptive density control, and real-time CUDA pipelines.

Master LLaVA: visual instruction tuning, 2-stage cross-modal projection, CLIP/SigLIP feature alignment, AnyRes scaling, and PyTorch VLM pipelines.

Master Stable Diffusion: latent diffusion models (LDM), perceptual VAE compression, cross-attention U-Net, classifier-free guidance, and PyTorch pipelines.

Master LoRA (Low-Rank Adaptation): low-rank matrix decomposition, intrinsic rank analysis, QLoRA NF4 quantization, DoRA, and PyTorch PEFT pipelines.

Master ControlNet: zero-convolution weight initialization, trainable U-Net copy architecture, multi-condition composition, and PyTorch training pipelines.

Master 3D Transformers: vector self-attention on point clouds, sparse voxel hashing, 3D Swin windowing, relative positional bias, and PyTorch architectures.

Master Llama architecture: RMSNorm pre-normalization, SwiGLU activations, RoPE relative embeddings, Grouped-Query Attention (GQA), and PyTorch pipelines.

Master the Transformer: scaled dot-product attention, multi-head projections, sinusoidal & RoPE encodings, Pre-LN vs Post-LN stability, and PyTorch engines.