Upload Mongle RunPod test package

.gitattributes

@@ -1,35 +1,7 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,12 @@
+.env
+__pycache__/
+*.pyc
+.DS_Store
+outputs/
+data/
+image/
+grid/
+*.log
+train_log.txt
+extract_log.txt
+extract_err.txt

README.md

@@ -0,0 +1,33 @@
+# Mongle HF Test Package
+
+This folder is a clean test package for uploading to a Hugging Face repository and cloning on RunPod.
+
+## Included
+
+- `test_text2feed_pipeline.py`
+- `test_image2feed_pipeline.py`
+- `test_qwen25_vl_extract.py`
+- `src/pipeline/persona2prompt.py`
+- `src/feed/feed_generator_1.py`
+- `src/feed/feed_generator_2.py`
+- `models/lora_v3_32bit/pytorch_lora_weights.safetensors`
+- `models/lora_bg_v1/pytorch_lora_weights.safetensors`
+- `requirements.txt`
+
+## Not Included
+
+- `.env`
+- local outputs
+- training datasets
+- logs
+- caches
+
+## RunPod Quick Test
+
+```bash
+pip install -r requirements.txt
+python test_text2feed_pipeline.py --name runpod_text_test --force
+python test_image2feed_pipeline.py --name runpod_image_test --character-image image/01.jpg --force
+```
+
+For `test_image2feed_pipeline.py`, upload a test image to `image/01.jpg` or pass another image path with `--character-image`.

models/lora_bg_v1/pytorch_lora_weights.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b11ce0f1e8ebce873e6889598e2a6be5eb63d852ba468dbad921f22d4d4c9400
+size 185963768

models/lora_v3_32bit/pytorch_lora_weights.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f935fa5276540033ab51f677a659c41624f26b093c21d91f1bea93fce408c60f
+size 185963768

requirements.txt

@@ -0,0 +1,23 @@
+--extra-index-url https://download.pytorch.org/whl/cu121
+
+torch==2.5.1
+torchvision==0.20.1
+
+diffusers==0.31.0
+transformers==4.46.3
+accelerate==1.1.1
+peft==0.13.2
+huggingface_hub==0.26.5
+safetensors
+sentencepiece
+protobuf
+qwen-vl-utils
+bitsandbytes
+
+rembg
+onnxruntime-gpu
+opencv-python-headless
+Pillow
+matplotlib
+numpy
+runpod

src/feed/feed_generator_1.py

@@ -0,0 +1,125 @@
+"""
+몽글마을 피드 이미지 생성기
+입력: 캐릭터 외형(Florence-2 추출) + 퀘스트(영어)
+출력: 피드 이미지 (캐릭터가 퀘스트를 수행하는 장면)
+"""
+import os as _os; _os.chdir(_os.path.dirname(_os.path.dirname(_os.path.dirname(_os.path.abspath(__file__)))))
+import os, gc
+from pathlib import Path
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+
+from diffusers import StableDiffusionXLPipeline, DPMSolverMultistepScheduler
+import torch
+
+CHARACTER_LORA = "models/lora_v3_32bit/pytorch_lora_weights.safetensors"
+BG_LORA        = "models/lora_bg_v1/pytorch_lora_weights.safetensors"
+
+NEGATIVE = (
+    "realistic, 3d render, photograph, blurry, dark, gloomy, "
+    "watercolor, sketch, painterly, smooth illustration, "
+    "modern city, urban, scary, violence, text, watermark, "
+    "multiple characters, tiling, repeated"
+)
+
+
+def _to_appearance_str(appearance) -> str:
+    """dict 또는 string → 외형 텍스트 변환"""
+    if isinstance(appearance, str):
+        return appearance.strip()
+    if not isinstance(appearance, dict):
+        return str(appearance).strip()
+
+    animal   = appearance.get("animal_type", "bear")
+    color    = appearance.get("body_color", "")
+    shape    = appearance.get("body_shape", "")
+    eye      = appearance.get("eye_style", "")
+    nose     = appearance.get("nose_mouth") or appearance.get("nose_shape", "")
+    cheeks   = appearance.get("cheeks", "")
+    ears     = appearance.get("ear_shape", "")
+    texture  = appearance.get("texture", "")
+    acc      = appearance.get("accessories", "")
+    features = appearance.get("distinctive_features", [])
+    secondary = appearance.get("secondary_colors", [])
+
+    parts = [f"a {color} pixel art stuffed {animal} character".strip()]
+    if shape:    parts.append(shape)
+    if isinstance(secondary, list):
+        # 3단어 이하인 짧은 색상 값만 포함 (문장형 묘사 제외)
+        parts.extend(s for s in secondary[:2] if s and len(str(s).split()) <= 3)
+    if eye:      parts.append(eye)
+    if cheeks and "no" not in cheeks.lower(): parts.append(cheeks)
+    if ears:     parts.append(ears)
+    if nose:     parts.append(nose)
+    if texture:  parts.append(texture)
+    if isinstance(acc, list):
+        acc = ", ".join(str(a) for a in acc if a)
+    if acc and str(acc).lower() != "none": parts.append(acc)
+    # distinctive_features는 eye_style, cheeks 등과 중복되므로 제외
+
+    return ", ".join(p for p in parts if p)
+
+
+def build_prompt(appearance, quest_en: str):
+    """
+    prompt   → 장면/스타일 (CLIP-L)
+    prompt_2 → 장면 + 캐릭터 외형 (OpenCLIP-bigG, 더 강한 인코더에 둘 다 전달)
+    """
+    appearance_str = _to_appearance_str(appearance)
+    prompt = (
+        f"monglestyle, {quest_en}, "
+        f"cute chibi stuffed animal character in action, "
+        f"full body pose, 32-bit pixel art scene, pastel colors"
+    )
+    prompt_2 = f"monglestyle, {appearance_str}"
+    return prompt, prompt_2
+
+
+def load_pipeline():
+    print("SDXL 로드 중 (캐릭터 LoRA + 배경 LoRA)...")
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        torch_dtype=torch.float16,
+        use_safetensors=True,
+    ).to("cuda")
+
+    if not Path(CHARACTER_LORA).exists():
+        raise FileNotFoundError(f"Character LoRA not found: {CHARACTER_LORA}")
+    if not Path(BG_LORA).exists():
+        raise FileNotFoundError(f"Background LoRA not found: {BG_LORA}")
+
+    pipe.load_lora_weights(CHARACTER_LORA, adapter_name="character")
+    pipe.load_lora_weights(BG_LORA,        adapter_name="bg")
+    pipe.set_adapters(
+        ["character", "bg"],
+        adapter_weights=[0.8, 0.8],
+    )
+    pipe.scheduler = DPMSolverMultistepScheduler.from_config(
+        pipe.scheduler.config, use_karras_sigmas=True
+    )
+    pipe.enable_attention_slicing()
+    print("로드 완료!\n")
+    return pipe
+
+
+def generate(appearance, quest_en: str, pipe, seed: int = 42):
+    prompt, prompt_2 = build_prompt(appearance, quest_en)
+    print(f"  prompt  : {prompt}")
+    print(f"  prompt_2: {prompt_2}")
+
+    return pipe(
+        prompt=prompt,
+        prompt_2=prompt_2,
+        negative_prompt=NEGATIVE,
+        num_inference_steps=20,
+        guidance_scale=7.5,
+        height=1024,
+        width=1024,
+        generator=torch.Generator("cuda").manual_seed(seed),
+    ).images[0]
+
+
+def unload_pipeline(pipe):
+    del pipe
+    gc.collect()
+    torch.cuda.empty_cache()
+    print("파이프라인 VRAM 해제 완료")

src/feed/feed_generator_2.py

@@ -0,0 +1,147 @@
+"""
+몽글마을 피드 이미지 생성기 v2 (이미지 입력 파이프라인 전용)
+
+feed_generator_1.py와의 차이점:
+- 캐릭터 외형을 프롬프트 앞쪽에 배치 (SDXL 토큰 가중치 활용)
+- appearance_str에 limbs 포함 (비전형 캐릭터 신체 반영)
+- NEGATIVE에 human/person 추가
+- char LoRA 0.9 / bg LoRA 1.1 (외형 강제력 상향)
+- guidance_scale 8.5 (프롬프트 추종력 강화)
+- 양쪽 인코더 모두 scene 정보 전달
+"""
+import os as _os; _os.chdir(_os.path.dirname(_os.path.dirname(_os.path.dirname(_os.path.abspath(__file__)))))
+import os, gc
+from pathlib import Path
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+
+from diffusers import StableDiffusionXLPipeline, DPMSolverMultistepScheduler
+import torch
+
+CHARACTER_LORA = "models/lora_v3_32bit/pytorch_lora_weights.safetensors"
+BG_LORA        = "models/lora_bg_v1/pytorch_lora_weights.safetensors"
+
+NEGATIVE = (
+    "realistic, 3d render, photograph, blurry, dark, gloomy, "
+    "watercolor, sketch, painterly, smooth illustration, "
+    "modern city, urban, scary, violence, text, watermark, "
+    "multiple characters, tiling, repeated, "
+    "human, person, girl, boy, man, woman, humanoid, human body, human face, "
+    "skin, hair, clothes, dress, shirt"
+)
+
+
+def _to_appearance_str(appearance) -> str:
+    if isinstance(appearance, str):
+        return appearance.strip()
+    if not isinstance(appearance, dict):
+        return str(appearance).strip()
+
+    animal    = appearance.get("animal_type", "bear")
+    color     = appearance.get("body_color", "")
+    shape     = appearance.get("body_shape", "")
+    eye       = appearance.get("eye_style", "")
+    nose      = appearance.get("nose_mouth") or appearance.get("nose_shape", "")
+    cheeks    = appearance.get("cheeks", "")
+    ears      = appearance.get("ear_shape", "")
+    limbs     = appearance.get("limbs", "")
+    texture   = appearance.get("texture", "")
+    acc       = appearance.get("accessories", "")
+    secondary = appearance.get("secondary_colors", [])
+
+    parts = [f"a {color} pixel art stuffed {animal} character".strip()]
+    if shape: parts.append(shape)
+    if isinstance(secondary, list):
+        parts.extend(s for s in secondary[:2] if s and len(str(s).split()) <= 3)
+    if eye:   parts.append(eye)
+    if cheeks and "no" not in cheeks.lower(): parts.append(cheeks)
+    if ears and "not visible" not in ears.lower(): parts.append(ears)
+    if nose and "not visible" not in nose.lower(): parts.append(nose)
+    if limbs and "not visible" not in limbs.lower(): parts.append(limbs)
+    if texture: parts.append(texture)
+    if isinstance(acc, list):
+        acc = ", ".join(str(a) for a in acc if a)
+    if acc and str(acc).lower() not in ("none", ""): parts.append(acc)
+
+    return ", ".join(p for p in parts if p)
+
+
+def build_prompt(appearance, quest_en: str):
+    """
+    두 인코더 역할 분리:
+    prompt   (CLIP-L)       → 장면/배경 담당: scene 앞에 배치
+    prompt_2 (OpenCLIP-bigG) → 캐릭터 외형 담당: appearance 앞에 배치
+    """
+    appearance_str = _to_appearance_str(appearance)
+
+    animal = "plush mascot"
+    if isinstance(appearance, dict):
+        animal = appearance.get("animal_type", "plush mascot")
+
+    # CLIP-L: 장면 먼저 → 배경 생성 담당
+    # 캐릭터 타입만 간단히 명시해 human 방지
+    prompt = (
+        f"monglestyle, {quest_en}, "
+        f"stuffed {animal} plush toy mascot, "
+        f"cozy pastel sky island village, "
+        f"32-bit pixel art scene, detailed background, outdoor scenery, pastel colors"
+    )
+    # OpenCLIP-bigG: 외형 먼저 → 캐릭터 정체성 담당
+    # 장면 힌트도 뒤에 포함해 배경 보조
+    prompt_2 = (
+        f"monglestyle, stuffed {animal} plush toy mascot, "
+        f"{appearance_str}, "
+        f"full body in action, {quest_en}, "
+        f"pixel art background scene"
+    )
+    return prompt, prompt_2
+
+
+def load_pipeline():
+    print("SDXL 로드 중 (캐릭터 LoRA + 배경 LoRA)...")
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        torch_dtype=torch.float16,
+        use_safetensors=True,
+    ).to("cuda")
+
+    if not Path(CHARACTER_LORA).exists():
+        raise FileNotFoundError(f"Character LoRA not found: {CHARACTER_LORA}")
+    if not Path(BG_LORA).exists():
+        raise FileNotFoundError(f"Background LoRA not found: {BG_LORA}")
+
+    pipe.load_lora_weights(CHARACTER_LORA, adapter_name="character")
+    pipe.load_lora_weights(BG_LORA,        adapter_name="bg")
+    pipe.set_adapters(
+        ["character", "bg"],
+        adapter_weights=[0.9, 1.1],
+    )
+    pipe.scheduler = DPMSolverMultistepScheduler.from_config(
+        pipe.scheduler.config, use_karras_sigmas=True
+    )
+    pipe.enable_attention_slicing()
+    print("로드 완료!\n")
+    return pipe
+
+
+def generate(appearance, quest_en: str, pipe, seed: int = 42):
+    prompt, prompt_2 = build_prompt(appearance, quest_en)
+    print(f"  prompt  : {prompt}")
+    print(f"  prompt_2: {prompt_2}")
+
+    return pipe(
+        prompt=prompt,
+        prompt_2=prompt_2,
+        negative_prompt=NEGATIVE,
+        num_inference_steps=25,
+        guidance_scale=8.5,
+        height=1024,
+        width=1024,
+        generator=torch.Generator("cuda").manual_seed(seed),
+    ).images[0]
+
+
+def unload_pipeline(pipe):
+    del pipe
+    gc.collect()
+    torch.cuda.empty_cache()
+    print("파이프라인 VRAM 해제 완료")

src/pipeline/persona2prompt.py

@@ -0,0 +1,102 @@
+"""
+한국어 페르소나 텍스트 → 영어 시각 프롬프트 변환
+모델: Qwen/Qwen2.5-7B-Instruct
+"""
+import os
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+MODEL_ID = "Qwen/Qwen2.5-7B-Instruct"
+
+SYSTEM_PROMPT = """You are a visual prompt writer for 몽글마을 (Mongle Village), a cozy pixel art character game.
+
+Your job: convert a Korean character description into a short English visual prompt for pixel art image generation.
+
+Rules:
+- Focus only on VISUAL traits: animal type, fur/body color, facial expression, body shape
+- Personality keywords → visual expression (e.g. 용감한=confident bright eyes, 사랑스러운=rosy cheeks warm smile, 조용한=calm soft eyes, 활발한=sparkling cheerful eyes, 수줍은=blushing shy smile)
+- If no animal mentioned → pick a soft round animal (bunny, bear, cat, hamster)
+- If no color mentioned → pick a pastel color (cream, soft pink, light blue, lavender, mint)
+- Output ONLY the English prompt. No explanations, no Korean, nothing else.
+- Keep it under 60 words
+- Always end with: single character, full body, centered, stuffed animal toy, 32-bit pixel art sprite, pure white background
+
+Example:
+Input: 이 친구의 이름은 최벨리입니다. 용감하고 사랑스러워요.
+Output: white fluffy bunny, confident bright eyes, rosy cheeks, warm gentle smile, soft round chubby body, single character, full body, centered, stuffed animal toy, 32-bit pixel art sprite, pure white background"""
+
+
+def load_qwen():
+    print(f"Qwen2.5-7B 로드 중... ({MODEL_ID})")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+        torch_dtype=torch.float16,
+        device_map="auto",   # GPU/CPU 자동 분배 (12GB GPU에서 안전)
+    ).eval()
+    print("Qwen 로드 완료!\n")
+    return model, tokenizer
+
+
+def persona_to_prompt(korean_text: str, model, tokenizer) -> str:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user",   "content": korean_text},
+    ]
+    text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+    )
+    inputs = tokenizer([text], return_tensors="pt").to("cuda")
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=120,
+            do_sample=False,
+            temperature=None,
+            top_p=None,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+
+    generated = outputs[0][inputs.input_ids.shape[1]:]
+    result = tokenizer.decode(generated, skip_special_tokens=True).strip()
+    return result
+
+
+def unload_qwen(model, tokenizer):
+    # accelerate dispatch hook 먼저 제거 (device_map="auto" 사용 시 필수)
+    try:
+        from accelerate.hooks import remove_hook_from_module
+        remove_hook_from_module(model, recurse=True)
+        print("accelerate hook 제거 완료")
+    except Exception as e:
+        print(f"hook 제거 스킵: {e}")
+    model.cpu()              # GPU → CPU로 이동
+    del model, tokenizer
+    import gc; gc.collect()
+    torch.cuda.empty_cache()
+    torch.cuda.synchronize()
+    print("Qwen VRAM 해제 완료\n")
+
+
+# ── 단독 테스트 ──────────────────────────────────────────────
+if __name__ == "__main__":
+    samples = [
+        "이 친구의 이름은 최벨리입니다. 용감하고, 사랑스러워요. 밤마다 저의 이야기를 잘 들어주고, 포근하게 안아준답니다",
+        "몽실이는 조용하고 차분한 성격이에요. 항상 따뜻한 눈빛으로 바라봐주고, 힘든 날엔 옆에서 말없이 함께 있어줘요",
+        "두부는 엄청 활발하고 장난기가 넘쳐요! 매일 새로운 모험을 꿈꾸고, 친구들에게 먼저 다가가는 붙임성 좋은 친구예요",
+        "솜솜이는 수줍음이 많지만 일단 친해지면 엄청 다정해요. 작고 포근한 외모처럼 마음도 보드랍고 섬세한 친구랍니다",
+    ]
+
+    model, tokenizer = load_qwen()
+
+    for i, text in enumerate(samples, 1):
+        prompt = persona_to_prompt(text, model, tokenizer)
+        print(f"[{i:02d}] 입력: {text[:40]}...")
+        print(f"     출력: {prompt}\n")
+
+    unload_qwen(model, tokenizer)

test_image2feed_pipeline.py

@@ -0,0 +1,351 @@
+"""
+Image-to-feed end-to-end test pipeline.
+
+Flow:
+  Real character image (input)
+    -> rembg background removal
+    -> Qwen2.5-VL appearance JSON extraction (pixel_prompt_core)
+    -> SDXL + lora_v3_32bit pixel art character image
+    -> Korean quest to English scene text
+    -> SDXL + lora_v3_32bit + lora_bg_v1 feed image
+
+Outputs:
+  outputs/image2feed/<name>/
+    input_nobg.png
+    appearance_raw.txt
+    appearance.json
+    character.png
+    quest.json
+    feed.png
+    results.json
+"""
+import argparse
+import gc
+import json
+import os
+import sys
+import traceback
+from pathlib import Path
+
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+
+ROOT = Path(__file__).resolve().parent
+os.chdir(ROOT)
+sys.path.insert(0, str(ROOT))
+
+OUTPUT_ROOT = Path("outputs/image2feed")
+CHAR_LORA_DIR = "models/lora_v3_32bit"
+
+DEFAULT_QUEST_KO = "공원에서 30분 달리기를 완료했어요!"
+
+CHARACTER_NEGATIVE = (
+    "realistic, photograph, 3d render, human, person, anime, scary, "
+    "complex background, multiple characters, text, watermark, logo, "
+    "extra limbs, long limbs, harsh black outline, low quality, blurry"
+)
+
+QUEST_SYSTEM = """You are an action-pose scene prompt writer for Mongle Village, a cozy sky island pixel art village.
+
+Convert a Korean quest completion message into a short English scene description for image generation.
+
+Rules:
+- The FIRST words must describe the character's visible action pose.
+- Keep the activity from the quest very explicit.
+- Include body movement cues such as arms swinging, legs moving, holding a book, stirring a pot, walking steps.
+- Describe one simple matching environment after the action.
+- Set it in a cozy pastel sky island village world.
+- Mention only one character.
+- Do not write only a landscape/background description.
+- Do not make the character standing still unless the quest is resting.
+- 16-28 words max.
+- Output ONLY the English scene description.
+
+Examples:
+Input: 공원에서 30분 달리기를 완료했어요!
+Output: running with arms swinging and legs in motion along a fluffy cloud meadow path
+
+Input: 오늘 책 한 권을 다 읽었어요
+Output: sitting and holding an open storybook under a blossoming cloud tree beside a cozy cottage
+
+Input: 직접 요리해서 건강한 밥을 먹었어요
+Output: cooking with both paws stirring a pot in a cozy cottage kitchen with fresh vegetables
+"""
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--name", default="sample_01")
+    parser.add_argument("--character-image", required=True, help="Path to the input character image.")
+    parser.add_argument("--quest-ko", default=DEFAULT_QUEST_KO)
+    parser.add_argument("--quest-en", default="", help="If provided, skips Qwen text translation.")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--character-steps", type=int, default=30)
+    parser.add_argument("--feed-seed", type=int, default=123, help="Feed generation seed.")
+    parser.add_argument("--force", action="store_true")
+    parser.add_argument("--force-char", action="store_true")
+    parser.add_argument("--force-quest", action="store_true")
+    parser.add_argument("--force-feed", action="store_true")
+    parser.add_argument("--no-4bit-vlm", action="store_true")
+    return parser.parse_args()
+
+
+def remove_background(image_path: Path, out_path: Path):
+    from PIL import Image
+    from rembg import remove
+
+    print("Removing background...", flush=True)
+    image = Image.open(image_path).convert("RGBA")
+    removed = remove(image)
+    white_bg = Image.new("RGBA", removed.size, (255, 255, 255, 255))
+    white_bg.paste(removed, mask=removed.split()[3])
+    result = white_bg.convert("RGB")
+    result.save(out_path)
+    print(f"Background removed: {out_path}", flush=True)
+    return result
+
+
+def extract_appearance(nobg_image, out_dir: Path, use_4bit: bool):
+    from test_qwen25_vl_extract import (
+        extract_json_from_text,
+        load_model,
+        normalize_info,
+        run_extraction,
+    )
+
+    print("Loading Qwen2.5-VL appearance extractor...", flush=True)
+    model, processor = load_model("Qwen/Qwen2.5-VL-7B-Instruct", use_4bit=use_4bit)
+    raw = run_extraction(nobg_image, model, processor, max_new_tokens=900)
+
+    raw_path = out_dir / "appearance_raw.txt"
+    raw_path.write_text(raw, encoding="utf-8")
+
+    info = normalize_info(extract_json_from_text(raw))
+    appearance_path = out_dir / "appearance.json"
+    appearance_path.write_text(json.dumps(info, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(f"Appearance saved: {appearance_path}", flush=True)
+    print(f"  pixel_prompt_core: {info.get('pixel_prompt_core', '')}", flush=True)
+
+    del model, processor
+    gc.collect()
+    try:
+        import torch
+        torch.cuda.empty_cache()
+    except Exception:
+        pass
+    return info
+
+
+def build_character_prompt(appearance: dict):
+    from src.feed.feed_generator_1 import _to_appearance_str
+
+    appearance_str = _to_appearance_str(appearance)
+    body_shape = appearance.get("body_shape", "") if isinstance(appearance, dict) else ""
+    pose = appearance.get("pose", "") if isinstance(appearance, dict) else ""
+
+    shape_hint = f"{body_shape}, " if body_shape else ""
+    pose_hint = f"{pose}, " if pose else ""
+
+    # CLIP-L: 스타일 + 원본의 체형/자세 (비율 강제 없음)
+    prompt = (
+        "monglestyle, "
+        f"{shape_hint}{pose_hint}"
+        "single stuffed animal toy mascot character, full body, centered, "
+        "32-bit pixel art sprite, "
+        "soft pixel shading, clean silhouette, soft brown outline, "
+        "pure white background"
+    )
+    # OpenCLIP-bigG: 캐릭터 외형 전체
+    prompt_2 = f"monglestyle, {appearance_str}"
+    return prompt, prompt_2
+
+
+def generate_character(appearance: dict, out_path: Path, seed: int, steps: int):
+    import torch
+    from diffusers import DPMSolverMultistepScheduler, StableDiffusionXLPipeline
+
+    print("Loading SDXL character pipeline...", flush=True)
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        torch_dtype=torch.float16,
+        use_safetensors=True,
+    )
+    pipe.load_lora_weights(CHAR_LORA_DIR)
+    pipe.fuse_lora(lora_scale=0.9)
+    pipe.unload_lora_weights()
+    pipe.scheduler = DPMSolverMultistepScheduler.from_config(
+        pipe.scheduler.config, use_karras_sigmas=True
+    )
+    pipe.to("cuda")
+    pipe.enable_attention_slicing()
+
+    prompt, prompt_2 = build_character_prompt(appearance)
+    print(f"Character prompt  : {prompt}", flush=True)
+    print(f"Character prompt_2: {prompt_2}", flush=True)
+    image = pipe(
+        prompt=prompt,
+        prompt_2=prompt_2,
+        negative_prompt=CHARACTER_NEGATIVE,
+        num_inference_steps=steps,
+        guidance_scale=7.5,
+        height=1024,
+        width=1024,
+        generator=torch.Generator("cuda").manual_seed(seed),
+    ).images[0]
+    image.save(out_path)
+    print(f"Character saved: {out_path}", flush=True)
+
+    del pipe
+    gc.collect()
+    torch.cuda.empty_cache()
+
+
+def translate_quest(quest_ko: str):
+    print("[quest translation] importing load_qwen...", flush=True)
+    from src.pipeline.persona2prompt import load_qwen, unload_qwen
+    print("[quest translation] importing torch...", flush=True)
+    import torch
+
+    print("Loading Qwen text model for quest translation...", flush=True)
+    model, tokenizer = load_qwen()
+    messages = [
+        {"role": "system", "content": QUEST_SYSTEM},
+        {"role": "user", "content": quest_ko},
+    ]
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer([text], return_tensors="pt").to("cuda")
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=80,
+            do_sample=False,
+            temperature=None,
+            top_p=None,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+    generated = outputs[0][inputs.input_ids.shape[1]:]
+    quest_en = tokenizer.decode(generated, skip_special_tokens=True).strip()
+    unload_qwen(model, tokenizer)
+    return quest_en
+
+
+def generate_feed(quest_en: str, appearance, out_path: Path, seed: int):
+    from src.feed.feed_generator_2 import generate, load_pipeline, unload_pipeline
+
+    print("Loading feed generation pipeline...", flush=True)
+    pipe = load_pipeline()
+    image = generate(appearance, quest_en, pipe, seed=seed)
+    image.save(out_path)
+    print(f"Feed saved: {out_path}", flush=True)
+    unload_pipeline(pipe)
+
+
+def main():
+    args = parse_args()
+    out_dir = OUTPUT_ROOT / args.name
+    out_dir.mkdir(parents=True, exist_ok=True)
+    status_path = out_dir / "status.log"
+
+    def status(message: str):
+        print(message, flush=True)
+        with status_path.open("a", encoding="utf-8") as f:
+            f.write(message + "\n")
+
+    status("=" * 60)
+    status("Image-to-feed pipeline started")
+    status(f"Output dir: {out_dir}")
+
+    src_image = Path(args.character_image).resolve()
+    if not src_image.exists():
+        raise FileNotFoundError(f"--character-image not found: {src_image}")
+
+    nobg_path = out_dir / "input_nobg.png"
+    appearance_path = out_dir / "appearance.json"
+    character_path = out_dir / "character.png"
+    character_nobg_path = out_dir / "character_nobg.png"
+    quest_path = out_dir / "quest.json"
+    feed_path = out_dir / "feed.png"
+    results_path = out_dir / "results.json"
+
+    # STEP 1: background removal
+    if args.force or not nobg_path.exists():
+        status("STEP 1: removing background")
+        nobg_image = remove_background(src_image, nobg_path)
+    else:
+        from PIL import Image
+        nobg_image = Image.open(nobg_path).convert("RGB")
+        status(f"STEP 1: using cached nobg image: {nobg_path}")
+
+    # STEP 2: extract appearance with Qwen2.5-VL
+    if args.force or not appearance_path.exists():
+        status("STEP 2: extracting appearance JSON with Qwen2.5-VL")
+        appearance = extract_appearance(nobg_image, out_dir, use_4bit=not args.no_4bit_vlm)
+    else:
+        appearance = json.loads(appearance_path.read_text(encoding="utf-8"))
+        status(f"STEP 2: using cached appearance: {appearance_path}")
+
+    # STEP 3: generate pixel art character from full appearance description
+    if args.force or args.force_char or not character_path.exists():
+        status("STEP 3: generating pixel art character with SDXL + LoRA")
+        generate_character(appearance, character_path, args.seed, args.character_steps)
+    else:
+        status(f"STEP 3: using cached character: {character_path}")
+
+    if args.force or args.force_char or not character_nobg_path.exists():
+        status("STEP 3.5: removing character background")
+        remove_background(character_path, character_nobg_path)
+    else:
+        status(f"STEP 3.5: using cached character nobg: {character_nobg_path}")
+
+    # STEP 4: translate Korean quest to English scene
+    if args.quest_en:
+        quest_en = args.quest_en
+        status("STEP 4: using provided English quest scene")
+    elif args.force or args.force_quest or not quest_path.exists():
+        status("STEP 4: translating Korean quest to English scene")
+        quest_en = translate_quest(args.quest_ko)
+    else:
+        quest_en = json.loads(quest_path.read_text(encoding="utf-8"))["quest_en"]
+        status(f"STEP 4: using cached quest translation: {quest_path}")
+
+    quest_data = {
+        "quest_ko": args.quest_ko,
+        "quest_en": quest_en,
+    }
+    quest_path.write_text(json.dumps(quest_data, ensure_ascii=False, indent=2), encoding="utf-8")
+    status(f"Quest EN: {quest_en}")
+
+    # STEP 5: generate feed image
+    if args.force or args.force_feed or not feed_path.exists():
+        status("STEP 5: generating feed image")
+        generate_feed(quest_en, appearance, feed_path, args.feed_seed)
+    else:
+        status(f"STEP 5: using cached feed: {feed_path}")
+
+    results = {
+        "name": args.name,
+        "character_image_input": str(src_image),
+        "input_nobg": str(nobg_path).replace("\\", "/"),
+        "character_image": str(character_path).replace("\\", "/"),
+        "character_nobg": str(character_nobg_path).replace("\\", "/"),
+        "appearance_json": str(appearance_path).replace("\\", "/"),
+        "appearance": appearance,
+        "quest": quest_data,
+        "feed_image": str(feed_path).replace("\\", "/"),
+    }
+    results_path.write_text(json.dumps(results, ensure_ascii=False, indent=2), encoding="utf-8")
+    status(f"Results saved: {results_path}")
+    status("Image-to-feed pipeline finished")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        fallback_dir = OUTPUT_ROOT / "sample_01"
+        fallback_dir.mkdir(parents=True, exist_ok=True)
+        error_path = fallback_dir / "error.log"
+        error_text = traceback.format_exc()
+        error_path.write_text(error_text, encoding="utf-8")
+        print(error_text, flush=True)
+        print(f"Error saved: {error_path}", flush=True)
+        raise

test_qwen25_vl_extract.py

@@ -0,0 +1,375 @@
+"""
+Qwen2.5-VL detailed appearance extraction test.
+
+Inputs:
+  image/01.jpg
+  image/10.jpg
+  image/19.jpg
+
+Outputs:
+  outputs/vlm_qwen25_extract/
+    01_nobg.png
+    10_nobg.png
+    19_nobg.png
+    01_raw.txt
+    10_raw.txt
+    19_raw.txt
+    extraction_results.json
+    extraction_report.md
+"""
+import argparse
+import gc
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+
+ROOT = Path(__file__).resolve().parent
+os.chdir(ROOT)
+sys.path.insert(0, str(ROOT))
+
+MODEL_ID = "Qwen/Qwen2.5-VL-7B-Instruct"
+OUTPUT_DIR = Path("outputs/vlm_qwen25_extract")
+
+TEST_IMAGES = [
+    {"name": "01", "path": "image/01.jpg"},
+    {"name": "10", "path": "image/10.jpg"},
+    {"name": "19", "path": "image/19.jpg"},
+]
+
+EXTRACT_PROMPT = """
+You are a meticulous visual character analyst for a plush-to-pixel-art pipeline.
+
+Analyze only the visible plush toy / mascot character in the image.
+Return ONLY valid JSON. Do not include markdown, comments, or extra text.
+
+Important rules:
+- Be specific and concrete. Avoid generic words when visual evidence is available.
+- If a detail is not visible, write "not visible" instead of inventing it.
+- Do not describe the background except whether it is plain/removed.
+- Preserve the character identity: color, silhouette, face, ears, body proportions,
+  markings, accessories, and texture are very important.
+- Use short descriptive phrases, not long paragraphs.
+
+JSON schema:
+{
+  "animal_type": "specific animal or mascot type, e.g. bear, bunny, cat, dog, unknown plush mascot",
+  "body_color": "main body color with nuance, e.g. soft cherry pink, warm cream white",
+  "secondary_colors": ["all visible secondary colors and where they appear"],
+  "color_pattern": "how colors are arranged on the body",
+  "body_shape": "overall body silhouette and proportions",
+  "head_shape": "head shape and size relative to body",
+  "ear_shape": "ear shape, placement, and size",
+  "eye_style": "eye size, shape, color, material impression, highlights",
+  "nose_shape": "nose shape, color, size, and placement",
+  "mouth_shape": "mouth shape/expression, or not visible",
+  "cheeks": "blush or cheek detail, or not visible",
+  "limbs": "arms/legs/paws shape, length, pose, and color",
+  "pose": "front/side/standing/sitting/lying and any visible gesture",
+  "texture": "plush surface texture and softness",
+  "accessories": ["bows, tags, clothes, charms, strings, or none"],
+  "distinctive_features": ["identity-preserving details, each as one phrase"],
+  "pixel_prompt_core": "one concise English phrase for image generation preserving the character",
+  "overall_feel": "2-5 words describing visual impression",
+  "uncertain_details": ["details that may be ambiguous"]
+}
+""".strip()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", default=MODEL_ID)
+    parser.add_argument("--output", default=str(OUTPUT_DIR))
+    parser.add_argument("--max-new-tokens", type=int, default=900)
+    parser.add_argument("--no-4bit", action="store_true", help="Disable 4bit loading fallback attempt.")
+    parser.add_argument("--keep-original-bg", action="store_true", help="Do not run rembg before VLM.")
+    return parser.parse_args()
+
+
+def remove_bg_white(image_path: str):
+    from PIL import Image
+
+    image = Image.open(image_path).convert("RGB")
+    try:
+        from rembg import remove
+
+        removed = remove(image.convert("RGBA"))
+        white_bg = Image.new("RGBA", removed.size, (255, 255, 255, 255))
+        white_bg.paste(removed, mask=removed.split()[3])
+        return white_bg.convert("RGB"), True
+    except Exception as exc:
+        print(f"  rembg failed, using original image: {exc}", flush=True)
+        return image, False
+
+
+def load_model(model_id: str, use_4bit: bool):
+    import torch
+    from transformers import AutoProcessor
+
+    try:
+        from transformers import Qwen2_5_VLForConditionalGeneration as QwenVLModel
+    except ImportError as exc:
+        raise ImportError(
+            "Your transformers version does not expose Qwen2_5_VLForConditionalGeneration. "
+            "Run: pip install -U transformers accelerate qwen-vl-utils"
+        ) from exc
+
+    print(f"Loading {model_id}", flush=True)
+
+    if use_4bit:
+        try:
+            from transformers import BitsAndBytesConfig
+
+            bnb = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=torch.float16,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4",
+            )
+            model = QwenVLModel.from_pretrained(
+                model_id,
+                quantization_config=bnb,
+                device_map="auto",
+                trust_remote_code=True,
+            ).eval()
+            print("  Loaded in 4bit.", flush=True)
+        except Exception as exc:
+            print(f"  4bit load failed: {exc}", flush=True)
+            print("  Falling back to float16 + device_map=auto.", flush=True)
+            model = QwenVLModel.from_pretrained(
+                model_id,
+                torch_dtype=torch.float16,
+                device_map="auto",
+                trust_remote_code=True,
+            ).eval()
+    else:
+        model = QwenVLModel.from_pretrained(
+            model_id,
+            torch_dtype=torch.float16,
+            device_map="auto",
+            trust_remote_code=True,
+        ).eval()
+
+    processor = AutoProcessor.from_pretrained(
+        model_id,
+        min_pixels=256 * 28 * 28,
+        max_pixels=768 * 28 * 28,
+        trust_remote_code=True,
+    )
+    return model, processor
+
+
+def extract_json_from_text(raw: str):
+    clean = raw.strip()
+    fence = re.search(r"```(?:json)?\s*(.*?)\s*```", clean, flags=re.DOTALL | re.IGNORECASE)
+    if fence:
+        clean = fence.group(1).strip()
+
+    start = clean.find("{")
+    end = clean.rfind("}")
+    if start != -1 and end != -1 and end > start:
+        clean = clean[start : end + 1]
+
+    return json.loads(clean)
+
+
+def ensure_list(value):
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    if isinstance(value, str):
+        if value.strip().lower() in {"", "none", "not visible"}:
+            return []
+        return [value]
+    return [str(value)]
+
+
+def normalize_info(info: dict):
+    list_fields = [
+        "secondary_colors",
+        "accessories",
+        "distinctive_features",
+        "uncertain_details",
+    ]
+    for field in list_fields:
+        info[field] = ensure_list(info.get(field))
+    return info
+
+
+def run_extraction(image, model, processor, max_new_tokens: int):
+    import torch
+    from qwen_vl_utils import process_vision_info
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image},
+                {"type": "text", "text": EXTRACT_PROMPT},
+            ],
+        }
+    ]
+
+    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    image_inputs, video_inputs = process_vision_info(messages)
+    inputs = processor(
+        text=[text],
+        images=image_inputs,
+        videos=video_inputs,
+        padding=True,
+        return_tensors="pt",
+    )
+
+    if torch.cuda.is_available():
+        inputs = inputs.to("cuda")
+
+    with torch.no_grad():
+        generated_ids = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            do_sample=False,
+        )
+
+    trimmed = generated_ids[0][inputs.input_ids.shape[1] :]
+    raw = processor.decode(trimmed, skip_special_tokens=True).strip()
+
+    del inputs, generated_ids, trimmed
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+    return raw
+
+
+def write_report(results, output_dir: Path, model_id: str):
+    report_path = output_dir / "extraction_report.md"
+    with report_path.open("w", encoding="utf-8") as f:
+        f.write("# Qwen2.5-VL Appearance Extraction Report\n\n")
+        f.write(f"Model: `{model_id}`\n\n")
+
+        for result in results:
+            info = result["extracted"]
+            f.write(f"## Image {result['name']}\n\n")
+            f.write(f"- Source: `{result['source']}`\n")
+            f.write(f"- Processed: `{result['processed_image']}`\n")
+            f.write(f"- JSON parse: `{result['parse_ok']}`\n\n")
+
+            f.write("| Field | Value |\n")
+            f.write("|---|---|\n")
+            for key, value in info.items():
+                if isinstance(value, list):
+                    value = ", ".join(str(v) for v in value) if value else "-"
+                f.write(f"| `{key}` | {value} |\n")
+            f.write("\n")
+
+            f.write("### Pixel Prompt Core\n\n")
+            f.write("```text\n")
+            f.write(str(info.get("pixel_prompt_core", "")))
+            f.write("\n```\n\n")
+
+            if result.get("raw_output"):
+                f.write("### Raw Output\n\n")
+                f.write("```json\n")
+                f.write(result["raw_output"])
+                f.write("\n```\n\n")
+
+    print(f"Report saved: {report_path}", flush=True)
+
+
+def main():
+    args = parse_args()
+    output_dir = Path(args.output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    model, processor = load_model(args.model, use_4bit=not args.no_4bit)
+
+    results = []
+    for case in TEST_IMAGES:
+        name = case["name"]
+        print("\n" + "=" * 60, flush=True)
+        print(f"[{name}] {case['path']}", flush=True)
+
+        if args.keep_original_bg:
+            from PIL import Image
+
+            image = Image.open(case["path"]).convert("RGB")
+            rembg_ok = False
+        else:
+            image, rembg_ok = remove_bg_white(case["path"])
+
+        processed_path = output_dir / f"{name}_nobg.png"
+        image.save(processed_path)
+        print(f"  Processed image saved: {processed_path}", flush=True)
+
+        raw = run_extraction(image, model, processor, args.max_new_tokens)
+        raw_path = output_dir / f"{name}_raw.txt"
+        raw_path.write_text(raw, encoding="utf-8")
+        print(f"  Raw output saved: {raw_path}", flush=True)
+
+        try:
+            info = normalize_info(extract_json_from_text(raw))
+            parse_ok = True
+        except Exception as exc:
+            print(f"  JSON parse failed: {exc}", flush=True)
+            info = {
+                "animal_type": "parse_failed",
+                "body_color": "parse_failed",
+                "secondary_colors": [],
+                "color_pattern": "parse_failed",
+                "body_shape": "parse_failed",
+                "head_shape": "parse_failed",
+                "ear_shape": "parse_failed",
+                "eye_style": "parse_failed",
+                "nose_shape": "parse_failed",
+                "mouth_shape": "parse_failed",
+                "cheeks": "parse_failed",
+                "limbs": "parse_failed",
+                "pose": "parse_failed",
+                "texture": "parse_failed",
+                "accessories": [],
+                "distinctive_features": [],
+                "pixel_prompt_core": "",
+                "overall_feel": "parse_failed",
+                "uncertain_details": [str(exc)],
+            }
+            parse_ok = False
+
+        results.append(
+            {
+                "name": name,
+                "source": case["path"],
+                "processed_image": str(processed_path).replace("\\", "/"),
+                "rembg_ok": rembg_ok,
+                "parse_ok": parse_ok,
+                "extracted": info,
+                "raw_output": raw,
+            }
+        )
+
+        print(f"  animal_type: {info.get('animal_type')}", flush=True)
+        print(f"  body_color : {info.get('body_color')}", flush=True)
+        print(f"  core       : {info.get('pixel_prompt_core')}", flush=True)
+
+    json_path = output_dir / "extraction_results.json"
+    json_path.write_text(json.dumps(results, ensure_ascii=False, indent=2), encoding="utf-8")
+    print("\n" + "=" * 60, flush=True)
+    print(f"JSON saved: {json_path}", flush=True)
+    write_report(results, output_dir, args.model)
+
+    del model, processor
+    gc.collect()
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    except Exception:
+        pass
+
+
+if __name__ == "__main__":
+    main()

test_text2feed_pipeline.py

@@ -0,0 +1,398 @@
+"""
+Text-to-feed end-to-end test pipeline.
+
+Flow:
+  Korean character text
+    -> English visual character prompt
+    -> SDXL + lora_v3_32bit character image
+    -> Qwen2.5-VL appearance JSON extraction
+    -> Korean quest to English scene text
+    -> SDXL + lora_v3_32bit + lora_bg_v1 feed image
+
+Outputs:
+  outputs/text2feed/<name>/
+    character.png
+    appearance_raw.txt
+    appearance.json
+    quest.json
+    feed.png
+    results.json
+"""
+import argparse
+import gc
+import json
+import os
+import sys
+import traceback
+from pathlib import Path
+
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+
+ROOT = Path(__file__).resolve().parent
+os.chdir(ROOT)
+sys.path.insert(0, str(ROOT))
+
+OUTPUT_ROOT = Path("outputs/text2feed")
+CHAR_LORA_DIR = "models/lora_v3_32bit"
+
+DEFAULT_CHARACTER_KO = (
+    "이 친구는 부드러운 체리핑크색 곰 인형이에요. "
+    "크림색 배를 가지고 있고, 작은 둥근 귀와 분홍색 코, "
+    "짧고 통통한 팔다리와 포근한 표정을 가지고 있어요."
+)
+DEFAULT_CHARACTER_EN = (
+    "soft cherry pink bear plush mascot with a cream white belly, "
+    "small rounded ears, tiny pink oval nose, simple smiling mouth, "
+    "short rounded limbs, smooth plush texture"
+)
+DEFAULT_QUEST_KO = "공원에서 30분 달리기를 완료했어요!"
+
+CHARACTER_NEGATIVE = (
+    "realistic, photograph, 3d render, human, person, anime, scary, "
+    "complex background, multiple characters, text, watermark, logo, "
+    "extra limbs, long limbs, harsh black outline, low quality, blurry"
+)
+
+QUEST_SYSTEM = """You are an action-pose scene prompt writer for Mongle Village, a cozy sky island pixel art village.
+
+Convert a Korean quest completion message into a short English scene description for image generation.
+
+Rules:
+- The FIRST words must describe the character's visible action pose.
+- Keep the activity from the quest very explicit.
+- Include body movement cues such as arms swinging, legs moving, holding a book, stirring a pot, walking steps.
+- Describe one simple matching environment after the action.
+- Set it in a cozy pastel sky island village world.
+- Mention only one character.
+- Do not write only a landscape/background description.
+- Do not make the character standing still unless the quest is resting.
+- 16-28 words max.
+- Output ONLY the English scene description.
+
+Examples:
+Input: 공원에서 30분 달리기를 완료했어요!
+Output: running with arms swinging and legs in motion along a fluffy cloud meadow path
+
+Input: 오늘 책 한 권을 다 읽었어요
+Output: sitting and holding an open storybook under a blossoming cloud tree beside a cozy cottage
+
+Input: 직접 요리해서 건강한 밥을 먹었어요
+Output: cooking with both paws stirring a pot in a cozy cottage kitchen with fresh vegetables
+"""
+
+CHARACTER_SYSTEM = """You are a visual prompt writer for a plush-to-pixel-art character generation pipeline.
+
+Convert a Korean character description into a concise English visual prompt.
+
+Rules:
+- Focus only on visible appearance: animal type, body color, face, ears, body shape, limbs, texture, accessories.
+- Convert personality words into visible expression only.
+- If animal type is not specified, choose a soft plush animal that fits the description.
+- If color is not specified, choose one pastel color.
+- Do not include background, scene, action, story, name, or relationship.
+- 25-45 words.
+- Output ONLY the English visual prompt.
+
+Example:
+Input: 이 친구는 용감하고 사랑스러운 하얀 토끼 인형이에요. 볼이 발그레하고 포근해요.
+Output: white bunny plush mascot, rosy cheeks, confident bright eyes, warm gentle smile, soft round chubby body, short rounded limbs, fluffy plush texture
+"""
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--name", default="sample_01")
+    parser.add_argument("--character-ko", default=DEFAULT_CHARACTER_KO)
+    parser.add_argument(
+        "--character-text",
+        default="",
+        help="English visual character prompt. If omitted, --character-ko is translated first.",
+    )
+    parser.add_argument("--quest-ko", default=DEFAULT_QUEST_KO)
+    parser.add_argument("--quest-en", default="", help="If provided, skips Qwen text translation.")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--force", action="store_true")
+    parser.add_argument("--force-quest", action="store_true")
+    parser.add_argument("--force-feed", action="store_true")
+    parser.add_argument("--no-4bit-vlm", action="store_true")
+    parser.add_argument("--character-steps", type=int, default=30)
+    parser.add_argument("--feed-seed", type=int, default=123)
+    return parser.parse_args()
+
+
+def character_prompt(character_text: str) -> str:
+    return (
+        "monglestyle, "
+        f"{character_text}, "
+        "single stuffed animal toy mascot character, full body, centered, "
+        "front view, cute chibi proportions, 32-bit pixel art sprite, "
+        "soft pixel shading, clean silhouette, soft brown outline, "
+        "pure white background"
+    )
+
+
+def translate_character(character_ko: str):
+    print("[character translation] importing load_qwen...", flush=True)
+    from src.pipeline.persona2prompt import load_qwen, unload_qwen
+    print("[character translation] importing torch...", flush=True)
+    import torch
+
+    print("Loading Qwen text model for character translation...", flush=True)
+    model, tokenizer = load_qwen()
+    messages = [
+        {"role": "system", "content": CHARACTER_SYSTEM},
+        {"role": "user", "content": character_ko},
+    ]
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer([text], return_tensors="pt").to("cuda")
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=120,
+            do_sample=False,
+            temperature=None,
+            top_p=None,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+    generated = outputs[0][inputs.input_ids.shape[1] :]
+    character_en = tokenizer.decode(generated, skip_special_tokens=True).strip()
+    unload_qwen(model, tokenizer)
+    return character_en
+
+
+def generate_character(character_text: str, out_path: Path, seed: int, steps: int):
+    import torch
+    from diffusers import DPMSolverMultistepScheduler, StableDiffusionXLPipeline
+
+    print("Loading SDXL character pipeline...", flush=True)
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        torch_dtype=torch.float16,
+        use_safetensors=True,
+    )
+    pipe.load_lora_weights(CHAR_LORA_DIR)
+    pipe.fuse_lora(lora_scale=0.9)
+    pipe.unload_lora_weights()
+    pipe.scheduler = DPMSolverMultistepScheduler.from_config(
+        pipe.scheduler.config, use_karras_sigmas=True
+    )
+    pipe.to("cuda")
+    pipe.enable_attention_slicing()
+
+    prompt = character_prompt(character_text)
+    print(f"Character prompt: {prompt}", flush=True)
+    image = pipe(
+        prompt=prompt,
+        negative_prompt=CHARACTER_NEGATIVE,
+        num_inference_steps=steps,
+        guidance_scale=7.5,
+        height=1024,
+        width=1024,
+        generator=torch.Generator("cuda").manual_seed(seed),
+    ).images[0]
+    image.save(out_path)
+    print(f"Character saved: {out_path}", flush=True)
+
+    del pipe
+    gc.collect()
+    torch.cuda.empty_cache()
+
+
+def extract_appearance(character_path: Path, out_dir: Path, use_4bit: bool):
+    from PIL import Image
+    from test_qwen25_vl_extract import (
+        extract_json_from_text,
+        load_model,
+        normalize_info,
+        run_extraction,
+    )
+
+    print("Loading Qwen2.5-VL appearance extractor...", flush=True)
+    model, processor = load_model("Qwen/Qwen2.5-VL-7B-Instruct", use_4bit=use_4bit)
+    image = Image.open(character_path).convert("RGB")
+    raw = run_extraction(image, model, processor, max_new_tokens=900)
+
+    raw_path = out_dir / "appearance_raw.txt"
+    raw_path.write_text(raw, encoding="utf-8")
+
+    info = normalize_info(extract_json_from_text(raw))
+    appearance_path = out_dir / "appearance.json"
+    appearance_path.write_text(json.dumps(info, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(f"Appearance saved: {appearance_path}", flush=True)
+
+    del model, processor
+    gc.collect()
+    try:
+        import torch
+
+        torch.cuda.empty_cache()
+    except Exception:
+        pass
+    return info
+
+
+def translate_quest(quest_ko: str):
+    print("[quest translation] importing load_qwen...", flush=True)
+    from src.pipeline.persona2prompt import load_qwen, unload_qwen
+    print("[quest translation] importing torch...", flush=True)
+    import torch
+
+    print("Loading Qwen text model for quest translation...", flush=True)
+    model, tokenizer = load_qwen()
+    messages = [
+        {"role": "system", "content": QUEST_SYSTEM},
+        {"role": "user", "content": quest_ko},
+    ]
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer([text], return_tensors="pt").to("cuda")
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=80,
+            do_sample=False,
+            temperature=None,
+            top_p=None,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+    generated = outputs[0][inputs.input_ids.shape[1] :]
+    quest_en = tokenizer.decode(generated, skip_special_tokens=True).strip()
+    unload_qwen(model, tokenizer)
+    return quest_en
+
+
+def remove_character_bg(character_path: Path, out_path: Path):
+    from PIL import Image
+    from rembg import remove
+
+    print("Removing character background...", flush=True)
+    image = Image.open(character_path).convert("RGBA")
+    result = remove(image)
+    result.save(out_path)
+    print(f"Character nobg saved: {out_path}", flush=True)
+
+
+def generate_feed(quest_en: str, appearance, out_path: Path, seed: int):
+    from src.feed.feed_generator_1 import generate, load_pipeline, unload_pipeline
+
+    print("Loading feed generation pipeline...", flush=True)
+    pipe = load_pipeline()
+    image = generate(appearance, quest_en, pipe, seed=seed)
+    image.save(out_path)
+    print(f"Feed saved: {out_path}", flush=True)
+    unload_pipeline(pipe)
+
+
+def main():
+    args = parse_args()
+    out_dir = OUTPUT_ROOT / args.name
+    out_dir.mkdir(parents=True, exist_ok=True)
+    status_path = out_dir / "status.log"
+
+    def status(message: str):
+        print(message, flush=True)
+        with status_path.open("a", encoding="utf-8") as f:
+            f.write(message + "\n")
+
+    status("=" * 60)
+    status("Text-to-feed pipeline started")
+    status(f"Output dir: {out_dir}")
+
+    character_path = out_dir / "character.png"
+    character_nobg_path = out_dir / "character_nobg.png"
+    character_prompt_path = out_dir / "character_prompt.json"
+    appearance_path = out_dir / "appearance.json"
+    quest_path = out_dir / "quest.json"
+    feed_path = out_dir / "feed.png"
+    results_path = out_dir / "results.json"
+
+    if args.character_text:
+        character_text = args.character_text
+        status("STEP 0: using provided English character prompt")
+    elif args.force or not character_prompt_path.exists():
+        status("STEP 0: translating Korean character description to English prompt")
+        character_text = translate_character(args.character_ko)
+    else:
+        character_text = json.loads(character_prompt_path.read_text(encoding="utf-8"))["character_text"]
+        status(f"STEP 0: using cached character prompt: {character_prompt_path}")
+
+    character_prompt_data = {
+        "character_ko": args.character_ko,
+        "character_text": character_text,
+    }
+    character_prompt_path.write_text(
+        json.dumps(character_prompt_data, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    status(f"Character EN: {character_text}")
+
+    if args.force or not character_path.exists():
+        status("STEP 1: generating character image")
+        generate_character(character_text, character_path, args.seed, args.character_steps)
+    else:
+        status(f"STEP 1: using cached character: {character_path}")
+
+    if args.force or not character_nobg_path.exists():
+        status("STEP 1.5: removing character background")
+        remove_character_bg(character_path, character_nobg_path)
+    else:
+        status(f"STEP 1.5: using cached character nobg: {character_nobg_path}")
+
+    if args.force or not appearance_path.exists():
+        status("STEP 2: extracting appearance JSON with Qwen2.5-VL")
+        appearance = extract_appearance(character_path, out_dir, use_4bit=not args.no_4bit_vlm)
+    else:
+        appearance = json.loads(appearance_path.read_text(encoding="utf-8"))
+        status(f"STEP 2: using cached appearance: {appearance_path}")
+
+    if args.quest_en:
+        quest_en = args.quest_en
+        status("STEP 3: using provided English quest scene")
+    elif args.force or args.force_quest or not quest_path.exists():
+        status("STEP 3: translating Korean quest to English scene")
+        quest_en = translate_quest(args.quest_ko)
+    else:
+        quest_en = json.loads(quest_path.read_text(encoding="utf-8"))["quest_en"]
+        status(f"STEP 3: using cached quest translation: {quest_path}")
+
+    quest_data = {
+        "quest_ko": args.quest_ko,
+        "quest_en": quest_en,
+    }
+    quest_path.write_text(json.dumps(quest_data, ensure_ascii=False, indent=2), encoding="utf-8")
+    status(f"Quest EN: {quest_en}")
+
+    if args.force or args.force_feed or not feed_path.exists():
+        status("STEP 4: generating feed image")
+        generate_feed(quest_en, appearance, feed_path, args.feed_seed)
+    else:
+        status(f"STEP 4: using cached feed: {feed_path}")
+
+    results = {
+        "name": args.name,
+        "character_ko": args.character_ko,
+        "character_text": character_text,
+        "character_prompt_json": str(character_prompt_path).replace("\\", "/"),
+        "character_image": str(character_path).replace("\\", "/"),
+        "character_nobg": str(character_nobg_path).replace("\\", "/"),
+        "appearance_json": str(appearance_path).replace("\\", "/"),
+        "appearance": appearance,
+        "quest": quest_data,
+        "feed_image": str(feed_path).replace("\\", "/"),
+    }
+    results_path.write_text(json.dumps(results, ensure_ascii=False, indent=2), encoding="utf-8")
+    status(f"Results saved: {results_path}")
+    status("Text-to-feed pipeline finished")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        fallback_dir = OUTPUT_ROOT / "sample_01"
+        fallback_dir.mkdir(parents=True, exist_ok=True)
+        error_path = fallback_dir / "error.log"
+        error_text = traceback.format_exc()
+        error_path.write_text(error_text, encoding="utf-8")
+        print(error_text, flush=True)
+        print(f"Error saved: {error_path}", flush=True)
+        raise