"""Server-based multi-GPU launcher for InternLM-XComposer2 finetuning. - Uses existing JSON files directly (no zip extraction, no splitting): - /users//vlm_conversations_train.json - /users//vlm_conversations_val.json - Runs distributed training across all visible GPUs via torchrun. - Saves LoRA adapters and (optionally) a merged full model under /users/. This script assumes the finetune helper files already exist at: /users//VLM_finetune/finetune and will NOT regenerate them. Prereqs (in your active conda env): - torch, torchvision - transformers, accelerate, peft - Pillow, einops, timm, sentencepiece Example: python /users//FT.py \ --model_name_or_path internlm/internlm-xcomposer2-4khd-7b \ --output_dir /users//outputs/lora_run_001 """ from __future__ import annotations # Environment and dependency checks # Validate environment and dataset # Argument parsing """ Dataset/model: - --train_json: path to training dataset JSON (default /users//vlm_conversations_train.json) - --val_json: path to validation dataset JSON (default /users//vlm_conversations_val.json) - --model_name_or_path: Hugging Face model ID or local path Outputs: - --output_dir: folder to save LoRA adapters (and optionally merged model) Vision/text sizes: - --img_size (default 490) - --hd_num (default 6) - --max_length (default 8192) Training hyperparameters: - --num_train_epochs (default 1) - --per_device_train_batch_size (default 1) - --per_device_eval_batch_size (default 1) - --gradient_accumulation_steps (default 8) - --learning_rate, --weight_decay, --warmup_ratio, --lr_scheduler_type Distributed/launcher behavior: - --cuda_visible_devices: sets CUDA_VISIBLE_DEVICES for you - --master_port: torchrun rendezvous port (29501 by default; 0 means “pick a free port”) - --single_process: do not use torchrun even if multiple GPUs exist - --no_launch: build/validate everything but do not actually run training Memory / sharding options: - --use_deepspeed: pass a DeepSpeed config to Hugging Face Trainer - --deepspeed_config: choose which DeepSpeed JSON config - --use_fsdp: use PyTorch FSDP sharding via Trainer (mutually exclusive with DeepSpeed) Post-processing: - --save_merged_model: after training, merge LoRA into base and save full model under output_dir/merged_model """ import argparse import json import os import socket import shutil import subprocess import sys from pathlib import Path from typing import Optional DEFAULT_TRAIN_JSON = "/users//vlm_conversations_train.json" DEFAULT_VAL_JSON = "/users//vlm_conversations_val.json" DEFAULT_BASE_MODEL = "internlm/internlm-xcomposer2-4khd-7b" def _run(cmd: list[str], cwd: Optional[str] = None, env: Optional[dict[str, str]] = None) -> None: print("[CMD]", " ".join(cmd)) subprocess.run(cmd, cwd=cwd, env=env, check=True) def _assert_deps() -> None: missing: list[str] = [] for name in ["torch", "transformers", "accelerate", "peft", "torchvision", "PIL"]: try: __import__(name) except Exception: missing.append(name) if missing: raise RuntimeError( "Missing required packages: " + ", ".join(missing) + ". Activate your conda env and install them, then re-run." ) def _gpu_summary() -> tuple[bool, int, bool]: import torch cuda_visible_devices = os.environ.get("CUDA_VISIBLE_DEVICES") if cuda_visible_devices is not None: print(f"CUDA_VISIBLE_DEVICES: {cuda_visible_devices}") has_cuda = torch.cuda.is_available() count = torch.cuda.device_count() if has_cuda else 0 bf16_ok = bool(has_cuda and getattr(torch.cuda, "is_bf16_supported", lambda: False)()) print(f"GPU Available: {has_cuda}") print(f"GPU Count: {count}") if has_cuda and count > 0: for i in range(count): props = torch.cuda.get_device_properties(i) print(f" GPU[{i}]: {torch.cuda.get_device_name(i)} | {props.total_memory / 1e9:.2f} GB") return has_cuda, count, bf16_ok def _validate_json(path: str) -> None: p = Path(path) if not p.exists(): raise FileNotFoundError(f"Dataset json not found: {path}") with p.open("r", encoding="utf-8") as f: data = json.load(f) if not isinstance(data, list) or not data: raise ValueError(f"Dataset json must be a non-empty list: {path}") sample = data[0] if "image" not in sample or "conversations" not in sample: raise ValueError(f"Unexpected sample format in {path}. Need keys: image, conversations") img0 = sample.get("image", [None])[0] if isinstance(img0, str) and img0 and not Path(img0).exists(): print(f"[WARN] First image path does not exist on disk: {img0}") def _ensure_repo(work_dir: Path, repo_url: str) -> Path: repo_dir = work_dir / "InternLM-XComposer" if (repo_dir / ".git").exists(): return repo_dir if repo_dir.exists(): shutil.rmtree(repo_dir) _run(["git", "clone", repo_url, str(repo_dir)]) return repo_dir def _get_finetune_paths(finetune_dir: Path) -> tuple[Path, Path]: """Use existing helper files instead of generating them.""" finetune_path = finetune_dir / "finetune.py" ds_config_path = finetune_dir / "ds_config_zero2.json" missing = [] for required in [ finetune_path, ds_config_path, finetune_dir / "data_mix.py", finetune_dir / "ixc_utils.py", ]: if not required.exists(): missing.append(str(required)) if missing: raise FileNotFoundError( "Missing required finetune helper files. Expected them to already exist.\n" + "\n".join(missing) ) return finetune_path, ds_config_path def _parse_args() -> argparse.Namespace: p = argparse.ArgumentParser(description="Server-based multi-GPU finetuning launcher") p.add_argument( "--cuda_visible_devices", default=None, help="Optional GPU selection, e.g. '2,3'. Equivalent to setting CUDA_VISIBLE_DEVICES before running.", ) p.add_argument("--train_json", default=DEFAULT_TRAIN_JSON) p.add_argument("--val_json", default=DEFAULT_VAL_JSON) p.add_argument("--model_name_or_path", default=DEFAULT_BASE_MODEL) p.add_argument("--work_dir", default="/users//VLM_finetune") p.add_argument( "--output_dir", default="/users//outputs/finetune_lora", help="Where LoRA adapters (and optionally merged model) are saved", ) p.add_argument("--img_size", type=int, default=490) p.add_argument("--hd_num", type=int, default=6) p.add_argument("--max_length", type=int, default=8192) p.add_argument("--num_train_epochs", type=int, default=1) p.add_argument("--per_device_train_batch_size", type=int, default=1) p.add_argument("--per_device_eval_batch_size", type=int, default=1) p.add_argument("--gradient_accumulation_steps", type=int, default=8) p.add_argument("--learning_rate", type=float, default=5e-5) p.add_argument("--weight_decay", type=float, default=0.1) p.add_argument("--warmup_ratio", type=float, default=0.01) p.add_argument("--lr_scheduler_type", default="cosine") p.add_argument("--logging_steps", type=int, default=10) p.add_argument("--save_total_limit", type=int, default=1) p.add_argument("--use_deepspeed", action="store_true") p.add_argument( "--deepspeed_config", default=None, help="Path to a DeepSpeed JSON config (defaults to ds_config_zero2.json under finetune/).", ) p.add_argument("--use_fsdp", action="store_true", help="Enable PyTorch FSDP sharding via HF Trainer.") p.add_argument( "--fsdp_policy", default="full_shard auto_wrap", help="FSDP policy string for TrainingArguments.fsdp (e.g., 'full_shard auto_wrap').", ) p.add_argument( "--fsdp_wrap_cls", default="InternLM2DecoderLayer", help="Transformer layer class name to auto-wrap for FSDP (fsdp_transformer_layer_cls_to_wrap).", ) p.add_argument( "--master_port", type=int, default=29501, help="torchrun rendezvous port. Use 0 to auto-pick a free port.", ) p.add_argument("--single_process", action="store_true") p.add_argument("--no_launch", action="store_true") p.add_argument( "--save_merged_model", action="store_true", help="After training, merge LoRA into base and save a full merged model under /merged_model", ) return p.parse_args() def _pick_free_port() -> int: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind(("127.0.0.1", 0)) s.listen(1) return int(s.getsockname()[1]) def _port_is_free(port: int) -> bool: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) try: s.bind(("127.0.0.1", int(port))) return True except OSError: return False def _merge_lora_to_full_model(base_model: str, lora_dir: Path, merged_out: Path) -> None: import torch import transformers from peft import PeftModel if not (lora_dir / "adapter_config.json").exists(): raise FileNotFoundError(f"Expected LoRA adapters at {lora_dir} (missing adapter_config.json)") merged_out.mkdir(parents=True, exist_ok=True) # Merge on a single GPU (rank0 after distributed run completes) dtype = torch.bfloat16 if getattr(torch.cuda, "is_bf16_supported", lambda: False)() else torch.float16 base = transformers.AutoModelForCausalLM.from_pretrained( base_model, trust_remote_code=True, torch_dtype=dtype, device_map="auto", ) model = PeftModel.from_pretrained(base, str(lora_dir)) merged = model.merge_and_unload() merged.save_pretrained(str(merged_out), safe_serialization=True) tok = transformers.AutoTokenizer.from_pretrained(base_model, trust_remote_code=True, use_fast=False) tok.save_pretrained(str(merged_out)) def main() -> None: _assert_deps() args = _parse_args() # If requested, set CUDA_VISIBLE_DEVICES for this process and propagate it to subprocesses. if args.cuda_visible_devices is not None: os.environ["CUDA_VISIBLE_DEVICES"] = str(args.cuda_visible_devices) _validate_json(args.train_json) _validate_json(args.val_json) # Proactive memory hint: this model + images at long context can exceed 40GB/GPU even with LoRA. if args.max_length >= 8192 and not args.use_deepspeed: print( "[WARN] max_length=%s can OOM on 40GB GPUs for InternLM-XComposer2 finetuning (especially with img_size=%s, hd_num=%s). " "If you hit CUDA OOM, try: --max_length 4096 (or 3072), and/or --img_size 336 --hd_num 4, and/or --use_deepspeed." % (args.max_length, args.img_size, args.hd_num) ) has_cuda, gpu_count, bf16_ok = _gpu_summary() if not has_cuda or gpu_count < 1: raise RuntimeError("No CUDA GPUs detected. This training setup expects at least 1 GPU.") work_dir = Path(args.work_dir).resolve() work_dir.mkdir(parents=True, exist_ok=True) # Repo clone is optional for this launcher; we keep it out of the critical path. # If you want to ensure it exists, you can manually clone it under work_dir. finetune_dir = work_dir / "finetune" finetune_path, ds_config_path = _get_finetune_paths(finetune_dir) output_dir = Path(args.output_dir).resolve() output_dir.mkdir(parents=True, exist_ok=True) # Mixed precision use_bf16 = bf16_ok script_and_args = [ str(finetune_path), "--model_name_or_path", args.model_name_or_path, "--data_path", args.train_json, "--eval_data_path", args.val_json, "--img_size", str(args.img_size), "--hd_num", str(args.hd_num), "--use_lora", "True", "--output_dir", str(output_dir), "--num_train_epochs", str(args.num_train_epochs), "--per_device_train_batch_size", str(args.per_device_train_batch_size), "--per_device_eval_batch_size", str(args.per_device_eval_batch_size), "--gradient_accumulation_steps", str(args.gradient_accumulation_steps), "--learning_rate", str(args.learning_rate), "--weight_decay", str(args.weight_decay), "--warmup_ratio", str(args.warmup_ratio), "--lr_scheduler_type", str(args.lr_scheduler_type), "--logging_steps", str(args.logging_steps), "--save_total_limit", str(args.save_total_limit), "--save_strategy", "epoch", "--eval_strategy", "epoch", "--report_to", "none", "--max_length", str(args.max_length), "--gradient_checkpointing", "True", "--ddp_find_unused_parameters", "False", ] if use_bf16: script_and_args.extend(["--bf16", "True"]) else: script_and_args.extend(["--fp16", "True"]) if args.use_deepspeed and args.use_fsdp: raise RuntimeError("Choose only one: --use_deepspeed or --use_fsdp") if args.use_deepspeed: ds_cfg = Path(args.deepspeed_config).resolve() if args.deepspeed_config else ds_config_path if not ds_cfg.exists(): raise FileNotFoundError(f"DeepSpeed config not found: {ds_cfg}") script_and_args.extend(["--deepspeed", str(ds_cfg)]) elif args.use_fsdp: script_and_args.extend(["--fsdp", args.fsdp_policy]) script_and_args.extend(["--fsdp_transformer_layer_cls_to_wrap", args.fsdp_wrap_cls]) if args.no_launch: print(f"[OK] Scripts created under: {finetune_dir}") print(f"[OK] Output directory: {output_dir}") print("[OK] Training not launched (--no_launch).") return env = os.environ.copy() env.setdefault("CUDA_DEVICE_MAX_CONNECTIONS", "1") # Helps reduce CUDA memory fragmentation; matches PyTorch's OOM suggestion. env.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True") master_port = int(args.master_port) if master_port == 0: master_port = _pick_free_port() print(f"[INFO] Auto-picked free --master_port {master_port}") elif not _port_is_free(master_port): new_port = _pick_free_port() print(f"[WARN] --master_port {master_port} is busy (EADDRINUSE). Switching to free port {new_port}.") master_port = new_port # Use all visible GPUs by default. if gpu_count > 1 and not args.single_process and "RANK" not in env: launch_cmd = [ sys.executable, "-m", "torch.distributed.run", "--nproc_per_node", str(gpu_count), "--master_port", str(master_port), ] + script_and_args _run(launch_cmd, cwd=str(finetune_dir), env=env) else: train_cmd = [sys.executable] + script_and_args _run(train_cmd, cwd=str(finetune_dir), env=env) if args.save_merged_model: merged_dir = output_dir / "merged_model" print(f"[INFO] Merging LoRA adapters into full model -> {merged_dir}") _merge_lora_to_full_model(args.model_name_or_path, output_dir, merged_dir) print(f"[OK] Merged model saved: {merged_dir}") if __name__ == "__main__": main()