Add files using upload-large-folder tool

FlowCache/FlowCache4MAGI-1-dev5-history/scripts/single_run/flowcache_t2v.sh

@@ -0,0 +1,119 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+export MASTER_ADDR=localhost
+export MASTER_PORT=6005
+export GPUS_PER_NODE=1
+export NNODES=1
+export WORLD_SIZE=1
+export CUDA_VISIBLE_DEVICES=0
+
+export PAD_HQ=1
+export PAD_DURATION=1
+
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+export OFFLOAD_T5_CACHE=true
+export OFFLOAD_VAE_CACHE=true
+export TORCH_CUDA_ARCH_LIST="8.9;9.0"
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MAGI_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+cd "$MAGI_ROOT"
+
+PROMPT="${PROMPT:-a woman dancing.}"
+TIMESTAMP="${RUN_ID:-$(date "+%Y-%m-%d_%H-%M-%S")}"
+PROMPT_DIR_NAME="${PROMPT_DIR_NAME:-$(python3 - "$PROMPT" <<'PY'
+import re
+import sys
+import unicodedata
+
+prompt = unicodedata.normalize("NFKC", sys.argv[1]).strip()
+prompt = re.sub(r"[\\/:\*\?\"<>\|\x00-\x1f]+", "_", prompt)
+prompt = re.sub(r"\s+", "_", prompt)
+prompt = prompt.strip("._")
+print((prompt or "prompt")[:120])
+PY
+)}"
+OUTPUT_ROOT="${OUTPUT_ROOT:-outputs}"
+EXP_DIR="${RUN_DIR:-$OUTPUT_ROOT/${PROMPT_DIR_NAME}_$TIMESTAMP}"
+mkdir -p "$EXP_DIR"
+
+OUTPUT_PATH="${OUTPUT_PATH:-$EXP_DIR/output_$TIMESTAMP.mp4}"
+RESIDUAL_JSON="${RESIDUAL_JSON:-$EXP_DIR/residual_stats_$TIMESTAMP.json}"
+RESIDUAL_PNG="${RESIDUAL_PNG:-$EXP_DIR/residual_norms_$TIMESTAMP.png}"
+L1_REL_JSON="${L1_REL_JSON:-$EXP_DIR/l1_rel_stats_$TIMESTAMP.json}"
+L1_REL_PNG="${L1_REL_PNG:-$EXP_DIR/l1_rel_$TIMESTAMP.png}"
+L1_REL_RATIO_PNG="${L1_REL_RATIO_PNG:-$EXP_DIR/l1_rel_ratio_$TIMESTAMP.png}"
+X_EMBEDDER_L1_REL_PNG="${X_EMBEDDER_L1_REL_PNG:-$EXP_DIR/x_embedder_l1_rel_$TIMESTAMP.png}"
+X_EMBEDDER_L1_REL_RATIO_PNG="${X_EMBEDDER_L1_REL_RATIO_PNG:-$EXP_DIR/x_embedder_l1_rel_ratio_$TIMESTAMP.png}"
+FLOWCACHE_METRIC_JSON="${FLOWCACHE_METRIC_JSON:-$EXP_DIR/flowcache_metric_stats_$TIMESTAMP.json}"
+FLOWCACHE_REL_L1_PNG="${FLOWCACHE_REL_L1_PNG:-$EXP_DIR/flowcache_rel_l1_$TIMESTAMP.png}"
+FLOWCACHE_REL_L1_RATIO_PNG="${FLOWCACHE_REL_L1_RATIO_PNG:-$EXP_DIR/flowcache_rel_l1_ratio_$TIMESTAMP.png}"
+FLOWCACHE_ACCUMULATED_REL_L1_PNG="${FLOWCACHE_ACCUMULATED_REL_L1_PNG:-$EXP_DIR/flowcache_accumulated_rel_l1_$TIMESTAMP.png}"
+LOG_FILE="${LOG_FILE:-$EXP_DIR/infer_$TIMESTAMP.log}"
+
+export PYTHONPATH="$MAGI_ROOT:${PYTHONPATH:-}"
+python3 inference/pipeline/flowcache.py \
+    --config_file config/single_run/flowcache_t2v.json \
+    --mode t2v \
+    --prompt "$PROMPT" \
+    --output_path "$OUTPUT_PATH" \
+    --additional_config yaml_config/single_run/config.yaml \
+    --residual_stats_path "$RESIDUAL_JSON" \
+    --l1_rel_stats_path "$L1_REL_JSON" \
+    --flowcache_metric_stats_path "$FLOWCACHE_METRIC_JSON" \
+    2>&1 | tee "$LOG_FILE"
+
+python3 tools/plot_residual_norms.py "$RESIDUAL_JSON" -o "$RESIDUAL_PNG"
+python3 tools/plot_l1_rel.py "$L1_REL_JSON" -o "$L1_REL_PNG"
+python3 tools/plot_l1_rel.py "$L1_REL_JSON" --y-field l1_rel_ratio -o "$L1_REL_RATIO_PNG"
+python3 tools/plot_l1_rel.py "$L1_REL_JSON" --y-field x_embedder_l1_rel -o "$X_EMBEDDER_L1_REL_PNG"
+python3 tools/plot_l1_rel.py "$L1_REL_JSON" --y-field x_embedder_l1_rel_ratio -o "$X_EMBEDDER_L1_REL_RATIO_PNG"
+python3 tools/plot_l1_rel.py "$FLOWCACHE_METRIC_JSON" --x-field cur_denoise_step --y-field flowcache_rel_l1 -o "$FLOWCACHE_REL_L1_PNG"
+python3 tools/plot_l1_rel.py "$FLOWCACHE_METRIC_JSON" --x-field cur_denoise_step --y-field flowcache_rel_l1_ratio -o "$FLOWCACHE_REL_L1_RATIO_PNG"
+python3 tools/plot_l1_rel.py "$FLOWCACHE_METRIC_JSON" --x-field cur_denoise_step --y-field flowcache_accumulated_rel_l1 -o "$FLOWCACHE_ACCUMULATED_REL_L1_PNG"
+
+python3 - "$FLOWCACHE_METRIC_JSON" <<'PY'
+import json
+import sys
+
+with open(sys.argv[1], "r") as f:
+    payload = json.load(f)
+
+summary = payload.get("chunk_execution_summary", {})
+print("FlowCache actual execution summary:")
+for chunk_id in sorted(summary, key=lambda value: int(value)):
+    item = summary[chunk_id]
+    print(
+        "  chunk {chunk_idx}: reuse={reuse_steps}, compute={compute_steps}, "
+        "total={total_steps}, reuse_rate={reuse_rate:.2%}".format(**item)
+    )
+PY
+
+echo "Done."
+echo "  log: $LOG_FILE"
+echo "  video: $OUTPUT_PATH"
+echo "  residual json: $RESIDUAL_JSON"
+echo "  residual plot: $RESIDUAL_PNG"
+echo "  L1 rel json: $L1_REL_JSON"
+echo "  L1 rel plot: $L1_REL_PNG"
+echo "  L1 rel ratio plot: $L1_REL_RATIO_PNG"
+echo "  x_embedder L1 rel plot: $X_EMBEDDER_L1_REL_PNG"
+echo "  x_embedder L1 rel ratio plot: $X_EMBEDDER_L1_REL_RATIO_PNG"
+echo "  FlowCache metric json: $FLOWCACHE_METRIC_JSON"
+echo "  FlowCache rel L1 plot: $FLOWCACHE_REL_L1_PNG"
+echo "  FlowCache rel L1 ratio plot: $FLOWCACHE_REL_L1_RATIO_PNG"
+echo "  FlowCache accumulated rel L1 plot: $FLOWCACHE_ACCUMULATED_REL_L1_PNG"

FlowCache/FlowCache4MAGI-1-dev5-history/scripts/single_run/flowcache_v2v.sh

@@ -0,0 +1,51 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+export MASTER_ADDR=localhost
+export MASTER_PORT=6001
+export GPUS_PER_NODE=1
+export NNODES=1
+export WORLD_SIZE=1
+export CUDA_VISIBLE_DEVICES=7
+
+export PAD_HQ=1
+export PAD_DURATION=1
+
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+export OFFLOAD_T5_CACHE=true
+export OFFLOAD_VAE_CACHE=true
+export TORCH_CUDA_ARCH_LIST="8.9;9.0"
+
+MAGI_ROOT=$(git rev-parse --show-toplevel)
+
+
+OUTPUT_NAME=flowcache
+TIMESTAMP=$(date "+%Y-%m-%d_%H-%M-%S")
+EXP_DIR="/path/to/output/magi/${TIMESTAMP}_${OUTPUT_NAME}"
+mkdir -p "$EXP_DIR"
+
+LOG_FILE="$EXP_DIR/log_${TIMESTAMP}.log"
+OUTPUT_PATH="$EXP_DIR/output.mp4"
+
+export PYTHONPATH="$MAGI_ROOT:$PYTHONPATH"
+python3 inference/pipeline/flowcache.py \
+    --config_file config/single_run/flowcache_v2v.json \
+    --mode v2v \
+    --prompt "Two pillows on a table and two grabber tools hanging above them from which a brown tennis ball and an orange block are suspended. The grabber tools let go of the ball and block. Static shot with no camera movement." \
+    --prefix_video_path "/path/to/physicsiq/conditioning_video.mp4" \
+    --output_path $OUTPUT_PATH \
+    --additional_config addconfig/config.yaml \
+    2>&1 | tee $LOG_FILE
+
+# a cat sitting on the grass

FlowCache/FlowCache4MAGI-1-dev5-history/scripts/single_run/historycache_t2v.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+export MASTER_ADDR=localhost
+export MASTER_PORT=6010
+export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-1}"
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MAGI_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+cd "$MAGI_ROOT"
+source "${HOME}/miniforge3/etc/profile.d/conda.sh" 2>/dev/null || source "${HOME}/anaconda3/etc/profile.d/conda.sh"
+conda activate magi
+HISTORYCACHE_CONFIG="${HISTORYCACHE_CONFIG:-yaml_config/single_run/historycache_config.yaml}"
+RUN_ID="${RUN_ID:-$(date +%Y%m%d_%H%M%S)}"
+EXP_DIR="${RUN_DIR:-outputs/a_woman_dancing_historycache_$RUN_ID}"
+mkdir -p "$EXP_DIR"
+export PYTHONPATH="$MAGI_ROOT:$(dirname "$MAGI_ROOT")/FlowCache4MAGI-1-dev4-detail:$(dirname "$MAGI_ROOT")/FlowCache4MAGI-1-dev3-motion"
+python3 inference/pipeline/motioncache.py \
+  --config_file config/single_run/flowcache_t2v.json \
+  --mode t2v --prompt "${PROMPT:-a woman dancing.}" \
+  --output_path "$EXP_DIR/output_$RUN_ID.mp4" \
+  --additional_config "$HISTORYCACHE_CONFIG" \
+  --motioncache_metric_stats_path "$EXP_DIR/metrics_$RUN_ID.json" \
+  2>&1 | tee "$EXP_DIR/infer_$RUN_ID.log"

FlowCache/FlowCache4MAGI-1-dev5-history/scripts/single_run/motioncache_t2v.sh

@@ -0,0 +1,122 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+export MASTER_ADDR=localhost
+export MASTER_PORT=6006
+export GPUS_PER_NODE=1
+export NNODES=1
+export WORLD_SIZE=1
+export CUDA_VISIBLE_DEVICES=0
+
+export PAD_HQ=1
+export PAD_DURATION=1
+
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+export OFFLOAD_T5_CACHE=true
+export OFFLOAD_VAE_CACHE=true
+export TORCH_CUDA_ARCH_LIST="8.9;9.0"
+
+set -euo pipefail
+
+# MAGI inference requires the `magi` conda environment (flashinfer, etc.)
+if [ -z "${CONDA_DEFAULT_ENV:-}" ] || [ "${CONDA_DEFAULT_ENV}" != "magi" ]; then
+    if [ -f "${HOME}/miniforge3/etc/profile.d/conda.sh" ]; then
+        # shellcheck disable=SC1091
+        source "${HOME}/miniforge3/etc/profile.d/conda.sh"
+        conda activate magi
+    elif [ -f "${HOME}/anaconda3/etc/profile.d/conda.sh" ]; then
+        # shellcheck disable=SC1091
+        source "${HOME}/anaconda3/etc/profile.d/conda.sh"
+        conda activate magi
+    fi
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MAGI_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+cd "$MAGI_ROOT"
+
+PROMPT="${PROMPT:-a woman dancing.}"
+TIMESTAMP="${RUN_ID:-$(date "+%Y-%m-%d_%H-%M-%S")}"
+PROMPT_DIR_NAME="${PROMPT_DIR_NAME:-$(python3 - "$PROMPT" <<'PY'
+import re
+import sys
+import unicodedata
+
+prompt = unicodedata.normalize("NFKC", sys.argv[1]).strip()
+prompt = re.sub(r"[\\/:\*\?\"<>\|\x00-\x1f]+", "_", prompt)
+prompt = re.sub(r"\s+", "_", prompt)
+prompt = prompt.strip("._")
+print((prompt or "prompt")[:120])
+PY
+)}"
+OUTPUT_ROOT="${OUTPUT_ROOT:-outputs}"
+EXP_DIR="${RUN_DIR:-$OUTPUT_ROOT/${PROMPT_DIR_NAME}_motioncache_$TIMESTAMP}"
+mkdir -p "$EXP_DIR"
+
+MOTIONCACHE_CONFIG="${MOTIONCACHE_CONFIG:-yaml_config/single_run/motioncache_config.yaml}"
+
+OUTPUT_PATH="${OUTPUT_PATH:-$EXP_DIR/output_$TIMESTAMP.mp4}"
+RESIDUAL_JSON="${RESIDUAL_JSON:-$EXP_DIR/residual_stats_$TIMESTAMP.json}"
+RESIDUAL_PNG="${RESIDUAL_PNG:-$EXP_DIR/residual_norms_$TIMESTAMP.png}"
+L1_REL_JSON="${L1_REL_JSON:-$EXP_DIR/l1_rel_stats_$TIMESTAMP.json}"
+L1_REL_PNG="${L1_REL_PNG:-$EXP_DIR/l1_rel_$TIMESTAMP.png}"
+MOTIONCACHE_METRIC_JSON="${MOTIONCACHE_METRIC_JSON:-$EXP_DIR/motioncache_metric_stats_$TIMESTAMP.json}"
+LOG_FILE="${LOG_FILE:-$EXP_DIR/infer_$TIMESTAMP.log}"
+
+export PYTHONPATH="$MAGI_ROOT:${PYTHONPATH:-}"
+python3 inference/pipeline/motioncache.py \
+    --config_file config/single_run/flowcache_t2v.json \
+    --mode t2v \
+    --prompt "$PROMPT" \
+    --output_path "$OUTPUT_PATH" \
+    --additional_config "$MOTIONCACHE_CONFIG" \
+    --residual_stats_path "$RESIDUAL_JSON" \
+    --l1_rel_stats_path "$L1_REL_JSON" \
+    --motioncache_metric_stats_path "$MOTIONCACHE_METRIC_JSON" \
+    2>&1 | tee "$LOG_FILE"
+
+if [ ! -f "$OUTPUT_PATH" ]; then
+    echo "ERROR: inference failed, output video not found: $OUTPUT_PATH"
+    exit 1
+fi
+
+if [ -f "$RESIDUAL_JSON" ]; then
+    python3 tools/plot_residual_norms.py "$RESIDUAL_JSON" -o "$RESIDUAL_PNG"
+fi
+if [ -f "$L1_REL_JSON" ]; then
+    python3 tools/plot_l1_rel.py "$L1_REL_JSON" -o "$L1_REL_PNG"
+fi
+
+python3 - "$MOTIONCACHE_METRIC_JSON" <<'PY'
+import json
+import sys
+
+with open(sys.argv[1], "r") as f:
+    payload = json.load(f)
+
+print("MotionCache hyperparameters:", payload.get("hyperparameters", {}))
+summary = payload.get("chunk_execution_summary", {})
+print("MotionCache execution summary:")
+for chunk_id in sorted(summary, key=lambda value: int(value)):
+    item = summary[chunk_id]
+    print(
+        "  chunk {chunk_idx}: reuse={reuse_steps}, compute={compute_steps}, "
+        "total={total_steps}, reuse_rate={reuse_rate:.2%}".format(**item)
+    )
+PY
+
+echo "Done."
+echo "  log: $LOG_FILE"
+echo "  video: $OUTPUT_PATH"
+echo "  motioncache metric json: $MOTIONCACHE_METRIC_JSON"

FlowCache/FlowCache4MAGI-1-dev5-history/scripts/single_run/motiondetail_t2v.sh

@@ -0,0 +1,120 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the License.
+
+export MASTER_ADDR=localhost
+export MASTER_PORT=6007
+export GPUS_PER_NODE=1
+export NNODES=1
+export WORLD_SIZE=1
+export CUDA_VISIBLE_DEVICES=0
+
+export PAD_HQ=1
+export PAD_DURATION=1
+
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+export OFFLOAD_T5_CACHE=true
+export OFFLOAD_VAE_CACHE=true
+export TORCH_CUDA_ARCH_LIST="8.9;9.0"
+
+set -euo pipefail
+
+if [ -z "${CONDA_DEFAULT_ENV:-}" ] || [ "${CONDA_DEFAULT_ENV}" != "magi" ]; then
+    if [ -f "${HOME}/miniforge3/etc/profile.d/conda.sh" ]; then
+        # shellcheck disable=SC1091
+        source "${HOME}/miniforge3/etc/profile.d/conda.sh"
+        conda activate magi
+    elif [ -f "${HOME}/anaconda3/etc/profile.d/conda.sh" ]; then
+        # shellcheck disable=SC1091
+        source "${HOME}/anaconda3/etc/profile.d/conda.sh"
+        conda activate magi
+    fi
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MAGI_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+cd "$MAGI_ROOT"
+
+PROMPT="${PROMPT:-a woman dancing.}"
+TIMESTAMP="${RUN_ID:-$(date "+%Y-%m-%d_%H-%M-%S")}"
+PROMPT_DIR_NAME="${PROMPT_DIR_NAME:-$(python3 - "$PROMPT" <<'PY'
+import re
+import sys
+import unicodedata
+
+prompt = unicodedata.normalize("NFKC", sys.argv[1]).strip()
+prompt = re.sub(r"[\\/:\*\?\"<>\|\x00-\x1f]+", "_", prompt)
+prompt = re.sub(r"\s+", "_", prompt)
+prompt = prompt.strip("._")
+print((prompt or "prompt")[:120])
+PY
+)}"
+OUTPUT_ROOT="${OUTPUT_ROOT:-outputs}"
+EXP_DIR="${RUN_DIR:-$OUTPUT_ROOT/${PROMPT_DIR_NAME}_motiondetail_$TIMESTAMP}"
+mkdir -p "$EXP_DIR"
+
+MOTIONDETAIL_CONFIG="${MOTIONDETAIL_CONFIG:-yaml_config/single_run/motiondetail_config.yaml}"
+
+OUTPUT_PATH="${OUTPUT_PATH:-$EXP_DIR/output_$TIMESTAMP.mp4}"
+RESIDUAL_JSON="${RESIDUAL_JSON:-$EXP_DIR/residual_stats_$TIMESTAMP.json}"
+RESIDUAL_PNG="${RESIDUAL_PNG:-$EXP_DIR/residual_norms_$TIMESTAMP.png}"
+L1_REL_JSON="${L1_REL_JSON:-$EXP_DIR/l1_rel_stats_$TIMESTAMP.json}"
+L1_REL_PNG="${L1_REL_PNG:-$EXP_DIR/l1_rel_$TIMESTAMP.png}"
+METRIC_JSON="${METRIC_JSON:-$EXP_DIR/motiondetail_metric_stats_$TIMESTAMP.json}"
+LOG_FILE="${LOG_FILE:-$EXP_DIR/infer_$TIMESTAMP.log}"
+
+export PYTHONPATH="$MAGI_ROOT:${PYTHONPATH:-}"
+python3 inference/pipeline/motioncache.py \
+    --config_file config/single_run/flowcache_t2v.json \
+    --mode t2v \
+    --prompt "$PROMPT" \
+    --output_path "$OUTPUT_PATH" \
+    --additional_config "$MOTIONDETAIL_CONFIG" \
+    --residual_stats_path "$RESIDUAL_JSON" \
+    --l1_rel_stats_path "$L1_REL_JSON" \
+    --motioncache_metric_stats_path "$METRIC_JSON" \
+    2>&1 | tee "$LOG_FILE"
+
+if [ ! -f "$OUTPUT_PATH" ]; then
+    echo "ERROR: inference failed, output video not found: $OUTPUT_PATH"
+    exit 1
+fi
+
+if [ -f "$RESIDUAL_JSON" ]; then
+    python3 tools/plot_residual_norms.py "$RESIDUAL_JSON" -o "$RESIDUAL_PNG"
+fi
+if [ -f "$L1_REL_JSON" ]; then
+    python3 tools/plot_l1_rel.py "$L1_REL_JSON" -o "$L1_REL_PNG"
+fi
+
+python3 - "$METRIC_JSON" <<'PY'
+import json
+import sys
+
+with open(sys.argv[1], "r") as f:
+    payload = json.load(f)
+
+print("MotionDetailCache hyperparameters:", payload.get("hyperparameters", {}))
+summary = payload.get("chunk_execution_summary", {})
+print("MotionDetailCache execution summary:")
+for chunk_id in sorted(summary, key=lambda value: int(value)):
+    item = summary[chunk_id]
+    print(
+        "  chunk {chunk_idx}: reuse={reuse_steps}, compute={compute_steps}, "
+        "total={total_steps}, reuse_rate={reuse_rate:.2%}".format(**item)
+    )
+PY
+
+echo "Done."
+echo "  log: $LOG_FILE"
+echo "  video: $OUTPUT_PATH"
+echo "  metric json: $METRIC_JSON"

FlowCache/FlowCache4MAGI-1-dev5-history/scripts/single_run/teacache_t2v.sh

@@ -0,0 +1,50 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+export MASTER_ADDR=localhost
+export MASTER_PORT=6002
+export GPUS_PER_NODE=1
+export NNODES=1
+export WORLD_SIZE=1
+export CUDA_VISIBLE_DEVICES=2
+
+export PAD_HQ=1
+export PAD_DURATION=1
+
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+export OFFLOAD_T5_CACHE=true
+export OFFLOAD_VAE_CACHE=true
+export TORCH_CUDA_ARCH_LIST="8.9;9.0"
+
+MAGI_ROOT=$(git rev-parse --show-toplevel)
+
+
+OUTPUT_NAME=allreuse
+TIMESTAMP=$(date "+%Y-%m-%d_%H-%M-%S")
+EXP_DIR="/path/to/output/magi/${TIMESTAMP}_${OUTPUT_NAME}"
+mkdir -p "$EXP_DIR"
+
+LOG_FILE="$EXP_DIR/log_${TIMESTAMP}.log"
+exec > >(tee -a "$LOG_FILE") 2>&1
+OUTPUT_PATH="$EXP_DIR/output.mp4"
+
+export PYTHONPATH="$MAGI_ROOT:$PYTHONPATH"
+python3 inference/pipeline/teacache_all.py \
+    --rel_l1_thresh 0.01 \
+    --warmup_steps 5 \
+    --config_file config/single_run/flowcache_t2v.json \
+    --mode t2v \
+    --prompt "A fantasy landscape" \
+    --log \
+    --output_path $OUTPUT_PATH \

FlowCache/FlowCache4MAGI-1-dev5-history/scripts/single_run/teacache_v2v.sh

@@ -0,0 +1,52 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+export MASTER_ADDR=localhost
+export MASTER_PORT=6012
+export GPUS_PER_NODE=1
+export NNODES=1
+export WORLD_SIZE=1
+export CUDA_VISIBLE_DEVICES=1
+export CUDA_HOME="/usr/local/cuda-12.1"
+
+export PAD_HQ=1
+export PAD_DURATION=1
+
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+export OFFLOAD_T5_CACHE=true
+export OFFLOAD_VAE_CACHE=true
+export TORCH_CUDA_ARCH_LIST="8.9;9.0"
+
+MAGI_ROOT=$(git rev-parse --show-toplevel)
+
+
+OUTPUT_NAME=allreuse
+TIMESTAMP=$(date "+%Y-%m-%d_%H-%M-%S")
+EXP_DIR="/path/to/output/magi/${TIMESTAMP}_${OUTPUT_NAME}"
+mkdir -p "$EXP_DIR"
+
+LOG_FILE="$EXP_DIR/log_${TIMESTAMP}.log"
+exec > >(tee -a "$LOG_FILE") 2>&1
+OUTPUT_PATH="$EXP_DIR/output.mp4"
+
+export PYTHONPATH="$MAGI_ROOT:$PYTHONPATH"
+python3 inference/pipeline/teacache_all.py \
+    --rel_l1_thresh 0.01 \
+    --warmup_steps 5 \
+    --config_file config/single_run/all_reuse.json \
+    --mode v2v \
+    --prompt "Two pillows on a table and two grabber tools hanging above them from which a brown tennis ball and an orange block are suspended. The grabber tools let go of the ball and block. Static shot with no camera movement." \
+    --prefix_video_path "/path/to/physicsiq/conditioning_video.mp4" \
+    --output_path $OUTPUT_PATH \
+    --log \

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/sample/flowcache_physicsiq.yaml

@@ -0,0 +1,36 @@
+# FlowCache PhysicsIQ configuration file
+# Usage: bash scripts/sample/flowcache_physicsiq.sh <path_to_this_yaml>
+
+# Basic configuration
+benchmark: physicsiq
+config_file: config/sample/5s_physicsiq.json
+
+# GPU configuration
+gpus: all
+
+# PhysicsIQ dataset configuration
+physicsiq_data_dir: /path/to/physicsiq
+
+# Output path configuration
+base_save_path: /path/to/output/physicsiq
+
+# Reuse strategy configuration
+reuse_strategy: chunkwise
+rel_l1_thresh: 0.01
+warmup_steps: 5
+
+# KV cache compression configuration
+compress_kv_cache: true
+total_cache_chunk_nums: 6
+compress_strategy: token
+query_granularity: token
+mix_lambda: 0.07
+score_weighting_method: no_weight
+power: 3
+
+# Sampling range control
+start: 150
+end: 200
+
+# Log configuration
+log: false

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/sample/flowcache_vbench.yaml

@@ -0,0 +1,36 @@
+# FlowCache VBench configuration file
+# Usage: bash scripts/sample/flowcache_vbench.sh <path_to_this_yaml>
+
+# Basic configuration
+benchmark: vbench
+config_file: config/sample/vbench.json
+
+# GPU configuration
+gpus: all
+
+# VBench dataset configuration
+vbench_prompt_dir: downloads/vbench/prompts_per_dimension
+
+# Dimension configuration (specify the current dimension to process)
+dimension: overall_consistency  # Options: subject_consistency, scene, object_class, multiple_objects, color, spatial_relationship, temporal_style, human_action, temporal_flickering, appearance_style
+
+# Output path configuration
+base_save_path: outputs/vbench
+
+# Reuse strategy configuration
+reuse_strategy: chunkwise
+rel_l1_thresh: 0.01
+warmup_steps: 5
+
+# KV cache compression configuration
+compress_kv_cache: true
+total_cache_chunk_nums: 6
+budget_cache_chunk_nums: 1
+compress_strategy: token
+query_granularity: chunk
+mix_lambda: 0.07
+score_weighting_method: no_weight
+discard_nearly_clean_chunk: true
+
+# Log configuration
+log: false

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/sample/teacache_physicsiq.yaml

@@ -0,0 +1,23 @@
+# TeaCache PhysicsIQ configuration file
+# Usage: bash scripts/sample/teacache_physicsiq.sh <path_to_this_yaml>
+
+# Basic configuration
+benchmark: physicsiq
+config_file: config/sample/5s_physicsiq.json
+
+# GPU configuration
+gpus: all
+
+# PhysicsIQ dataset configuration
+physicsiq_data_dir: /path/to/physicsiq
+
+# Output path configuration
+base_save_path: /path/to/output/physicsiq
+
+# Reuse strategy configuration
+reuse_strategy: all
+rel_l1_thresh: 0.01
+warmup_steps: 5
+
+# Log configuration
+log: false

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/sample/teacache_vbench.yaml

@@ -0,0 +1,26 @@
+# TeaCache VBench configuration file
+# Usage: bash scripts/sample/teacache_vbench.sh <path_to_this_yaml>
+
+# Basic configuration
+benchmark: vbench
+config_file: config/sample/vbench.json
+
+# GPU configuration
+gpus: all
+
+# VBench dataset configuration
+vbench_prompt_dir: downloads/vbench/prompts_per_dimension
+
+# Dimension configuration (specify the current dimension to process)
+dimension: overall_consistency  # Options: subject_consistency, scene, object_class, multiple_objects, color, spatial_relationship, temporal_style, human_action, temporal_flickering, appearance_style
+
+# Output path configuration
+base_save_path: /path/to/output/vbench
+
+# Reuse strategy configuration
+reuse_strategy: all
+rel_l1_thresh: 0.01
+warmup_steps: 5
+
+# Log configuration
+log: false

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/config.yaml

@@ -0,0 +1,15 @@
+rel_l1_thresh: 0.015
+warmup_steps: 5
+discard_nearly_clean_chunk: true
+
+compress_kv_cache: true
+total_cache_chunk_nums: 5
+compress_strategy: token
+mix_lambda: 0.07
+query_granularity: frame
+score_weighting_method: no_weight
+power: 3
+
+log: true
+print_peak_memory: true
+debug: false

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/history_anchor0.5.yaml

@@ -0,0 +1,25 @@
+alpha: 0.5
+compress_kv_cache: true
+compress_strategy: token
+detail_alpha: 0.5
+detail_lambda: 0.3
+detail_window_size: 3
+discard_nearly_clean_chunk: true
+history_anchor_alpha: 0.5
+history_anchor_horizon: 3
+history_anchor_lambda: 0.5
+history_decay: 0.7
+history_streak_gamma: 0.2
+history_streak_len: 5
+log: false
+mix_lambda: 0.07
+phase1_steps: 9
+power: 3
+print_peak_memory: true
+query_granularity: frame
+rel_l1_thresh: 0.012
+score_weighting_method: no_weight
+total_cache_chunk_nums: 5
+use_history_cache: true
+warmup_steps: 5
+weight_combine_mode: blend

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/history_decay0.5.yaml

@@ -0,0 +1,25 @@
+alpha: 0.5
+compress_kv_cache: true
+compress_strategy: token
+detail_alpha: 0.5
+detail_lambda: 0.3
+detail_window_size: 3
+discard_nearly_clean_chunk: true
+history_anchor_alpha: 0.5
+history_anchor_horizon: 3
+history_anchor_lambda: 0.3
+history_decay: 0.5
+history_streak_gamma: 0.2
+history_streak_len: 5
+log: false
+mix_lambda: 0.07
+phase1_steps: 9
+power: 3
+print_peak_memory: true
+query_granularity: frame
+rel_l1_thresh: 0.012
+score_weighting_method: no_weight
+total_cache_chunk_nums: 5
+use_history_cache: true
+warmup_steps: 5
+weight_combine_mode: blend

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/history_decay0.85.yaml

@@ -0,0 +1,25 @@
+alpha: 0.5
+compress_kv_cache: true
+compress_strategy: token
+detail_alpha: 0.5
+detail_lambda: 0.3
+detail_window_size: 3
+discard_nearly_clean_chunk: true
+history_anchor_alpha: 0.5
+history_anchor_horizon: 3
+history_anchor_lambda: 0.3
+history_decay: 0.85
+history_streak_gamma: 0.2
+history_streak_len: 5
+log: false
+mix_lambda: 0.07
+phase1_steps: 9
+power: 3
+print_peak_memory: true
+query_granularity: frame
+rel_l1_thresh: 0.012
+score_weighting_method: no_weight
+total_cache_chunk_nums: 5
+use_history_cache: true
+warmup_steps: 5
+weight_combine_mode: blend

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/history_streak0.35.yaml

@@ -0,0 +1,25 @@
+alpha: 0.5
+compress_kv_cache: true
+compress_strategy: token
+detail_alpha: 0.5
+detail_lambda: 0.3
+detail_window_size: 3
+discard_nearly_clean_chunk: true
+history_anchor_alpha: 0.5
+history_anchor_horizon: 3
+history_anchor_lambda: 0.3
+history_decay: 0.7
+history_streak_gamma: 0.35
+history_streak_len: 5
+log: false
+mix_lambda: 0.07
+phase1_steps: 9
+power: 3
+print_peak_memory: true
+query_granularity: frame
+rel_l1_thresh: 0.012
+score_weighting_method: no_weight
+total_cache_chunk_nums: 5
+use_history_cache: true
+warmup_steps: 5
+weight_combine_mode: blend

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/historycache_config.yaml

@@ -0,0 +1,29 @@
+# dev5 HistoryAwareCache — inherits dev4 best + AR history (MVP)
+rel_l1_thresh: 0.012
+warmup_steps: 5
+phase1_steps: 9
+alpha: 0.5
+
+detail_alpha: 0.5
+detail_window_size: 3
+detail_lambda: 0.3
+weight_combine_mode: blend
+
+use_history_cache: true
+history_decay: 0.7
+history_anchor_horizon: 3
+history_streak_len: 5
+history_anchor_lambda: 0.3
+history_streak_gamma: 0.2
+history_anchor_alpha: 0.5
+
+discard_nearly_clean_chunk: true
+compress_kv_cache: true
+total_cache_chunk_nums: 5
+compress_strategy: token
+mix_lambda: 0.07
+query_granularity: frame
+score_weighting_method: no_weight
+power: 3
+log: false
+print_peak_memory: true

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/historycache_config_best.yaml

@@ -0,0 +1,29 @@
+# dev5 HistoryAwareCache — inherits dev4 best + AR history (MVP)
+rel_l1_thresh: 0.012
+warmup_steps: 5
+phase1_steps: 9
+alpha: 0.5
+
+detail_alpha: 0.5
+detail_window_size: 3
+detail_lambda: 0.3
+weight_combine_mode: blend
+
+use_history_cache: true
+history_decay: 0.7
+history_anchor_horizon: 3
+history_streak_len: 5
+history_anchor_lambda: 0.3
+history_streak_gamma: 0.2
+history_anchor_alpha: 0.5
+
+discard_nearly_clean_chunk: true
+compress_kv_cache: true
+total_cache_chunk_nums: 5
+compress_strategy: token
+mix_lambda: 0.07
+query_granularity: frame
+score_weighting_method: no_weight
+power: 3
+log: false
+print_peak_memory: true

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/motioncache_config.yaml

@@ -0,0 +1,19 @@
+# MotionCache hyperparameters for MAGI-1 (Appendix C)
+rel_l1_thresh: 0.015
+warmup_steps: 5
+phase1_steps: 9
+alpha: 0.5
+
+discard_nearly_clean_chunk: true
+
+compress_kv_cache: true
+total_cache_chunk_nums: 5
+compress_strategy: token
+mix_lambda: 0.07
+query_granularity: frame
+score_weighting_method: no_weight
+power: 3
+
+log: true
+print_peak_memory: true
+debug: false

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/motioncache_config_fast.yaml

@@ -0,0 +1,19 @@
+# MotionCache-fast: higher threshold for more aggressive skipping
+rel_l1_thresh: 0.025
+warmup_steps: 5
+phase1_steps: 9
+alpha: 0.5
+
+discard_nearly_clean_chunk: true
+
+compress_kv_cache: true
+total_cache_chunk_nums: 5
+compress_strategy: token
+mix_lambda: 0.07
+query_granularity: frame
+score_weighting_method: no_weight
+power: 3
+
+log: true
+print_peak_memory: true
+debug: false

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/motioncache_phase1_only.yaml

@@ -0,0 +1,19 @@
+# MotionCache with phase2 disabled (K=64, always chunk-wise = FlowCache equivalent)
+rel_l1_thresh: 0.015
+warmup_steps: 5
+phase1_steps: 64
+alpha: 0.5
+
+discard_nearly_clean_chunk: true
+
+compress_kv_cache: true
+total_cache_chunk_nums: 5
+compress_strategy: token
+mix_lambda: 0.07
+query_granularity: frame
+score_weighting_method: no_weight
+power: 3
+
+log: false
+print_peak_memory: true
+debug: false

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/motiondetail_config.yaml

@@ -0,0 +1,25 @@
+# MotionDetailCache: MotionCache + spatial detail variance (dev4)
+rel_l1_thresh: 0.015
+warmup_steps: 5
+phase1_steps: 9
+alpha: 0.5
+
+# Detail metric: local latent spatial variance
+detail_alpha: 0.5
+detail_window_size: 3
+detail_lambda: 0.5
+weight_combine_mode: max  # max | product | blend
+
+discard_nearly_clean_chunk: true
+
+compress_kv_cache: true
+total_cache_chunk_nums: 5
+compress_strategy: token
+mix_lambda: 0.07
+query_granularity: frame
+score_weighting_method: no_weight
+power: 3
+
+log: true
+print_peak_memory: true
+debug: false

FlowCache/FlowCache4MAGI-1-dev5-history/yaml_config/single_run/motiondetail_config_best.yaml

@@ -0,0 +1,13 @@
+alpha: 0.5
+compress_kv_cache: true
+detail_alpha: 0.5
+detail_lambda: 0.3
+detail_window_size: 3
+discard_nearly_clean_chunk: true
+log: true
+phase1_steps: 9
+print_peak_memory: true
+rel_l1_thresh: 0.012
+total_cache_chunk_nums: 5
+warmup_steps: 5
+weight_combine_mode: blend

FlowCache/FlowCache4MAGI-1-dev6-adaptive/config/sample/physicsiq.json

@@ -0,0 +1,81 @@
+{
+    "model_config": {
+        "model_name": "videodit_ardf",
+        "num_layers": 34,
+        "hidden_size": 3072,
+        "ffn_hidden_size": 12288,
+        "num_attention_heads": 24,
+        "num_query_groups": 8,
+        "kv_channels": 128,
+        "layernorm_epsilon": 1e-06,
+        "apply_layernorm_1p": true,
+        "x_rescale_factor": 1,
+        "half_channel_vae": false,
+        "params_dtype": "torch.bfloat16",
+        "patch_size": 2,
+        "t_patch_size": 1,
+        "in_channels": 16,
+        "out_channels": 16,
+        "cond_hidden_ratio": 0.25,
+        "caption_channels": 4096,
+        "caption_max_length": 800,
+        "xattn_cond_hidden_ratio": 1.0,
+        "cond_gating_ratio": 1.0,
+        "gated_linear_unit": false
+    },
+    "runtime_config": {
+        "cfg_number": 1,
+        "cfg_t_range": [
+            0.0,
+            0.0217,
+            0.1,
+            0.3,
+            0.999
+        ],
+        "prev_chunk_scales": [
+            1.5,
+            1.5,
+            1.5,
+            1.0,
+            1.0
+        ],
+        "text_scales": [
+            7.5,
+            7.5,
+            7.5,
+            0.0,
+            0.0
+        ],
+        "noise2clean_kvrange": [],
+        "clean_chunk_kvrange": 1,
+        "clean_t": 0.9999,
+        "seed": 1234,
+        "num_frames": 120,
+        "video_size_h": 720,
+        "video_size_w": 1280,
+        "num_steps": 64,
+        "window_size": 4,
+        "fps": 24,
+        "chunk_width": 6,
+        "load": "./downloads/4.5B_distill",
+        "t5_pretrained": "./downloads/t5_pretrained",
+        "t5_device": "cuda",
+        "vae_pretrained": "./downloads/vae",
+        "scale_factor": 0.18215,
+        "temporal_downsample_factor": 4
+    },
+    "engine_config": {
+        "distributed_backend": "nccl",
+        "distributed_timeout_minutes": 15,
+        "pp_size": 1,
+        "cp_size": 1,
+        "cp_strategy": "none",
+        "ulysses_overlap_degree": 1,
+        "fp8_quant": false,
+        "distill_nearly_clean_chunk_threshold": 0.3,
+        "shortcut_mode": "8,16,16",
+        "distill": true,
+        "kv_offload": true,
+        "enable_cuda_graph": false
+    }
+}

FlowCache/FlowCache4MAGI-1-dev6-adaptive/config/sample/vbench.json

@@ -0,0 +1,81 @@
+{
+    "model_config": {
+        "model_name": "videodit_ardf",
+        "num_layers": 34,
+        "hidden_size": 3072,
+        "ffn_hidden_size": 12288,
+        "num_attention_heads": 24,
+        "num_query_groups": 8,
+        "kv_channels": 128,
+        "layernorm_epsilon": 1e-06,
+        "apply_layernorm_1p": true,
+        "x_rescale_factor": 1,
+        "half_channel_vae": false,
+        "params_dtype": "torch.bfloat16",
+        "patch_size": 2,
+        "t_patch_size": 1,
+        "in_channels": 16,
+        "out_channels": 16,
+        "cond_hidden_ratio": 0.25,
+        "caption_channels": 4096,
+        "caption_max_length": 800,
+        "xattn_cond_hidden_ratio": 1.0,
+        "cond_gating_ratio": 1.0,
+        "gated_linear_unit": false
+    },
+    "runtime_config": {
+        "cfg_number": 1,
+        "cfg_t_range": [
+            0.0,
+            0.0217,
+            0.1,
+            0.3,
+            0.999
+        ],
+        "prev_chunk_scales": [
+            1.5,
+            1.5,
+            1.5,
+            1.0,
+            1.0
+        ],
+        "text_scales": [
+            7.5,
+            7.5,
+            7.5,
+            0.0,
+            0.0
+        ],
+        "noise2clean_kvrange": [],
+        "clean_chunk_kvrange": 1,
+        "clean_t": 0.9999,
+        "seed": 1234,
+        "num_frames": 240,
+        "video_size_h": 720,
+        "video_size_w": 720,
+        "num_steps": 16,
+        "window_size": 4,
+        "fps": 24,
+        "chunk_width": 6,
+        "load": "./downloads/4.5B_distill",
+        "t5_pretrained": "./downloads/t5_pretrained",
+        "t5_device": "cuda",
+        "vae_pretrained": "./downloads/vae",
+        "scale_factor": 0.18215,
+        "temporal_downsample_factor": 4
+    },
+    "engine_config": {
+        "distributed_backend": "nccl",
+        "distributed_timeout_minutes": 15,
+        "pp_size": 1,
+        "cp_size": 1,
+        "cp_strategy": "none",
+        "ulysses_overlap_degree": 1,
+        "fp8_quant": false,
+        "distill_nearly_clean_chunk_threshold": 0.3,
+        "shortcut_mode": "8,16,16",
+        "distill": true,
+        "kv_offload": true,
+        "enable_cuda_graph": false
+    }
+}

FlowCache/FlowCache4MAGI-1-dev6-adaptive/config/single_run/flowcache_t2v.json

@@ -0,0 +1,81 @@
+{
+    "model_config": {
+        "model_name": "videodit_ardf",
+        "num_layers": 34,
+        "hidden_size": 3072,
+        "ffn_hidden_size": 12288,
+        "num_attention_heads": 24,
+        "num_query_groups": 8,
+        "kv_channels": 128,
+        "layernorm_epsilon": 1e-06,
+        "apply_layernorm_1p": true,
+        "x_rescale_factor": 1,
+        "half_channel_vae": false,
+        "params_dtype": "torch.bfloat16",
+        "patch_size": 2,
+        "t_patch_size": 1,
+        "in_channels": 16,
+        "out_channels": 16,
+        "cond_hidden_ratio": 0.25,
+        "caption_channels": 4096,
+        "caption_max_length": 800,
+        "xattn_cond_hidden_ratio": 1.0,
+        "cond_gating_ratio": 1.0,
+        "gated_linear_unit": false
+    },
+    "runtime_config": {
+        "cfg_number": 1,
+        "cfg_t_range": [
+            0.0,
+            0.0217,
+            0.1,
+            0.3,
+            0.999
+        ],
+        "prev_chunk_scales": [
+            1.5,
+            1.5,
+            1.5,
+            1.0,
+            1.0
+        ],
+        "text_scales": [
+            7.5,
+            7.5,
+            7.5,
+            0.0,
+            0.0
+        ],
+        "noise2clean_kvrange": [],
+        "clean_chunk_kvrange": 1,
+        "clean_t": 0.9999,
+        "seed": 1234,
+        "num_frames": 240,
+        "video_size_h": 720,
+        "video_size_w": 720,
+        "num_steps": 64,
+        "window_size": 4,
+        "fps": 24,
+        "chunk_width": 6,
+        "load": "./downloads/4.5B_distill",
+        "t5_pretrained": "./downloads/t5_pretrained",
+        "t5_device": "cuda",
+        "vae_pretrained": "./downloads/vae",
+        "scale_factor": 0.18215,
+        "temporal_downsample_factor": 4
+    },
+    "engine_config": {
+        "distributed_backend": "nccl",
+        "distributed_timeout_minutes": 15,
+        "pp_size": 1,
+        "cp_size": 1,
+        "cp_strategy": "none",
+        "ulysses_overlap_degree": 1,
+        "fp8_quant": false,
+        "distill_nearly_clean_chunk_threshold": 0.3,
+        "shortcut_mode": "8,16,16",
+        "distill": true,
+        "kv_offload": false,
+        "enable_cuda_graph": false
+    }
+}

FlowCache/FlowCache4MAGI-1-dev6-adaptive/config/single_run/flowcache_v2v.json

@@ -0,0 +1,86 @@
+{
+    "model_config": {
+        "model_name": "videodit_ardf",
+        "num_layers": 34,
+        "hidden_size": 3072,
+        "ffn_hidden_size": 12288,
+        "num_attention_heads": 24,
+        "num_query_groups": 8,
+        "kv_channels": 128,
+        "layernorm_epsilon": 1e-06,
+        "apply_layernorm_1p": true,
+        "x_rescale_factor": 1,
+        "half_channel_vae": false,
+        "params_dtype": "torch.bfloat16",
+        "patch_size": 2,
+        "t_patch_size": 1,
+        "in_channels": 16,
+        "out_channels": 16,
+        "cond_hidden_ratio": 0.25,
+        "caption_channels": 4096,
+        "caption_max_length": 800,
+        "xattn_cond_hidden_ratio": 1.0,
+        "cond_gating_ratio": 1.0,
+        "gated_linear_unit": false
+    },
+    "runtime_config": {
+        "cfg_number": 1,
+        "cfg_t_range": [
+            0.0,
+            0.0217,
+            0.1,
+            0.3,
+            0.999
+        ],
+        "prev_chunk_scales": [
+            1.5,
+            1.5,
+            1.5,
+            1.0,
+            1.0
+        ],
+        "text_scales": [
+            7.5,
+            7.5,
+            7.5,
+            0.0,
+            0.0
+        ],
+        "noise2clean_kvrange": [
+            5,
+            4,
+            3,
+            2
+        ],
+        "clean_chunk_kvrange": 1,
+        "clean_t": 0.9999,
+        "seed": 1234,
+        "num_frames": 120,
+        "video_size_h": 720,
+        "video_size_w": 1280,
+        "num_steps": 8,
+        "window_size": 4,
+        "fps": 24,
+        "chunk_width": 6,
+        "load": "./downloads/4.5B_distill",
+        "t5_pretrained": "./downloads/t5_pretrained",
+        "t5_device": "cuda",
+        "vae_pretrained": "./downloads/vae",
+        "scale_factor": 0.18215,
+        "temporal_downsample_factor": 4
+    },
+    "engine_config": {
+        "distributed_backend": "nccl",
+        "distributed_timeout_minutes": 15,
+        "pp_size": 1,
+        "cp_size": 1,
+        "cp_strategy": "none",
+        "ulysses_overlap_degree": 1,
+        "fp8_quant": false,
+        "distill_nearly_clean_chunk_threshold": 0.3,
+        "shortcut_mode": "8,16,16",
+        "distill": true,
+        "kv_offload": false,
+        "enable_cuda_graph": false
+    }
+}

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/common/__init__.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .common_utils import divide, env_is_true, set_random_seed
+from .config import EngineConfig, MagiConfig, ModelConfig, RuntimeConfig
+from .dataclass import InferenceParams, ModelMetaArgs, PackedCoreAttnParams, PackedCrossAttnParams
+from .logger import magi_logger, print_per_rank, print_rank_0
+from .timer import event_path_timer
+
+__all__ = [
+    "MagiConfig",
+    "ModelConfig",
+    "EngineConfig",
+    "RuntimeConfig",
+    "magi_logger",
+    "print_per_rank",
+    "print_rank_0",
+    "event_path_timer",
+    "divide",
+    "env_is_true",
+    "set_random_seed",
+    "PackedCoreAttnParams",
+    "PackedCrossAttnParams",
+    "ModelMetaArgs",
+    "InferenceParams",
+]

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/common/common_utils.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import random
+
+import numpy as np
+import torch
+
+
+def env_is_true(env_name: str) -> bool:
+    return str(os.environ.get(env_name, "0")).lower() in {"1", "true", "yes", "y", "on", "enabled"}
+
+
+def divide(numerator, denominator):
+    assert numerator % denominator == 0, "{} is not divisible by {}".format(numerator, denominator)
+    return numerator // denominator
+
+
+def set_random_seed(seed):
+    """Set random seed.
+
+    Args:
+        seed (int): Seed to be used.
+    """
+    assert seed is not None, "Please provide a seed in config.json"
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    return seed

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/common/config.py

@@ -0,0 +1,180 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import dataclasses
+import json
+import os
+
+import torch
+
+
+@dataclasses.dataclass
+class ModelConfig:
+    model_name: str
+
+    # Transformer
+    num_layers: int = None  # Number of transformer layers.
+    hidden_size: int = None  # Transformer hidden size.
+    ffn_hidden_size: int = None  # Transformer Feed-Forward Network hidden size
+    num_attention_heads: int = None  # Number of transformer attention heads.
+    num_query_groups: int = 1  # Number of query groups, which used for GQA
+    kv_channels: int = None  # Projection weights dimension in multi-head attention
+    layernorm_epsilon: float = 1e-6  # Epsilon for layer norm and RMS norm.
+    apply_layernorm_1p: bool = False  # Adjust LayerNorm weights which improves numerical stability.
+    x_rescale_factor: float = 1.0
+    half_channel_vae: bool = False
+    params_dtype: torch.dtype = None
+
+    # Embedding
+    patch_size: int = 2  # (latent) patch size for DiT patch embedding layer
+    t_patch_size: int = 1  # (latent) patch size for t dim patch embedding layer
+    in_channels: int = 4  # latent input channel for DiT
+    out_channels: int = 4  # latent output channel for DiT
+    cond_hidden_ratio: float = 0.25
+    caption_channels: int = 4096
+    caption_max_length: int = 800
+    xattn_cond_hidden_ratio: float = 1.0
+    cond_gating_ratio: float = 1.0
+    gated_linear_unit: bool = False
+
+
+@dataclasses.dataclass
+class RuntimeConfig:
+    # Inference settings such as cfg, kv range, clean t, etc.
+    cfg_number: int = None  # Number of CFG
+    cfg_t_range: list = dataclasses.field(
+        default_factory=lambda: [0, 0.0217, 0.1000, 0.3, 0.999]
+    )  # CFG t-range of each scales
+    prev_chunk_scales: list = dataclasses.field(
+        default_factory=lambda: [1.5, 1.5, 1.5, 1.5, 1.5]
+    )  # CFG scales of previous chunks
+    text_scales: list = dataclasses.field(default_factory=lambda: [7.5, 7.5, 7.5, 7.5, 7.5])  # CFG scales of text
+
+    noise2clean_kvrange: list = dataclasses.field(default_factory=list)  # Range of kv for noise2clean chunks
+    clean_chunk_kvrange: int = -1  # Range of kv for clean chunks
+    clean_t: float = 1.0  # timestep for clean chunks
+
+    # Video settings
+    seed: int = 1234  # Random seed used for python, numpy, pytorch, and cuda.
+    num_frames: int = 128
+    video_size_h: int = None
+    video_size_w: int = None
+    num_steps: int = 64  # Number of steps for the diffusion model
+    window_size: int = 4  # Window size for the diffusion model
+    fps: int = 24  # Frames per second
+    chunk_width: int = 6  # Clip width for the diffusion model
+
+    # Checkpoint, includes t5, vae, dit, etc.
+    t5_pretrained: str = None  # Path to load pretrained T5 model.
+    t5_device: str = "cuda"  # Device for T5 model to run on.
+    vae_pretrained: str = None  # Path to load pretrained VAE model.
+    scale_factor: float = 0.18215  # Scale factor for the vae
+    temporal_downsample_factor: int = 4  # Temporal downsample factor for the vae
+    load: str = None  # Directory containing a model checkpoint.
+
+
+@dataclasses.dataclass
+class EngineConfig:
+    # Parallism strategy
+    distributed_backend: str = "nccl"  # Choices: ["nccl", "gloo"]
+    distributed_timeout_minutes: int = 10  # Timeout minutes for torch.distributed.
+    pp_size: int = 1  # Degree of pipeline model parallelism.
+    cp_size: int = 1  # Degree of context parallelism.
+    cp_strategy: str = "none"  # Choices: ["none", "cp_ulysses", "cp_shuffle_overlap"]
+    ulysses_overlap_degree: int = 1  # Overlap degree for Ulysses
+
+    # Quantization
+    fp8_quant: bool = False  # Enable 8-bit floating point quantization for model weights.
+
+    # Distillation
+    distill_nearly_clean_chunk_threshold: float = 0.3  # Threshold for distilling nearly clean chunks
+    shortcut_mode: str = "8,16,16"  # Parameters for shortcut mode
+    distill: bool = False  # Use distill mode
+
+    # Optimization
+    kv_offload: bool = False  # Use kv-offload algorithm
+    enable_cuda_graph: bool = False  # Enable CUDA graph for video generation
+
+
+@dataclasses.dataclass
+class MagiConfig:
+    model_config: ModelConfig
+    runtime_config: RuntimeConfig
+    engine_config: EngineConfig
+
+    @classmethod
+    def _check_missing_fields(cls, config_dict: dict, required_fields: list):
+        actual_fields = set(config_dict.keys())
+        missing_fields = set(required_fields) - actual_fields
+        if missing_fields:
+            raise ValueError(f"Missing fields in the configuration file: {', '.join(missing_fields)}")
+
+    @classmethod
+    def _create_nested_config(cls, config_dict: dict, config_name: str, config_cls):
+        nested_config_dict = config_dict.get(config_name, {})
+        cls._check_missing_fields(nested_config_dict, config_cls.__dataclass_fields__.keys())
+        return config_cls(**nested_config_dict)
+
+    @classmethod
+    def _create_config_from_dict(cls, config_dict: dict):
+        cls._check_missing_fields(config_dict, cls.__dataclass_fields__.keys())
+
+        # Create nested configs
+        model_config = cls._create_nested_config(config_dict, "model_config", ModelConfig)
+        runtime_config = cls._create_nested_config(config_dict, "runtime_config", RuntimeConfig)
+        engine_config = cls._create_nested_config(config_dict, "engine_config", EngineConfig)
+
+        return cls(model_config=model_config, runtime_config=runtime_config, engine_config=engine_config)
+
+    @classmethod
+    def from_json(cls, json_path: str):
+        def simple_json_decoder(dct):
+            dtype_map = {"torch.bfloat16": torch.bfloat16, "torch.float16": torch.float16, "torch.float32": torch.float32}
+            if 'params_dtype' in dct:
+                dct['params_dtype'] = dtype_map[dct['params_dtype']]
+            return dct
+
+        with open(json_path, "r") as f:
+            config_dict = json.load(f, object_hook=simple_json_decoder)
+        magi_config = cls._create_config_from_dict(config_dict)
+
+        def post_validation(magi_config):
+            if magi_config.engine_config.fp8_quant or magi_config.engine_config.distill:
+                assert (
+                    magi_config.runtime_config.cfg_number == 1
+                ), "Please set `cfg_number: 1` in config.json for distill or quant model"
+            else:
+                assert magi_config.runtime_config.cfg_number == 3, "Please set `cfg_number: 3` in config.json for base model"
+
+        post_validation(magi_config)
+
+        return magi_config
+
+    def to_json(self, json_path: str):
+        class SimpleJSONEncoder(json.JSONEncoder):
+            def default(self, obj):
+                if isinstance(obj, torch.dtype):
+                    return str(obj)
+                return super().default(obj)
+
+        # Ensure the directory exists
+        os.makedirs(os.path.dirname(json_path), exist_ok=True)
+
+        config_dict = {
+            "model_config": dataclasses.asdict(self.model_config),
+            "runtime_config": dataclasses.asdict(self.runtime_config),
+            "engine_config": dataclasses.asdict(self.engine_config),
+        }
+        with open(json_path, "w") as f:
+            json.dump(config_dict, f, indent=4, cls=SimpleJSONEncoder)

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/common/dataclass.py

@@ -0,0 +1,100 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+import numpy as np
+import torch
+
+
+@dataclass(frozen=True)
+class PackedCoreAttnParams:
+    # Packed sequence parameters for core_attn
+    q_range: torch.Tensor
+    k_range: torch.Tensor
+    np_q_range: np.ndarray
+    np_k_range: np.ndarray
+    max_seqlen_q: int
+    max_seqlen_k: int
+
+
+@dataclass(frozen=True)
+class PackedCrossAttnParams:
+    # Packed sequence parameters for cross_attn
+    q_ranges: torch.Tensor = None
+    kv_ranges: torch.Tensor = None
+    cu_seqlens_q: torch.Tensor = None
+    cu_seqlens_kv: torch.Tensor = None
+    max_seqlen_q: int = None
+    max_seqlen_kv: int = None
+
+
+@dataclass(frozen=True)
+class ModelMetaArgs:
+    H: int
+    W: int
+    cp_pad_size: int
+    cp_split_sizes: List[int]
+    slice_point: int
+    denoising_range_num: int
+    range_num: int
+    extract_prefix_video_feature: bool
+    fwd_extra_1st_chunk: bool
+    distill_nearly_clean_chunk: bool
+    clip_token_nums: int
+    enable_cuda_graph: bool
+    core_attn_params: PackedCoreAttnParams
+    cross_attn_params: PackedCrossAttnParams
+    timestep: torch.Tensor
+    get_attn_weights_layer_num: int
+    save_kvcache_every_forward: bool
+    cur_denoise_step: int
+    # Includes all chunks of the current sequence
+    start_chunk_id: int
+    end_chunk_id: int
+    compress_kv: bool    # use kv cache compression or not
+    total_cache_len: int
+    budget_cache_len: int
+    chunk_num: int
+    debug: bool
+    near_clean_chunk_idx: int
+    # MotionCache sparse forward (Phase 2): gather active tokens only
+    sparse_active_indices: Optional[torch.Tensor] = None
+    sparse_total_tokens: int = 0
+
+class InferenceParams:
+    """Inference parameters that are passed to the main model in order
+    to efficienly calculate and store the context during inference."""
+
+    def __init__(self, max_batch_size, max_sequence_length):
+        self.max_sequence_length = max_sequence_length
+        self.max_batch_size = max_batch_size
+        self.sequence_len_offset = 0
+        self.key_value_memory_dict = {}
+        self.update_kv_cache = False
+
+        self.kv_compressed = False
+
+    def swap_key_value_dict(self, batch_idx):
+        "swap between batches"
+        if len(self.key_value_memory_dict) == 0:
+            raise ValueError("should not swap when dict in empty")
+
+        for layer_number in self.key_value_memory_dict.keys():
+            inference_key_memory, inference_value_memory = self.key_value_memory_dict[layer_number]
+            assert len(batch_idx) == inference_key_memory.shape[1]  # make sure batch size is the same
+            new_inference_key_memory = inference_key_memory[:, batch_idx]
+            new_inference_value_memory = inference_value_memory[:, batch_idx]
+            self.key_value_memory_dict[layer_number] = (new_inference_key_memory, new_inference_value_memory)

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/common/logger.py

@@ -0,0 +1,51 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+import torch
+
+
+class GlobalLogger:
+    _logger = None
+
+    @classmethod
+    def get_logger(cls, name=__name__, level=logging.INFO):
+        if cls._logger is None:
+            cls._logger = logging.getLogger("magi_logger")
+            cls._logger.setLevel(logging.INFO)
+
+            cls._logger.propagate = False
+            cls._logger.handlers.clear()
+            formatter = logging.Formatter("[%(asctime)s - %(levelname)s] %(message)s")
+            handler = logging.StreamHandler()
+            handler.setFormatter(formatter)
+            cls._logger.addHandler(handler)
+
+        return cls._logger
+
+
+magi_logger = GlobalLogger.get_logger()
+
+
+def print_per_rank(message):
+    magi_logger.info(message)
+
+
+def print_rank_0(message):
+    if torch.distributed.is_initialized():
+        if torch.distributed.get_rank() == 0:
+            magi_logger.info(message)
+    else:
+        magi_logger.info(message)

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/common/timer.py

@@ -0,0 +1,85 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from datetime import datetime
+
+import torch
+
+from .logger import print_rank_0
+
+
+class EventPathTimer:
+    """
+    A lightweight class for recording time without any distributed barrier.
+
+    This class allows for recording elapsed time between events without requiring
+    synchronization across distributed processes. It maintains the previous message
+    and time to calculate the duration between consecutive records.
+    """
+
+    def __init__(self):
+        """
+        Initialize the EventPathTimer.
+
+        This constructor sets the previous message and time to None, preparing
+        the instance for recording events.
+        """
+        self.prev_message: str = None
+        self.prev_time: datetime = None
+
+    def reset(self):
+        """
+        Reset the recorded message and time.
+
+        This method clears the previous message and time, allowing for a fresh
+        start in recording new events.
+        """
+        self.prev_message = None
+        self.prev_time = None
+
+    def synced_record(self, message):
+        """
+        Record the current time with a message.
+
+        Args:
+            message (str): A message to log along with the current time.
+
+        This method synchronizes the CUDA operations, records the current time,
+        and calculates the elapsed time since the last recorded message, if any.
+        It then logs the elapsed time along with the previous and current messages.
+        """
+        torch.cuda.synchronize()
+        current_time = datetime.now()
+        if self.prev_message is not None:
+            print_rank_0(
+                f"\nTime Elapsed: [{current_time - self.prev_time}] From [{self.prev_message} ({self.prev_time})] To [{message} ({current_time})]"
+            )
+        self.prev_message = message
+        self.prev_time = current_time
+
+
+_GLOBAL_LIGHT_TIMER = EventPathTimer()
+
+
+def event_path_timer() -> EventPathTimer:
+    """Get the current EventPathTimer instance.
+
+    Returns:
+        EventPathTimer: The current EventPathTimer instance.
+
+    Raises:
+        AssertionError: If the EventPathTimer has not been initialized.
+    """
+    assert _GLOBAL_LIGHT_TIMER is not None, "light time recorder is not initialized"
+    return _GLOBAL_LIGHT_TIMER

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/infra/checkpoint/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .checkpointing import load_checkpoint
+
+__all__ = ["load_checkpoint"]

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/infra/checkpoint/checkpointing.py

@@ -0,0 +1,180 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import json
+import os
+import re
+import subprocess
+from collections import OrderedDict
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+
+import numpy as np
+import torch
+import torch.distributed
+from safetensors.torch import load as load_from_bytes
+from safetensors.torch import load_file
+from tqdm.auto import tqdm
+
+import inference.infra.distributed.parallel_state as mpu
+from inference.common import EngineConfig, ModelConfig, RuntimeConfig, print_per_rank, print_rank_0
+
+
+def _load_shard(shard_path, param_names, num_threads=None):
+    zstd_path = shard_path + ".zst"
+    if os.path.exists(zstd_path):
+        start_time = datetime.now()
+        print_per_rank(f"Decompressing {zstd_path} with {num_threads} threads")
+        cmd = ["zstd", "-d"]
+        if num_threads:
+            cmd.extend(["-T", str(num_threads)])
+
+        process = subprocess.Popen(cmd + ["-c", zstd_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=-1)
+
+        decompressed_data = process.stdout.read()
+        process.stdout.close()
+
+        retcode = process.wait()
+        if retcode != 0:
+            raise RuntimeError(f"Decompression failed: {process.stderr.read().decode()}")
+        print_per_rank(
+            f"Decompressed {zstd_path} with {num_threads} threads, duration: {(datetime.now() - start_time).total_seconds()}s"
+        )
+
+        buffer = io.BytesIO(decompressed_data)
+        start_time = datetime.now()
+        print_per_rank(f"Loading {shard_path} from zstd file, start time: {start_time}")
+        weights = load_from_bytes(buffer.getvalue())
+        print_per_rank(f"Loaded {shard_path} from zstd file, duration: {(datetime.now() - start_time).total_seconds()}s")
+        buffer.close()
+    else:
+        weights = load_file(shard_path)
+
+    return {name: weights[name] for name in param_names}
+
+
+def load_sharded_safetensors_parallel_with_progress(checkpoint_dir):
+    index_path = os.path.join(checkpoint_dir, "model.safetensors.index.json")
+    if not os.path.exists(index_path):
+        model_file_path = os.path.join(checkpoint_dir, "model.safetensors")
+        state_dict = load_file(model_file_path)
+        return state_dict
+
+    with open(index_path, "r") as f:
+        index = json.load(f)
+
+    state_dict = {}
+    shard_map = {}
+
+    # Group parameters by shard file
+    for param_name, shard_file in index["weight_map"].items():
+        shard_path = os.path.join(checkpoint_dir, shard_file)
+        if shard_path not in shard_map:
+            shard_map[shard_path] = []
+        shard_map[shard_path].append(param_name)
+
+    # Load shards in parallel with a progress bar
+    with ThreadPoolExecutor() as executor:
+        futures = {
+            executor.submit(_load_shard, shard_path, param_names): shard_path for shard_path, param_names in shard_map.items()
+        }
+        pbar = tqdm(futures, desc="Loading shards", total=len(futures))
+        for future in pbar:
+            result = future.result()
+            state_dict.update(result)
+
+    return state_dict
+
+
+def unwrap_model(model):
+    return_list = True
+    if not isinstance(model, list):
+        model = [model]
+        return_list = False
+    unwrapped_model = []
+    for model_module in model:
+        while hasattr(model_module, "module"):
+            model_module = model_module.module
+        unwrapped_model.append(model_module)
+    if not return_list:
+        return unwrapped_model[0]
+    return unwrapped_model
+
+
+def _split_state_dict_for_pp(weight_dict: OrderedDict, model_config: ModelConfig):
+    num_layers = model_config.num_layers
+    partition = mpu.get_pp_world_size()
+
+    ## use partition and num_layers to get current rank layer order
+    layers_for_each_stage = np.array_split(range(num_layers), partition)
+    current_stage = mpu.get_pp_rank()
+    allow_layer_num = layers_for_each_stage[current_stage]
+    layer_offset = allow_layer_num[0]
+    new_weight_dict = {}
+    for k, v in weight_dict.items():
+        if "videodit_blocks.layers" in k:
+            layer_num = int(re.search(r"videodit_blocks\.layers\.(\d+)", k).group(1))
+            if layer_num not in allow_layer_num:
+                continue
+            ## replace the old key name by new layer number
+            new_layer_num = layer_num - layer_offset
+            new_k = k.replace(f"videodit_blocks.layers.{layer_num}", f"videodit_blocks.layers.{new_layer_num}")
+            new_weight_dict[new_k] = v
+        else:
+            new_weight_dict[k] = v
+    return new_weight_dict
+
+
+def load_state_dict(runtime_config: RuntimeConfig, engine_config: EngineConfig):
+    load_dir = runtime_config.load
+
+    default_subdir = "inference_weight"
+    if engine_config.fp8_quant:
+        default_subdir = f"{default_subdir}.fp8"
+    if engine_config.distill:
+        default_subdir = f"{default_subdir}.distill"
+    inference_weight_dir = os.path.join(load_dir, default_subdir)
+
+    print_rank_0(f"load {default_subdir} weight from {inference_weight_dir}")
+    assert (
+        os.path.exists(inference_weight_dir) and len(os.listdir(inference_weight_dir)) > 0
+    ), f"Ckpt directory {inference_weight_dir} does not exist or empty. If you are using fp8_quant, please run calibration first."
+    state_dict = load_sharded_safetensors_parallel_with_progress(inference_weight_dir)
+    return state_dict
+
+
+def load_checkpoint(model):
+    state_dict = load_state_dict(model.runtime_config, model.engine_config)
+
+    model = unwrap_model(model)
+    # if we use pipeline parallelism, we need to load the state dict for each stage
+    # as it always record layer from 0 -> num_layers//pipeline_parallel_size
+    # so we need to choose correct layer weight when load_state_dict
+    if mpu.get_pp_world_size() > 1:
+        state_dict = _split_state_dict_for_pp(state_dict, model.model_config)
+
+    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False, assign=True)
+    model.cuda(torch.cuda.current_device())   # bottleneck for loading
+
+    if mpu.get_pp_world_size() > 1:
+        rank_msg = f"CP_rank={mpu.get_cp_rank()} PP_rank={mpu.get_pp_rank()}"
+        print_per_rank(
+            f"""[{rank_msg}] Load Weight Missing Keys: {missing_keys} Load Weight Unexpected Keys: {unexpected_keys} You should see message [missing fianl layer norm weight] except the final pipeline stage"""
+        )
+    else:
+        print_rank_0(f"Load Weight Missing Keys: {missing_keys}")
+        print_rank_0(f"Load Weight Unexpected Keys: {unexpected_keys}")
+
+    return model

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/infra/distributed/__init__.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .dist_utils import dist_init, get_device, get_world_size, is_last_rank, is_last_tp_cp_rank
+from .parallel_state import (
+    destroy_model_parallel,
+    get_cp_group,
+    get_cp_rank,
+    get_cp_world_size,
+    get_dp_group,
+    get_dp_group_gloo,
+    get_dp_rank,
+    get_dp_world_size,
+    get_pipeline_model_parallel_first_rank,
+    get_pipeline_model_parallel_last_rank,
+    get_pipeline_model_parallel_next_rank,
+    get_pipeline_model_parallel_prev_rank,
+    get_pp_group,
+    get_pp_rank,
+    get_pp_world_size,
+    get_tensor_model_parallel_last_rank,
+    get_tensor_model_parallel_ranks,
+    get_tensor_model_parallel_src_rank,
+    get_tp_group,
+    get_tp_rank,
+    get_tp_world_size,
+    is_initialized,
+    is_pipeline_first_stage,
+    is_pipeline_last_stage,
+)
+
+__all__ = [
+    "dist_init",
+    "is_initialized",
+    "get_tp_group",
+    "get_pp_group",
+    "get_dp_group",
+    "get_dp_group_gloo",
+    "get_cp_group",
+    "get_tp_world_size",
+    "get_pp_world_size",
+    "get_dp_world_size",
+    "get_cp_world_size",
+    "get_tp_rank",
+    "get_pp_rank",
+    "get_dp_rank",
+    "get_cp_rank",
+    "is_pipeline_first_stage",
+    "is_pipeline_last_stage",
+    "get_tensor_model_parallel_src_rank",
+    "get_tensor_model_parallel_ranks",
+    "get_tensor_model_parallel_last_rank",
+    "get_pipeline_model_parallel_first_rank",
+    "get_pipeline_model_parallel_last_rank",
+    "get_pipeline_model_parallel_next_rank",
+    "get_pipeline_model_parallel_prev_rank",
+    "destroy_model_parallel",
+    "is_last_rank",
+    "is_last_tp_cp_rank",
+    "get_world_size",
+    "get_device",
+]

FlowCache/FlowCache4MAGI-1-dev6-adaptive/inference/infra/distributed/dist_utils.py

@@ -0,0 +1,92 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from datetime import timedelta
+
+import torch
+
+import inference.infra.distributed.parallel_state as mpu
+from inference.common import print_rank_0
+from inference.infra.parallelism.pipeline_parallel import init_pp_scheduler
+
+from . import parallel_state as mpu
+
+
+def dist_init(config):
+    """Initialize torch.distributed and core model parallel."""
+
+    assert torch.cuda.is_available()
+    device_count = torch.cuda.device_count()
+    if torch.distributed.is_initialized():
+        print_rank_0("Torch distribution already initialized, skipping initialization ...")
+    else:
+        rank = int(os.getenv("RANK", "0"))
+        world_size = int(os.getenv("WORLD_SIZE", "1"))
+        # Manually set the device ids.
+        if device_count > 0:
+            device = rank % device_count
+            torch.cuda.set_device(device)
+        # Call the init process
+        torch.distributed.init_process_group(
+            backend=config.engine_config.distributed_backend,
+            world_size=world_size,
+            rank=rank,
+            timeout=timedelta(minutes=config.engine_config.distributed_timeout_minutes),
+        )
+    assert config.engine_config.cp_size * config.engine_config.pp_size == torch.distributed.get_world_size()
+    if device_count > 0:
+        if mpu.model_parallel_is_initialized():
+            print_rank_0("Model parallel is already initialized")
+        else:
+            mpu.initialize_model_parallel(
+                cp_size=config.engine_config.cp_size,
+                pp_size=config.engine_config.pp_size,
+                nccl_communicator_config_path=None,
+                distributed_timeout_minutes=config.engine_config.distributed_timeout_minutes,
+                order="tp-cp-pp-dp",
+            )
+    if mpu.get_pp_world_size() > 1:
+        init_pp_scheduler()
+    print_rank_0("Initialize torch distribution and model parallel successfully")
+
+
+def is_last_rank():
+    return torch.distributed.get_rank() == (torch.distributed.get_world_size() - 1)
+
+
+def is_last_tp_cp_rank():
+    return mpu.get_tp_rank(with_context_parallel=True) == mpu.get_tp_world_size(with_context_parallel=True) - 1
+
+
+def get_world_size():
+    if torch.distributed.is_available() and torch.distributed.is_initialized():
+        world_size = torch.distributed.get_world_size()
+    else:
+        world_size = 1
+    return world_size
+
+
+def get_device(local_rank=None):
+    backend = torch.distributed.get_backend()
+    if backend == "nccl":
+        if local_rank is None:
+            device = torch.device("cuda")
+        else:
+            device = torch.device(f"cuda:{local_rank}")
+    elif backend == "gloo":
+        device = torch.device("cpu")
+    else:
+        raise RuntimeError
+    return device