Qwen Image 2.1 + MiniMax H3: स्थानीय पहले और अंतिम फ़्रेम वीडियो पाइपलाइन

आप Qwen से अच्छे पहले और अंतिम फ़्रेम बना सकते हैं, लेकिन असली अड़चन यह है कि H3 उन्हें एक ही लगातार शॉट में जोड़ पाता है या नहीं—बिना विषय बदलने, अनचाहा कट डालने या API-निर्भर 2K रास्ते को “स्थानीय” कहने के। यह गाइड एक स्पष्ट शुरुआती रास्ता देती है: पहले पूरी तरह स्थानीय 768p श्रृंखला चलाएँ, फिर केवल वास्तविक 2K आवश्यकता पर मिश्रित 2K अपनाएँ और समान इनपुट पर स्थानीय तथा होस्टेड H3 की तुलना करें।

सीधा निर्णय: अधिकांश काम के लिए पहले स्थानीय 768p चलाएँ

यदि आपका लक्ष्य handoff जाँचना, assets को अपनी मशीन पर रखना या अनचाहे cuts ढूँढना है, तो पूरी तरह स्थानीय 768p से शुरू करें। मिश्रित 2K तभी चुनें जब अंतिम डिलीवरी में 2K अनिवार्य हो और H3-Context-IR तथा H3-Regenerate-2K के remote API calls स्वीकार्य हों।

आपका लक्ष्य	पहले क्या चुनें	क्यों	सलाह कब बदलेगी
पूरी श्रृंखला चलती है या नहीं साबित करना	पूरी तरह स्थानीय 768p	कम variables होने से Qwen और H3 की समस्याएँ अलग करना आसान है	768p स्थिर हो और डिलीवरी को सचमुच 2K चाहिए
assets मशीन से बाहर न जाएँ	पूरी तरह स्थानीय 768p	Qwen फ़्रेम और H3-Base दोनों स्थानीय रह सकते हैं	यदि 2K अनिवार्य है लेकिन remote API वर्जित है, तो दस्तावेज़ित पूर्ण 2K मार्ग शर्त पूरी नहीं करता; दूसरा स्थानीय 2K समाधान चाहिए
अंतिम वीडियो 2K देना	मिश्रित 2K	आधिकारिक पूर्ण 2K मार्ग दो hosted modules पर निर्भर है	assets दूर भेजना संभव न हो तो 768p या दूसरा समाधान चुनें
स्थानीय और hosted H3 में चुनाव करना	पहले स्थानीय 768p चलाएँ, फिर paired test करें	वरना deployment error और model quality मिल जाएँगे	कई shot types पर repeated tests के बाद दीर्घकालीन विकल्प तय करें

केवल GPU नाम देखकर compatibility का वादा न करें। MiniMax का SGLang उदाहरण चार GPUs उपयोग करता है और सार्वजनिक रन DGX Spark पर था; दोनों में minimum VRAM नहीं दी गई और सामान्य consumer GPU की गारंटी नहीं है।

कौन-से हिस्से वास्तव में आपकी मशीन पर रह सकते हैं?

Qwen फ़्रेम generation और H3-Base 768p स्थानीय रह सकते हैं; आधिकारिक end-to-end 2K मार्ग पूरी तरह स्थानीय नहीं है।

चरण	स्थानीय रूप से संभव?	दस्तावेज़ित सीमा
Qwen Image 2.1 से पहला/अंतिम फ़्रेम बनाना और संपादित करना	हाँ	आधिकारिक रिपॉज़िटरी में QwenImage21Pipeline, स्थानीय Diffusers उदाहरण, मूल 2K आकार और अधिकतम 10 संदर्भ चित्रों का समर्थन है
MiniMax H3-Base से पहले/अंतिम फ़्रेम को ऑडियो-वीडियो में बदलना	हाँ	खुला FL2VA चेकपॉइंट शून्य, एक या दो चित्र स्वीकार करता है; दो चित्र पहले-अंतिम फ़्रेम मोड सक्रिय करते हैं और स्थानीय सत्यापन 768p पर है
H3-Context-IR	पूर्ण आधिकारिक स्थानीय रूप में नहीं	MiniMax इसे होस्टेड प्री-प्रोसेसिंग और ऑर्केस्ट्रेशन सिस्टम बताता है, जो ओपन रिलीज़ में शामिल नहीं है; API लें या prompting guide के आधार पर अपना प्री-प्रोसेसर बनाएँ
H3-Regenerate-2K	वर्तमान खुले घटकों से नहीं	यह मॉड्यूल अभी ओपन-सोर्स नहीं है; आधिकारिक पूर्ण 2K वर्कफ़्लो इसे API से बुलाता है
होस्टेड H3 तुलना	नहीं	Web/API रन परिभाषा के अनुसार रिमोट है और केवल जोड़ीदार नियंत्रण के रूप में काम करता है

MiniMax 4–15 सेकंड आउटपुट, 24 FPS, 32 kHz स्टीरियो ऑडियो और डिफ़ॉल्ट 768-पिक्सेल छोटी भुजा भी दस्तावेज़ित करता है; 2K H3-Regenerate-2K से बनता है। ये मॉडल की सीमाएँ हैं, यह वादा नहीं कि हर सेटिंग आपके हार्डवेयर पर चलेगी।

एक सार्वजनिक test व्यवहार्यता दिखाता है, सार्वभौमिक विजेता नहीं

इस उदाहरण को test design की तरह उपयोग करें, “स्थानीय H3 हमेशा बेहतर है” वाले निष्कर्ष की तरह नहीं।

फ़िल्ममेकर Sam Wasserman ने DGX Spark पर Qwen Image 2.1 और MiniMax H3 के साथ स्थानीय “विचार → चित्र → वीडियो” रन पोस्ट किया। जुड़ा परिणाम लगभग आठ सेकंड का है। अगले पोस्ट में उन्होंने बताया कि भुगतान वाले Web H3 में वही prompt, वही specifications और वही पहले/अंतिम फ़्रेम दोबारा उपयोग किए। उनके अनुसार वेब परिणाम ने अनचाहा कट जोड़ा, जबकि स्थानीय परिणाम ने अपेक्षित क्रम बनाए रखा।

यह व्यवहार्यता का उपयोगी प्रमाण और तुलना का अच्छा ढाँचा है। यह यह सिद्ध नहीं करता कि स्थानीय H3 सामान्यतः बेहतर है। पोस्ट इंस्टॉलेशन कमांड, पीक मेमोरी, जनरेशन समय, ऑडियो उपचार, seed या विफल प्रयास नहीं बताते। तुलना भी उसी लेखक की एक इनपुट पर राय है, स्वतंत्र पुनरावृत्ति नहीं।

चरण 1: विचार को एक लगातार शॉट तक सीमित करें

एक स्थान, एक action chain और एक अंतिम अवस्था माँगें। इन शर्तों को shot contract—यानी परिणाम जाँचने योग्य छोटी specification—के रूप में लिखें।

फ़ील्ड	क्या तय करें
विषय और दृश्य	व्यक्ति, वस्तु, कपड़े, पृष्ठभूमि और पहचान के वे गुण जो स्थिर रहने चाहिए
प्रारंभिक स्थिति	पहले फ़्रेम में स्थान, मुद्रा, नज़र, कैमरा दूरी, रचना और प्रकाश
अंतिम स्थिति	अंत में केवल अनुमत परिवर्तन; विषय, स्थान और कैमरा स्थिति एक साथ न बदलें
गति का मार्ग	विषय कैसे चलेगा, कैमरा चलेगा या नहीं, और क्रियाओं का क्रम
निरंतरता प्रतिबंध	“एक लगातार शॉट”, “कोई कट नहीं”, “कोई teleport नहीं” जैसी स्पष्ट शर्तें
आउटपुट विनिर्देश	अवधि, aspect ratio और संवाद, ambience या संगीत की आवश्यकता
निषेध	अवांछित पात्र, subtitles, scene change, background replacement या अतिरिक्त क्रियाएँ

यदि परीक्षण अनचाहे कट पकड़ने के लिए है, तो एक ही prompt में कई स्थान, समय-अवधि या montage न माँगें। अन्यथा कट निर्देश की उचित व्याख्या हो सकता है, मॉडल की गलती नहीं।

उदाहरण के लिए, “दरवाज़े से मेज़ तक जाए, कप उठाए, कोई cut नहीं” उपयोगी first/last-frame test है। “सड़क से दफ़्तर जाए और फिर बचपन का flashback दिखाए” स्वाभाविक रूप से कई scenes माँगता है, इसलिए unwanted cuts को साफ़ तरीके से नहीं जाँच सकता।

चरण 2: पहले पहला फ़्रेम बनाएँ, फिर उसी से अंतिम फ़्रेम edit करें

दो अलग prompts से दो असंबंधित चित्र बनाने के बजाय पहले फ़्रेम को edit करके अंतिम फ़्रेम बनाएँ। इससे H3 शुरू होने से पहले ही identity, कपड़े, composition और background को स्थिर रखना आसान होता है।

आधिकारिक model ID Qwen/Qwen-Image-2.1 है। Qwen 7B visual generation component, स्थानीय Diffusers, generation/editing, native 2K और अधिकतम 10 reference images दस्तावेज़ित करता है।

pip install "torch>=2.4.0" "transformers>=5.17" accelerate pillow
pip install git+https://github.com/huggingface/diffusers

from pathlib import Path

import torch
from diffusers import QwenImage21Pipeline

first_prompt = Path("first_prompt.txt").read_text(encoding="utf-8").strip()
last_edit_prompt = Path("last_edit_prompt.txt").read_text(encoding="utf-8").strip()

pipe = QwenImage21Pipeline.from_pretrained(
    "Qwen/Qwen-Image-2.1",
    torch_dtype=torch.bfloat16,
).to("cuda")

first = pipe(
    prompt=first_prompt,
    width=2752,
    height=1536,
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
first.convert("RGB").save("first.png")

last = pipe(
    prompt=last_edit_prompt,
    image=first,
    width=2752,
    height=1536,
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(43),
).images[0]
last.convert("RGB").save("last.png")

यह code आधिकारिक generation और single-image editing interfaces को जोड़ता है; first_prompt और last_edit_prompt आप देते हैं। इसमें दस्तावेज़ित 16:9 2K आकार 2752 × 1536, 40 steps और opaque RGB PNG उपयोग होते हैं। सार्वजनिक H3 विवरण इस handoff में alpha-channel व्यवहार नहीं बताता, इसलिए RGBA को अलग से सत्यापित न किया हो तो opaque frames एक variable कम करते हैं।

कम से कम यह दर्ज करें:

• मॉडल ID, framework version, पहला prompt और अंतिम edit prompt;
• दोनों seeds, width, height, inference steps और reference list;
• दोनों फ़ाइलों का SHA-256, pixel dimensions और color mode;
• पहचान, कपड़े, composition, lighting और background की स्थिरता;
• अंतिम फ़्रेम केवल अंतिम अवस्था दिखाता है या पूरी motion sequence भर देता है।

Qwen सीमित मेमोरी वाले GPU के लिए enable_model_cpu_offload() भी दस्तावेज़ित करता है। यह offload मार्ग का प्रमाण है, न्यूनतम VRAM या गति की गारंटी नहीं।

चरण 3: स्थानीय और hosted H3 को वही inputs दें

दो interfaces में parameters याद से दोबारा न भरें। Images, prompt और output settings को एक manifest में रखें; अलग seed, अवधि या rewritten prompt पूरी तुलना को बेकार कर सकता है।

experiment_id: "qwen-h3-001"
qwen_model: "Qwen/Qwen-Image-2.1"
h3_model: "MiniMaxAI/MiniMax-H3"
h3_variant: "fl2va"
prompt_file: "prompt.txt"
first_frame: "first.png"
last_frame: "last.png"
prompt_sha256: "<sha256>"
first_frame_sha256: "<sha256>"
last_frame_sha256: "<sha256>"
duration_seconds: "<same value>"
aspect_ratio: "<same value>"
local_seed: "<record if exposed>"
hosted_seed: "<record or not_exposed>"

स्थानीय और होस्टेड दोनों रन इसी रिकॉर्ड को पढ़ें। यदि होस्टेड UI seed छिपाए, prompt दोबारा लिखे या अवधि सीमित करे, तो not_exposed लिखें या rewritten prompt सहेजें। जिन parameters की समानता जाँची नहीं जा सकती, उन्हें समान न मानें। दिखाई देने वाले inputs नियंत्रित होने के बाद ही परिणाम-अंतर का अर्थ निकलेगा।

चरण 4: पहले स्थानीय H3-Base 768p परिणाम चलाएँ

2K पर जाने से पहले 768p परिणाम स्वीकार करें। Qwen stills का 2K होना स्थानीय H3-Base वीडियो को 2K नहीं बनाता।

MiniMax दो task-specific checkpoints प्रकाशित करता है। यहाँ MiniMax-H3 Base FL2VA चाहिए, जो text, first frame, last frame या दोनों frames से BF16 audio-video generation समर्थन देता है। आधिकारिक download और SGLang उदाहरण हैं:

hf download MiniMaxAI/MiniMax-H3 \
  --include "FL2VA/*" \
  --local-dir MiniMax-H3

sglang serve \
  --model-path MiniMaxAI/MiniMax-H3 \
  --num-gpus 4 \
  --ulysses-degree 4 \
  --performance-mode speed \
  --host 0.0.0.0 \
  --port 30010 \
  --model-variant fl2va

दूसरा command MiniMax का चार-GPU उदाहरण है। यह Wasserman की प्रकाशित DGX Spark configuration नहीं है और न न्यूनतम आवश्यकता। इसे केवल संबंधित framework documentation के अनुसार बदलें और हर बदलाव रिकॉर्ड करें; इसे हर मशीन के लिए प्रमाण न बनाएँ।

दोनों फ़्रेम SGLang प्रक्रिया को उपलब्ध कराएँ

FL2VA में role: "keyframe" वाली एक या दो image conditions दी जा सकती हैं। आधिकारिक SGLang H3 गाइड में frame_index: 0 पहला फ़्रेम, frame_index: -1 अंतिम फ़्रेम और [0, -1] दोनों सिरों का संयोजन है। MiniMax का reproducible script केवल पहले फ़्रेम का रूप दिखाता है; नीचे उन्हीं fields के साथ दोनों images दी गई हैं।

file:// URI को SGLang server process पढ़ता है, curl चलाने वाला terminal नहीं। server और command एक host पर हों तो realpath से मिले default absolute paths काम करेंगे। SGLang container या दूसरी machine पर हो तो दोनों files को वहाँ mount या copy करें और FIRST_URI तथा LAST_URI में server को दिखने वाले paths दें।

shot contract को prompt.txt में रखें। पूरी तरह स्थानीय 768p के लिए इसमें आपका अपना structured prompt हो सकता है। मिश्रित 2K मार्ग में H3-Context-IR का परिणाम इसी prompt field में दें, फिर H3-Base output को H3-Regenerate-2K पर भेजें।

FL2VA भेजें, पूरा होने तक प्रतीक्षा करें और MP4 सहेजें

यह script दस्तावेज़ित asynchronous lifecycle अपनाती है: POST /v1/videos से task बनाकर .id पढ़ती है, GET /v1/videos/{id} को poll करती है और status के completed होने पर ही GET /v1/videos/{id}/content से file लेती है। आधिकारिक cookbook में failed terminal failure है; अन्य सभी non-empty statuses पर प्रतीक्षा जारी रहती है।

set -euo pipefail

BASE_URL="${BASE_URL:-http://127.0.0.1:30010}"
FIRST_URI="${FIRST_URI:-file://$(realpath first.png)}"
LAST_URI="${LAST_URI:-file://$(realpath last.png)}"
PROMPT_FILE="${PROMPT_FILE:-prompt.txt}"
OUTPUT_FILE="${OUTPUT_FILE:-fl2va.mp4}"

payload=$(
  jq -n \
    --rawfile prompt "$PROMPT_FILE" \
    --arg first "$FIRST_URI" \
    --arg last "$LAST_URI" \
    '{
      model: "MiniMaxAI/MiniMax-H3",
      task: "fl2va",
      prompt: $prompt,
      seconds: 8,
      conditions: [
        {
          type: "image",
          uri: $first,
          role: "keyframe",
          frame_index: 0
        },
        {
          type: "image",
          uri: $last,
          role: "keyframe",
          frame_index: -1
        }
      ],
      target: {
        short_edge: 768,
        aspect_ratio: "auto",
        duration_seconds: 8
      },
      seed: 0
    }'
)

response=$(
  curl --fail-with-body --silent --show-error \
    --request POST \
    --url "$BASE_URL/v1/videos" \
    --header 'Content-Type: application/json' \
    --data-binary "$payload"
)

video_id=$(printf '%s\n' "$response" | jq -er '.id')
printf 'video_id=%s\n' "$video_id"

while true; do
  task_json=$(
    curl --fail-with-body --silent --show-error \
      --request GET \
      --url "$BASE_URL/v1/videos/$video_id"
  )
  status=$(printf '%s\n' "$task_json" | jq -er '.status')
  printf 'status=%s\n' "$status"

  case "$status" in
    completed)
      break
      ;;
    failed)
      printf '%s\n' "$task_json" | jq .
      exit 1
      ;;
    *)
      sleep 1
      ;;
  esac
done

curl --fail-with-body --silent --show-error --location \
  --request GET \
  --url "$BASE_URL/v1/videos/$video_id/content" \
  --output "$OUTPUT_FILE"

test -s "$OUTPUT_FILE"

if command -v ffprobe >/dev/null 2>&1; then
  ffprobe -v error \
    -show_entries stream=codec_type,codec_name,r_frame_rate,sample_rate,channels \
    -of default=noprint_wrappers=1 \
    "$OUTPUT_FILE"
fi

printf 'saved=%s\n' "$OUTPUT_FILE"

curl --fail-with-body किसी non-2xx response पर तुरंत रुकती है और .id या .status न मिलने पर jq -e विफल हो जाता है। failed आने पर script पूरा task JSON दिखाकर nonzero code से निकलती है; success के लिए content download सफल और MP4 non-empty होना भी जरूरी है।

ffprobe उपलब्ध हो तो script media streams भी दिखाती है। SGLang का दस्तावेज़ित output contract H.264 video वाला 24 FPS MP4 और 32 kHz AAC stereo stream है। task completed बताए लेकिन file खाली हो, decode न हो या media properties अलग हों तो hosted comparison न चलाएँ; पहले SGLang logs, server-visible image URIs और request JSON जाँचें।

fields और endpoints MiniMax के आधिकारिक reproducible FL2VA script, SGLang MiniMax-H3 cookbook और SGLang video API guide से लिए गए हैं। पूरी तरह स्थानीय मार्ग यहाँ H3-Base 768p MP4 पर समाप्त होता है; पूर्ण 2K के लिए पहले बताया मिश्रित मार्ग ही उपयोग होगा।

चरण 5: स्थानीय श्रृंखला स्थिर होने के बाद ही hosted तुलना चलाएँ

जब स्थानीय श्रृंखला अभी असफल हो रही हो, तब quality compare न करें। वरना deployment error, input difference और model behavior अलग नहीं किए जा सकेंगे। केवल execution location बदलें:

1. दोनों फ़्रेम के बिल्कुल समान bytes अपलोड करके hashes जाँचें।
2. वही prompt, अवधि, aspect ratio, भाषा और audio intent उपयोग करें।
3. दर्ज करें कि Web/API prompt rewrite करता है, seed दिखाता है या H3-Context-IR उपयोग करता है।
4. मूल outputs सुरक्षित रखें; तुलना से पहले edit, re-encode या संगीत न जोड़ें।
5. स्रोत labels छिपाकर blind review करें, ताकि “स्थानीय बेहतर होगा” या “paid बेहतर होगा” की अपेक्षा निर्णय को प्रभावित न करे।

लागत की तुलना के लिए अपना API bill, machine occupancy और power use दर्ज करें। केवल “स्थानीय” और “paid web” labels यह नहीं बताते कि आपके workload में कौन-सा रास्ता सस्ता है।

चरण 6: एक ही scorecard से अपने shots के लिए बेहतर रास्ता चुनें

पहले देखें कि clip creative task पूरा करता है या नहीं, फिर runtime और hardware की तुलना करें। अधिक resolution वाला परिणाम भी खराब विकल्प हो सकता है यदि वह बार-बार अनचाहे cuts जोड़ता है।

मापदंड	कैसे देखें	क्या दर्ज करें
पहले फ़्रेम की निष्ठा	शुरुआत विषय, composition और प्रमुख objects बचाती है या तुरंत बदल देती है?	विचलन और timestamp
अंतिम फ़्रेम तक पहुँचना	clip स्वाभाविक रूप से अंतिम अवस्था तक जाता है या अचानक अंतिम image पर कूदता है?	अंतिम अवस्था और transition quality
एकल-शॉट निरंतरता	अनचाहे cuts, teleport, scene replacement या time jumps हैं?	cut timestamps और पहले/बाद की captures
पहचान और background स्थिरता	चेहरा, कपड़े, हाथ, props और background geometry स्थिर हैं?	प्रभावित object और अवधि
गति का मार्ग	विषय और camera तय क्रम व दिशा में चलते हैं?	दिशा त्रुटि, speed jump या stall
ऑडियो	माँगे जाने पर track मौजूद, synchronized और pops/असंबंधित content से मुक्त है?	media properties, sync offset और abnormal segment
आउटपुट specification	अवधि, aspect ratio, FPS और resolution settings से मेल खाते हैं?	वास्तविक metadata
रनटाइम resources	wall-clock समय, peak accelerator memory, system memory और retries	हर रन के raw logs, अनुमान नहीं
पुनरावृत्ति	नियंत्रित input दोहराने पर वही समस्या फिर आती है?	repeated results और दिखाई देने वाले random parameters

MiniMax कहता है कि H3 32 kHz stereo audio बना सकता है। Wasserman की पोस्ट यह नहीं बताती कि audio चालू था, रखा गया या post-process किया गया। अपना output जाँच सकते हैं, पर उस उदाहरण को audio-quality validation नहीं कह सकते।

सब कुछ दोबारा चलाने के बजाय सही upstream layer ठीक करें

गलत पहला फ़्रेम Qwen में ठीक करें, continuity समस्या H3 में, और resolution mismatch पर पहले देखें कि आपने स्थानीय 768p चुना था या मिश्रित 2K। Layered diagnosis एक साथ सभी parameters बदलने से तेज़ है।

लक्षण	पहले क्या जाँचें	कार्रवाई
पहला फ़्रेम ही गलत है	Qwen image stage	prompt, references और seed सुधारें; खराब composition को H3 में न सुधारें
अंतिम फ़्रेम में पहचान या background बदलता है	Qwen handoff asset	स्वतंत्र generation के बजाय पहले फ़्रेम से edit करें, बदलाव घटाएँ और स्थिर references फिर उपयोग करें
अनचाहा cut आता है	H3 prompt और motion constraints	एक continuous shot स्पष्ट करें, montage/multi-scene भाषा हटाएँ और उन्हीं hashes के साथ दोहराएँ
वीडियो अंतिम स्थिति तक नहीं पहुँचता	अवधि या motion plan	action chain छोटी करें और start–process–finish क्रम स्पष्ट करें
audio गायब या mismatch है	H3 variant, client और container	audio-video checkpoint तथा request path जाँचें; तुलनीय audio न हो तो रन को incomparable लिखें
Qwen memory से बाहर हो जाता है	image deployment	दस्तावेज़ित CPU offload आजमाएँ और speed impact मापें; universal minimum VRAM न मानें
H3 वर्तमान hardware पर शुरू नहीं होता	H3 deployment	framework guide देखें; आधिकारिक sample चार GPU का है और consumer hardware की गारंटी नहीं है
स्थानीय 768p पर रुकता है, 2K को API चाहिए	workflow boundary	यह दस्तावेज़ित architecture है, failure नहीं; 768p स्वीकारें या hybrid 2K चुनें
स्थानीय और होस्टेड परिणाम बहुत अलग हैं	input और preprocessing	prompt rewriting, Context-IR, seed, अवधि, ratio और re-encoding जाँचें, फिर मॉडल अंतर मानें

लंबे समय के लिए स्थानीय या hosted H3 कैसे चुनें

निर्णय अपने पूरे shot set पर लें, केवल सबसे अच्छे sample पर नहीं। Static camera, human action, object transformation, dialogue और ambience को शामिल करें और successes तथा failures दोनों रखें; इन measurements को अलग लिखें:

• clip duration, जैसे सार्वजनिक उदाहरण के लगभग आठ सेकंड;
• generation time, submission से completed file तक wall-clock समय, जो उदाहरण में नहीं बताया गया;
• model specifications, vendor documentation से;
• actual hardware use, अपने सिस्टम पर मापा गया, device name से अनुमानित नहीं;
• एक visual judgment, जो उस रन को बताता है लेकिन overall win rate नहीं बनता।

यदि assets मशीन से बाहर नहीं जा सकते, तो स्थानीय 768p को default रखें। यदि final delivery 2K होनी चाहिए और remote APIs स्वीकार्य हैं, तो मिश्रित 2K चुनें। यदि continuity सबसे महत्वपूर्ण है, तो समान shot set पर local और hosted H3 का blind review करें और जो route आपकी rubric अधिक स्थिरता से pass करे उसे प्राथमिकता दें। सार्वजनिक उदाहरण केवल यह दिखाता है कि local route चल सकता है और एक same-input test में उसने एक unwanted cut टाला; वह आपके repeated tests का विकल्प नहीं है।

चलाने से पहले ये आठ बातें जाँचें

• रन को “पूरी तरह स्थानीय 768p” या “मिश्रित 2K” नाम दिया गया है, दोनों शब्द नहीं मिलाए गए।
• दोनों फ़्रेम के लिए Qwen model, prompts, seeds, dimensions और references दर्ज हैं।
• images और prompt hashed हैं, और दोनों H3 runs वही inputs उपयोग करते हैं।
• स्थानीय रन fl2va उपयोग करता है और पहले H3-Base 768p परिणाम के रूप में स्वीकार होता है।
• होस्टेड prompt rewrite और hidden parameters ईमानदारी से लिखे गए हैं।
• मूल videos unedited हैं और continuity, cuts, audio व specifications की वही rubric उपयोग होती है।
• समय, peak memory, retries और failures logs से आते हैं।
• निष्कर्ष tested samples, hardware और verification date तक सीमित हैं।

निष्कर्ष

Default सलाह स्पष्ट है: Qwen Image 2.1 से पहले और अंतिम फ़्रेम स्थानीय रूप से बनाएँ, फिर MiniMax H3-Base fl2va से स्थानीय 768p चलाएँ। H3-Context-IR → स्थानीय H3-Base → H3-Regenerate-2K पर तभी जाएँ जब 2K अनिवार्य हो और remote APIs स्वीकार्य हों।

किसी भी route में frames, prompt, अवधि और aspect ratio freeze करें, फिर समान inputs पर continuity, unwanted cuts, audio, wall time और hardware use की तुलना करें। इससे अच्छा दिखने वाला demo एक audit करने योग्य workflow बनता है, जिसे आप सोच-समझकर अपना सकते हैं।

संदर्भ लिंक

• Qwen Image 2.1 आधिकारिक रिपॉज़िटरी
• MiniMax H3 आधिकारिक open-source घोषणा
• MiniMax H3 का आधिकारिक reproducible FL2VA request
• SGLang MiniMax-H3 आधिकारिक cookbook
• SGLang Diffusion video API guide
• Sam Wasserman का स्थानीय end-to-end रन
• उसी लेखक की समान inputs वाली Web H3 तुलना

तथ्य जाँच तिथि: 26 सितंबर 2026।