Update app.py

app.py

@@ -1,426 +1,281 @@
-import spaces
-import math
 import gradio as gr
-import numpy as np
-import torch
-import safetensors.torch as sf
-
-from PIL import Image
-from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline
-from diffusers import AutoencoderKL, UNet2DConditionModel, DDIMScheduler, EulerAncestralDiscreteScheduler, DPMSolverMultistepScheduler
-from diffusers.models.attention_processor import AttnProcessor2_0
-from transformers import CLIPTextModel, CLIPTokenizer
-from briarmbg import BriaRMBG
-from enum import Enum
-
-# Cohere 모델을 사용하기 위한 라이브러리
+import requests
+from bs4 import BeautifulSoup
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.retry import Retry
+import re
+import time
+import random
+import os
 from huggingface_hub import InferenceClient
 
-# CohereForAI/c4ai-command-r-plus 모델 사용 설정
-client = InferenceClient(model_name="CohereForAI/c4ai-command-r-plus")
-
-# Stable Diffusion 설정
-sd15_name = 'stablediffusionapi/realistic-vision-v51'
-model_path = './models/iclight_sd15_fc.safetensors'
-
-# 모델 로드
-tokenizer = CLIPTokenizer.from_pretrained(sd15_name, subfolder="tokenizer")
-text_encoder = CLIPTextModel.from_pretrained(sd15_name, subfolder="text_encoder")
-vae = AutoencoderKL.from_pretrained(sd15_name, subfolder="vae")
-unet = UNet2DConditionModel.from_pretrained(sd15_name, subfolder="unet")
-rmbg = BriaRMBG.from_pretrained("briaai/RMBG-1.4")
-
-# UNet 수정
-with torch.no_grad():
-    new_conv_in = torch.nn.Conv2d(8, unet.conv_in.out_channels, unet.conv_in.kernel_size, unet.conv_in.stride, unet.conv_in.padding)
-    new_conv_in.weight.zero_()
-    new_conv_in.weight[:, :4, :, :].copy_(unet.conv_in.weight)
-    new_conv_in.bias = unet.conv_in.bias
-    unet.conv_in = new_conv_in
-
-unet_original_forward = unet.forward
-
-def hooked_unet_forward(sample, timestep, encoder_hidden_states, **kwargs):
-    c_concat = kwargs.get('cross_attention_kwargs', {}).get('concat_conds', None)
-    if c_concat is not None:
-        c_concat = c_concat.to(sample.device)
-        c_concat = torch.cat([c_concat] * (sample.shape[0] // c_concat.shape[0]), dim=0)
-        sample = torch.cat([sample, c_concat], dim=1)
-    kwargs['cross_attention_kwargs'] = {}
-    return unet_original_forward(sample, timestep, encoder_hidden_states, **kwargs)
-
-unet.forward = hooked_unet_forward
-
-# 모델 로드
-try:
-    sd_offset = sf.load_file(model_path)
-    sd_origin = unet.state_dict()
-    sd_merged = {k: sd_origin[k] + sd_offset[k] for k in sd_origin.keys()}
-    unet.load_state_dict(sd_merged, strict=True)
-    del sd_offset, sd_origin, sd_merged
-except FileNotFoundError:
-    print(f"Error: Model file not found at {model_path}")
-    # 적절한 예외 처리를 추가할 수 있습니다.
-
-# 디바이스 설정
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-text_encoder = text_encoder.to(device=device, dtype=torch.float16)
-vae = vae.to(device=device, dtype=torch.float16)
-unet = unet.to(device=device, dtype=torch.float16)
-rmbg = rmbg.to(device=device, dtype=torch.float32)
-
-# SDP 설정
-unet.set_attn_processor(AttnProcessor2_0())
-vae.set_attn_processor(AttnProcessor2_0())
-
-# 스케줄러 설정
-ddim_scheduler = DDIMScheduler(
-    num_train_timesteps=1000,
-    beta_start=0.00085,
-    beta_end=0.012,
-    beta_schedule="scaled_linear",
-    clip_sample=False,
-    set_alpha_to_one=False,
-    steps_offset=1,
-)
-
-euler_a_scheduler = EulerAncestralDiscreteScheduler(
-    num_train_timesteps=1000,
-    beta_start=0.00085,
-    beta_end=0.012,
-    steps_offset=1
-)
-
-dpmpp_2m_sde_karras_scheduler = DPMSolverMultistepScheduler(
-    num_train_timesteps=1000,
-    beta_start=0.00085,
-    beta_end=0.012,
-    algorithm_type="sde-dpmsolver++",
-    use_karras_sigmas=True,
-    steps_offset=1
-)
-
-# 파이프라인 설정
-t2i_pipe = StableDiffusionPipeline(
-    vae=vae,
-    text_encoder=text_encoder,
-    tokenizer=tokenizer,
-    unet=unet,
-    scheduler=dpmpp_2m_sde_karras_scheduler,
-    safety_checker=None,
-    requires_safety_checker=False,
-    feature_extractor=None,
-    image_encoder=None
-)
-
-i2i_pipe = StableDiffusionImg2ImgPipeline(
-    vae=vae,
-    text_encoder=text_encoder,
-    tokenizer=tokenizer,
-    unet=unet,
-    scheduler=dpmpp_2m_sde_karras_scheduler,
-    safety_checker=None,
-    requires_safety_checker=False,
-    feature_extractor=None,
-    image_encoder=None
-)
-
-@torch.inference_mode()
-def encode_prompt_inner(txt: str):
-    max_length = tokenizer.model_max_length
-    chunk_length = tokenizer.model_max_length - 2
-    id_start = tokenizer.bos_token_id
-    id_end = tokenizer.eos_token_id
-    id_pad = id_end
-
-    def pad(x, p, i):
-        return x[:i] if len(x) >= i else x + [p] * (i - len(x))
-
-    tokens = tokenizer(txt, truncation=False, add_special_tokens=False)["input_ids"]
-    chunks = [[id_start] + tokens[i: i + chunk_length] + [id_end] for i in range(0, len(tokens), chunk_length)]
-    chunks = [pad(ck, id_pad, max_length) for ck in chunks]
-
-    token_ids = torch.tensor(chunks).to(device=device, dtype=torch.int64)
-    conds = text_encoder(token_ids).last_hidden_state
-
-    return conds
-
-@torch.inference_mode()
-def encode_prompt_pair(positive_prompt, negative_prompt):
-    c = encode_prompt_inner(positive_prompt)
-    uc = encode_prompt_inner(negative_prompt)
-
-    c_len = float(len(c))
-    uc_len = float(len(uc))
-    max_count = max(c_len, uc_len)
-    c_repeat = int(math.ceil(max_count / c_len))
-    uc_repeat = int(math.ceil(max_count / uc_len))
-    max_chunk = max(len(c), len(uc))
-
-    c = torch.cat([c] * c_repeat, dim=0)[:max_chunk]
-    uc = torch.cat([uc] * uc_repeat, dim=0)[:max_chunk]
-
-    c = torch.cat([p[None, ...] for p in c], dim=1)
-    uc = torch.cat([p[None, ...] for p in uc], dim=1)
-
-    return c, uc
-
-@torch.inference_mode()
-def pytorch2numpy(imgs, quant=True):
-    results = []
-    for x in imgs:
-        y = x.movedim(0, -1)
-
-        if quant:
-            y = y * 127.5 + 127.5
-            y = y.detach().float().cpu().numpy().clip(0, 255).astype(np.uint8)
+def setup_session():
+    try:
+        session = requests.Session()
+        retries = Retry(total=5, backoff_factor=1, status_forcelist=[502, 503, 504])
+        session.mount('https://', HTTPAdapter(max_retries=retries))
+        return session
+    except Exception as e:
+        return None
+
+def generate_naver_search_url(query):
+    base_url = "https://search.naver.com/search.naver?"
+    params = {"ssc": "tab.blog.all", "sm": "tab_jum", "query": query}
+    url = base_url + "&".join(f"{key}={value}" for key, value in params.items())
+    return url
+
+def crawl_blog_content(url, session):
+    try:
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+            "Accept-Language": "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Connection": "keep-alive",
+            "Referer": "https://search.naver.com/search.naver",
+        }
+        
+        # 랜덤 딜레이 추가
+        delay = random.uniform(1, 2)
+        time.sleep(delay)
+
+        response = session.get(url, headers=headers)
+        if response.status_code != 200:
+            return ""
+        
+        soup = BeautifulSoup(response.content, "html.parser")
+        content = soup.find("div", attrs={'class': 'se-main-container'})
+        
+        if content:
+            return clean_text(content.get_text())
         else:
-            y = y * 0.5 + 0.5
-            y = y.detach().float().cpu().numpy().clip(0, 1).astype(np.float32)
-
-        results.append(y)
-    return results
-
-@torch.inference_mode()
-def numpy2pytorch(imgs):
-    h = torch.from_numpy(np.stack(imgs, axis=0)).float() / 127.0 - 1.0  # so that 127 must be strictly 0.0
-    h = h.movedim(-1, 1)
-    return h
-
-def resize_and_center_crop(image, target_width, target_height):
-    pil_image = Image.fromarray(image)
-    original_width, original_height = pil_image.size
-    scale_factor = max(target_width / original_width, target_height / original_height)
-    resized_width = int(round(original_width * scale_factor))
-    resized_height = int(round(original_height * scale_factor))
-    resized_image = pil_image.resize((resized_width, resized_height), Image.LANCZOS)
-    left = (resized_width - target_width) / 2
-    top = (resized_height - target_height) / 2
-    right = (resized_width + target_width) / 2
-    bottom = (resized_height + target_height) / 2
-    cropped_image = resized_image.crop((left, top, right, bottom))
-    return np.array(cropped_image)
-
-def resize_without_crop(image, target_width, target_height):
-    pil_image = Image.fromarray(image)
-    resized_image = pil_image.resize((target_width, target_height), Image.LANCZOS)
-    return np.array(resized_image)
-
-@torch.inference_mode()
-def run_rmbg(img, sigma=0.0):
-    H, W, C = img.shape
-    assert C == 3
-    k = (256.0 / float(H * W)) ** 0.5
-    feed = resize_without_crop(img, int(64 * round(W * k)), int(64 * round(H * k)))
-    feed = numpy2pytorch([feed]).to(device=device, dtype=torch.float32)
-    alpha = rmbg(feed)[0][0]
-    alpha = torch.nn.functional.interpolate(alpha, size=(H, W), mode="bilinear")
-    alpha = alpha.movedim(1, -1)[0]
-    alpha = alpha.detach().float().cpu().numpy().clip(0, 1)
-    result = 127 + (img.astype(np.float32) - 127 + sigma) * alpha
-    return result.clip(0, 255).astype(np.uint8), alpha
-
-@torch.inference_mode()
-def process(input_fg, prompt, bg_source, image_width, image_height):
-    # UI에서 제거된 매개변수의 값 설정
-    num_samples = 1
-    seed = 12345
-    steps = 25
-    cfg = 2
-    lowres_denoise = 0.9
-    highres_scale = 1.5
-    highres_denoise = 0.5
-    a_prompt = 'best quality'
-    n_prompt = 'lowres, bad anatomy, bad hands, cropped, worst quality'
-
-    bg_source = BGSource(bg_source)
-    input_bg = None
-
-    # 이미지 크기를 8의 배수로 조정
-    image_width = (image_width // 8) * 8
-    image_height = (image_height // 8) * 8
-
-    if bg_source == BGSource.NONE:
-        pass
-    elif bg_source == BGSource.LEFT:
-        gradient = np.linspace(255, 0, image_width)
-        image = np.tile(gradient, (image_height, 1))
-        input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-    elif bg_source == BGSource.RIGHT:
-        gradient = np.linspace(0, 255, image_width)
-        image = np.tile(gradient, (image_height, 1))
-        input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-    elif bg_source == BGSource.TOP:
-        gradient = np.linspace(255, 0, image_height)[:, None]
-        image = np.tile(gradient, (1, image_width))
-        input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-    elif bg_source == BGSource.BOTTOM:
-        gradient = np.linspace(0, 255, image_height)[:, None]
-        image = np.tile(gradient, (1, image_width))
-        input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-    else:
-        raise ValueError('Wrong initial latent!')
-
-    rng = torch.Generator(device=device).manual_seed(int(seed))
-
-    fg = resize_and_center_crop(input_fg, image_width, image_height)
-
-    concat_conds = numpy2pytorch([fg]).to(device=vae.device, dtype=vae.dtype)
-    concat_conds = vae.encode(concat_conds).latent_dist.mode() * vae.config.scaling_factor
-
-    conds, unconds = encode_prompt_pair(positive_prompt=prompt + ', ' + a_prompt, negative_prompt=n_prompt)
-
-    if input_bg is None:
-        latents = t2i_pipe(
-            prompt_embeds=conds,
-            negative_prompt_embeds=unconds,
-            width=image_width,
-            height=image_height,
-            num_inference_steps=steps,
-            num_images_per_prompt=num_samples,
-            generator=rng,
-            output_type='latent',
-            guidance_scale=cfg,
-            cross_attention_kwargs={'concat_conds': concat_conds},
-        ).images.to(vae.dtype) / vae.config.scaling_factor
-    else:
-        bg = resize_and_center_crop(input_bg, image_width, image_height)
-        bg_latent = numpy2pytorch([bg]).to(device=vae.device, dtype=vae.dtype)
-        bg_latent = vae.encode(bg_latent).latent_dist.mode() * vae.config.scaling_factor
-        latents = i2i_pipe(
-            image=bg_latent,
-            strength=lowres_denoise,
-            prompt_embeds=conds,
-            negative_prompt_embeds=unconds,
-            width=image_width,
-            height=image_height,
-            num_inference_steps=int(round(steps / lowres_denoise)),
-            num_images_per_prompt=num_samples,
-            generator=rng,
-            output_type='latent',
-            guidance_scale=cfg,
-            cross_attention_kwargs={'concat_conds': concat_conds},
-        ).images.to(vae.dtype) / vae.config.scaling_factor
-
-    pixels = vae.decode(latents).sample
-    pixels = pytorch2numpy(pixels)
-    pixels = [resize_without_crop(
-        image=p,
-        target_width=int(round(image_width * highres_scale / 64.0) * 64),
-        target_height=int(round(image_height * highres_scale / 64.0) * 64))
-    for p in pixels]
-
-    pixels = numpy2pytorch(pixels).to(device=vae.device, dtype=vae.dtype)
-    latents = vae.encode(pixels).latent_dist.mode() * vae.config.scaling_factor
-    latents = latents.to(device=unet.device, dtype=unet.dtype)
-
-    image_height, image_width = latents.shape[2] * 8, latents.shape[3] * 8
-
-    fg = resize_and_center_crop(input_fg, image_width, image_height)
-    concat_conds = numpy2pytorch([fg]).to(device=vae.device, dtype=vae.dtype)
-    concat_conds = vae.encode(concat_conds).latent_dist.mode() * vae.config.scaling_factor
-
-    latents = i2i_pipe(
-        image=latents,
-        strength=highres_denoise,
-        prompt_embeds=conds,
-        negative_prompt_embeds=unconds,
-        width=image_width,
-        height=image_height,
-        num_inference_steps=int(round(steps / highres_denoise)),
-        num_images_per_prompt=num_samples,
-        generator=rng,
-        output_type='latent',
-        guidance_scale=cfg,
-        cross_attention_kwargs={'concat_conds': concat_conds},
-    ).images.to(vae.dtype) / vae.config.scaling_factor
-
-    pixels = vae.decode(latents).sample
-
-    return pytorch2numpy(pixels)
-
-@spaces.GPU
-@torch.inference_mode()
-def process_relight(input_fg, prompt, bg_source):
-    input_fg, matting = run_rmbg(input_fg)
-    image_width, image_height = input_fg.shape[1], input_fg.shape[0]
-    results = process(input_fg, prompt, bg_source, image_width, image_height)
-
-    # 이미지 저장
-    output_image_path = "/tmp/output_image.png"
-    Image.fromarray(results[0]).save(output_image_path)
-
-    return input_fg, results, output_image_path
-
-# 한국어 텍스트를 Stable Diffusion 프롬프트로 변환
-def korean_to_sd_prompt(korean_text):
-    system_message = "주어진 한국어 텍스트를 Stable Diffusion 프롬프트로 변환하세요. 프롬프트는 주로 사용되는 키워드들로 구성된 형태여야 합니다."
-    response = client.chat_completion(
-        messages=[
-            {"role": "system", "content": system_message},
-            {"role": "user", "content": korean_text}
-        ],
-        max_tokens=100
+            return ""
+    except Exception as e:
+        return ""
+
+def crawl_naver_search_results(url, session):
+    try:
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+            "Accept-Language": "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Connection": "keep-alive",
+            "Referer": "https://search.naver.com/search.naver",
+        }
+        response = session.get(url, headers=headers)
+        if response.status_code != 200:
+            return []
+
+        soup = BeautifulSoup(response.content, "html.parser")
+        results = []
+        count = 0
+        for li in soup.find_all("li", class_=re.compile("bx.*")):
+            if count >= 10:
+                break
+            for div in li.find_all("div", class_="detail_box"):
+                for div2 in div.find_all("div", class_="title_area"):
+                    title = div2.text.strip()
+                    for a in div2.find_all("a", href=True):
+                        link = a["href"]
+                        if "blog.naver" in link:
+                            link = link.replace("https://", "https://m.")
+                            results.append({"제목": title, "링크": link})
+                            count += 1
+                            if count >= 10:
+                                break
+                if count >= 10:
+                    break
+            if count >= 10:
+                break
+        
+        return results
+    except Exception as e:
+        return []
+
+def clean_text(text):
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def create_client(model_name):
+    return InferenceClient(model_name, token=os.getenv("HF_TOKEN"))
+
+client = create_client("CohereForAI/c4ai-command-r-plus")
+
+def call_api(content, system_message, max_tokens, temperature, top_p):
+    messages = [{"role": "system", "content": system_message}, {"role": "user", "content": content}]
+    random_seed = random.randint(0, 1000000)
+    response = client.chat_completion(messages=messages, max_tokens=max_tokens, temperature=temperature, top_p=top_p, seed=random_seed)
+    modified_text = response.choices[0].message.content
+    input_tokens = response.usage.prompt_tokens
+    output_tokens = response.usage.completion_tokens
+    total_tokens = response.usage.total_tokens
+    return modified_text, input_tokens, output_tokens, total_tokens
+
+def analyze_info(category, topic, references1, references2, references3):
+    return f"선택한 카테고리: {category}\n블로그 주제: {topic}\n참고 글1: {references1}\n참고 글2: {references2}\n참고 글3: {references3}"
+
+def suggest_title(category, topic, references1, references2, references3, system_message, max_tokens, temperature, top_p):
+    full_content = analyze_info(category, topic, references1, references2, references3)
+    modified_text, input_tokens, output_tokens, total_tokens = call_api(full_content, system_message, max_tokens, temperature, top_p)
+    token_usage_message = f"[입력 토큰수: {input_tokens}]\n[출력 토큰수: {output_tokens}]\n[총 토큰수: {total_tokens}]"
+    return modified_text, token_usage_message
+
+def generate_outline(category, topic, references1, references2, references3, title, system_message, max_tokens, temperature, top_p):
+    full_content = analyze_info(category, topic, references1, references2, references3)
+    content = f"{full_content}\nTitle: {title}"
+    modified_text, input_tokens, output_tokens, total_tokens = call_api(content, system_message, max_tokens, temperature, top_p)
+    token_usage_message = f"[입력 토큰수: {input_tokens}]\n[출력 토큰수: {output_tokens}]\n[총 토큰수: {total_tokens}]"
+    return modified_text, token_usage_message
+
+def generate_blog_post(category, topic, references1, references2, references3, title, outline, system_message, max_tokens, temperature, top_p):
+    full_content = analyze_info(category, topic, references1, references2, references3)
+    content = f"{full_content}\nTitle: {title}\nOutline: {outline}"
+    modified_text, input_tokens, output_tokens, total_tokens = call_api(content, system_message, max_tokens, temperature, top_p)
+    formatted_text = modified_text.replace('\n', '\n\n')
+    token_usage_message = f"[입력 토큰수: {input_tokens}]\n[출력 토큰수: {output_tokens}]\n[총 토큰수: {total_tokens}]"
+    return formatted_text, token_usage_message
+
+def fetch_references(topic):
+    search_url = generate_naver_search_url(topic)
+    session = setup_session()
+    if session is None:
+        return "Failed to set up session.", "", "", ""
+    results = crawl_naver_search_results(search_url, session)
+    if not results:
+        return "No results found.", "", "", ""
+    
+    selected_results = random.sample(results, 3)
+    references1_content = f"제목: {selected_results[0]['제목']}\n내용: {crawl_blog_content(selected_results[0]['링크'], session)}"
+    references2_content = f"제목: {selected_results[1]['제목']}\n내용: {crawl_blog_content(selected_results[1]['링크'], session)}"
+    references3_content = f"제목: {selected_results[2]['제목']}\n내용: {crawl_blog_content(selected_results[2]['링크'], session)}"
+    
+    return "참고글 생성 완료", references1_content, references2_content, references3_content
+
+def fetch_references_and_generate_all_steps(category, topic, blog_title, system_message_outline, max_tokens_outline, temperature_outline, top_p_outline, system_message_blog_post, max_tokens_blog_post, temperature_blog_post, top_p_blog_post):
+    search_url = generate_naver_search_url(topic)
+    session = setup_session()
+    if session is None:
+        return "", "", "", "", "", "", "", "", "", ""
+    
+    results = crawl_naver_search_results(search_url, session)
+    if not results:
+        return "", "", "", "", "", "", "", "", "", ""
+    
+    selected_results = random.sample(results, 3)
+    references1_content = f"제목: {selected_results[0]['제목']}\n내용: {crawl_blog_content(selected_results[0]['링크'], session)}"
+    references2_content = f"제목: {selected_results[1]['제목']}\n내용: {crawl_blog_content(selected_results[1]['링크'], session)}"
+    references3_content = f"제목: {selected_results[2]['제목']}\n내용: {crawl_blog_content(selected_results[2]['링크'], session)}"
+    
+    # 아웃라인 생성
+    outline_result, outline_token_usage = generate_outline(category, topic, references1_content, references2_content, references3_content, blog_title, system_message_outline, max_tokens_outline, temperature_outline, top_p_outline)
+    
+    # 블로그 글 생성
+    blog_post_result, blog_post_token_usage = generate_blog_post(category, topic, references1_content, references2_content, references3_content, blog_title, outline_result, system_message_blog_post, max_tokens_blog_post, temperature_blog_post, top_p_blog_post)
+    
+    return references1_content, references2_content, references3_content, outline_result, outline_token_usage, blog_post_result, blog_post_token_usage
+
+def get_title_prompt(category):
+    if (category == "일반"):
+        return """
+# 블로그 제목 생성 규칙(일반)
+"""
+    elif (category == "건강정보"):
+        return """
+# 블로그 제목 생성 규칙(건강정보)
+"""
+
+def get_outline_prompt(category):
+    if (category == "일반"):
+        return """
+# 블로그 소주제(Subtopic) 생성 규칙(일반)
+"""
+    elif (category == "건강정보"):
+        return """
+# 블로그 소주제(Subtopic) 생성 규칙(건강정보)
+"""
+
+def get_blog_post_prompt(category):
+    if (category == "일반"):
+        return """
+# 블로그 텍스트 생성 규칙(일반)
+"""
+    elif (category == "건강정보"):
+        return """
+# 블로그 텍스트 생성 규칙(건강정보)
+"""
+
+# Gradio 인터페이스 구성
+title = "정보성 포스팅 자동생성기(제목추천 후 자동)"
+
+def update_prompts(category):
+    title_prompt = get_title_prompt(category)
+    outline_prompt = get_outline_prompt(category)
+    blog_post_prompt = get_blog_post_prompt(category)
+    return title_prompt, outline_prompt, blog_post_prompt
+
+with gr.Blocks() as demo:
+    gr.Markdown(f"# {title}")
+    
+    # 1단계
+    gr.Markdown("### 1단계 : 포스팅 카테고리를 지정해주세요")
+    category = gr.Radio(choices=["일반", "건강정보"], label="포스팅 카테고리", value="일반")
+    
+    # 2단계
+    gr.Markdown("### 2단계 : 블로그 주제, 또는 키워드를 상세히 입력하세요")
+    topic = gr.Textbox(label="블로그 주제(예시: 오징어 무침회(X), 오징어 무침회 레시피(O))", placeholder="예시: 여행지 추천(X), 8월 국내 여행지 추천(O)")
+
+    # 3단계: 참고 글을 위한 변수들 미리 정의
+    references1 = gr.Textbox(label="참고 글 1", placeholder="참고할 블로그 포스팅글을 복사하여 붙여넣으세요", lines=10, visible=False)
+    references2 = gr.Textbox(label="참고 글 2", placeholder="참고할 블로그 포스팅글을 복사하여 붙여넣으세요", lines=10, visible=False)
+    references3 = gr.Textbox(label="참고 글 3", placeholder="참고할 블로그 포스팅글을 복사하여 붙여넣으세요", lines=10, visible=False)
+
+    # 제목 추천
+    gr.Markdown("### 4단계 : 제목 추천하기")
+    
+    with gr.Accordion("제목 설정", open=True):
+        title_system_message = gr.Textbox(label="시스템 메시지", value=get_title_prompt("일반"), lines=15)
+        title_max_tokens = gr.Slider(label="Max Tokens", minimum=1000, maximum=8000, value=5000, step=1000)
+        title_temperature = gr.Slider(label="Temperature", minimum=0.1, maximum=1.0, value=0.8, step=0.1)
+        title_top_p = gr.Slider(label="Top P", minimum=0.1, maximum=1.0, value=0.95, step=0.05)
+
+    title_suggestions = gr.Textbox(label="제목 추천", lines=10)
+    title_token_output = gr.Markdown(label="사용된 토큰 수")
+
+    # 제목 추천 버튼
+    title_btn = gr.Button("제목 추천하기")
+    title_btn.click(fn=suggest_title, inputs=[category, topic, references1, references2, references3, title_system_message, title_max_tokens, title_temperature, title_top_p], outputs=[title_suggestions, title_token_output])
+    
+    blog_title = gr.Textbox(label="블로그 제목", placeholder="블로그 제목을 입력해주세요")
+    
+    # 블로그 글 생성
+    gr.Markdown("### 5단계 : 블로그 글 생성하기")
+    gr.HTML("<span style='color: grey;'>[블로그 글 생성하기 버튼을 클릭하면 아웃라인 생성 및 블로그 글 작성이 자동으로 진행됩니다.]</span>")
+    
+    with gr.Accordion("블로그 글 설정", open=True):
+        outline_system_message = gr.Textbox(label="시스템 메시지", value=get_outline_prompt("일반"), lines=20)
+        outline_max_tokens = gr.Slider(label="Max Tokens", minimum=1000, maximum=8000, value=6000, step=1000)
+        outline_temperature = gr.Slider(label="Temperature", minimum=0.1, maximum=1.0, value=0.8, step=0.1)
+        outline_top_p = gr.Slider(label="Top P", minimum=0.1, maximum=1.0, value=0.95, step=0.05)
+        
+        blog_system_message = gr.Textbox(label="시스템 메시지", value=get_blog_post_prompt("일반"), lines=20)
+        blog_max_tokens = gr.Slider(label="Max Tokens", minimum=1000, maximum=12000, value=8000, step=1000)
+        blog_temperature = gr.Slider(label="Temperature", minimum=0.1, maximum=1.0, value=0.8, step=0.1)
+        blog_top_p = gr.Slider(label="Top P", minimum=0.1, maximum=1.0, value=0.95, step=0.05)
+
+    outline_result = gr.Textbox(label="아웃라인 결과", lines=15, visible=False)
+    outline_token_output = gr.Markdown(label="사용된 토큰 수", visible=False)
+    output = gr.Textbox(label="생성된 블로그 글", lines=30)
+    token_output = gr.Markdown(label="사용된 토큰 수")
+
+    # 블로그 글 생성 버튼
+    generate_post_btn = gr.Button("블로그 글 생성하기")
+    generate_post_btn.click(
+        fn=fetch_references_and_generate_all_steps,
+        inputs=[category, topic, blog_title, outline_system_message, outline_max_tokens, outline_temperature, outline_top_p, blog_system_message, blog_max_tokens, blog_temperature, blog_top_p],
+        outputs=[references1, references2, references3, outline_result, outline_token_output, output, token_output]
     )
-    return response.choices[0].message.content.strip()
-
-quick_prompts = [
-    'sunshine from window',
-    'neon light, city',
-    'sunset over sea',
-    'golden time',
-    'sci-fi RGB glowing, cyberpunk',
-    'natural lighting',
-    'warm atmosphere, at home, bedroom',
-    'magic lit',
-    'evil, gothic, Yharnam',
-    'light and shadow',
-    'shadow from window',
-    'soft studio lighting',
-    'home atmosphere, cozy bedroom illumination',
-    'neon, Wong Kar-wai, warm'
-]
-quick_prompts = [[x] for x in quick_prompts]
-
-quick_subjects = [
-    'beautiful woman, detailed face',
-    'handsome man, detailed face',
-]
-quick_subjects = [[x] for x in quick_subjects]
-
-class BGSource(Enum):
-    NONE = "None"
-    LEFT = "Left Light"
-    RIGHT = "Right Light"
-    TOP = "Top Light"
-    BOTTOM = "Bottom Light"
-
-block = gr.Blocks().queue()
-with block:
-    with gr.Row():
-        gr.Markdown("## IC-Light (Relighting with Foreground Condition)")
-    with gr.Row():
-        gr.Markdown("See also https://github.com/lllyasviel/IC-Light for background-conditioned model and normal estimation")
-    with gr.Row():
-        with gr.Column():
-            with gr.Row():
-                input_fg = gr.Image(sources='upload', type="numpy", label="Image", height=480)
-                output_bg = gr.Image(type="numpy", label="Preprocessed Foreground", height=480, visible=False)  # UI에서 보이지 않도록 설정
-            prompt = gr.Textbox(label="Prompt")
-            bg_source = gr.Radio(choices=[e.value for e in BGSource],
-                                 value=BGSource.NONE.value,
-                                 label="Lighting Preference (Initial Latent)", type='value')
-            example_quick_subjects = gr.Dataset(samples=quick_subjects, label='Subject Quick List', samples_per_page=1000, components=[prompt])
-            example_quick_prompts = gr.Dataset(samples=quick_prompts, label='Lighting Quick List', samples_per_page=1000, components=[prompt])
-            relight_button = gr.Button(value="Relight")
-
-        with gr.Column():
-            result_gallery = gr.Gallery(height=832, object_fit='contain', label='Outputs')
-            download_button = gr.File(label="Download Processed Image")
 
-    ips = [input_fg, prompt, bg_source]
-    relight_button.click(fn=process_relight, inputs=ips, outputs=[output_bg, result_gallery, download_button])
-    example_quick_prompts.click(lambda x, y: ', '.join(y.split(', ')[:2] + [x[0]]), inputs=[example_quick_prompts, prompt], outputs=prompt, show_progress=False, queue=False)
-    example_quick_subjects.click(lambda x: x[0], inputs=example_quick_subjects, outputs=prompt, show_progress=False, queue=False)
+    category.change(fn=update_prompts, inputs=category, outputs=[title_system_message, outline_system_message, blog_system_message])
 
-block.launch(server_name='0.0.0.0')
+demo.launch()