Update app.py

app.py

@@ -2,44 +2,57 @@ import gradio as gr
 import torch
 import random
 import os
-import time
+import io
 from PIL import Image
 from deep_translator import GoogleTranslator
 from diffusers import DiffusionPipeline
-from huggingface_hub import hf_hub_download
+from huggingface_hub import hf_hub_download, login
 
-# Project by Nymbo with LoRA integration
+# Autentikasi Hugging Face
+HF_TOKEN = os.getenv("HF_READ_TOKEN")  # Ganti dengan token Anda atau set env variable
+login(token=HF_TOKEN)
 
-# Model and LoRA configuration
+# Konfigurasi Model
 BASE_MODEL = "black-forest-labs/FLUX.1-dev"
 LORA_REPO = "burhansyam/uncen"
-LORA_WEIGHTS_NAME = "uncen.safetensors"  # Adjust if different
-torch_dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+LORA_WEIGHTS_NAME = "uncen.safetensors"  # Ganti jika nama file berbeda
+torch_dtype = torch.float16  # Gunakan float16 untuk kompatibilitas lebih luas
 
-# Initialize the pipeline with LoRA
+# Inisialisasi Pipeline dengan LoRA
 def init_pipeline():
+    # Muat model dasar
     pipe = DiffusionPipeline.from_pretrained(
         BASE_MODEL,
-        torch_dtype=torch_dtype
+        torch_dtype=torch_dtype,
+        use_auth_token=HF_TOKEN
     )
     
-    # Load LoRA weights
-    pipe.load_lora_weights(
-        hf_hub_download(repo_id=LORA_REPO, filename=LORA_WEIGHTS_NAME),
-        adapter_name="uncen"
+    # Muat weights LoRA
+    lora_path = hf_hub_download(
+        repo_id=LORA_REPO,
+        filename=LORA_WEIGHTS_NAME,
+        token=HF_TOKEN
     )
+    pipe.load_lora_weights(lora_path, adapter_name="uncen")
     
-    # Enable model offloading if needed
+    # Optimasi GPU jika tersedia
     if torch.cuda.is_available():
         pipe.to("cuda")
-        pipe.enable_xformers_memory_efficient_attention()
+        try:
+            pipe.enable_xformers_memory_efficient_attention()
+        except:
+            print("Xformers tidak tersedia, melanjutkan tanpa optimasi")
     
     return pipe
 
-pipe = init_pipeline()
+# Inisialisasi pipeline
+try:
+    pipe = init_pipeline()
+except Exception as e:
+    raise gr.Error(f"Gagal memuat model: {str(e)}. Pastikan token akses valid dan Anda memiliki izin.")
 
 def convert_to_png(image):
-    """Convert any image format to true PNG format"""
+    """Konversi gambar ke format PNG"""
     png_buffer = io.BytesIO()
     if image.mode == 'RGBA':
         image.save(png_buffer, format='PNG', optimize=True)
@@ -50,64 +63,64 @@ def convert_to_png(image):
     png_buffer.seek(0)
     return Image.open(png_buffer)
 
-def query(prompt, is_negative=False, steps=35, cfg_scale=7, sampler="DPM++ 2M Karras", 
-          seed=-1, strength=0.7, width=1024, height=1024):
+def generate_image(
+    prompt,
+    negative_prompt="",
+    steps=35,
+    cfg_scale=7,
+    sampler="DPM++ 2M Karras",
+    seed=-1,
+    width=1024,
+    height=1024
+):
     if not prompt:
         return None
 
-    key = random.randint(0, 999)
-    
-    # Translate prompt
+    # Terjemahkan prompt jika bahasa Indonesia
     try:
-        prompt = GoogleTranslator(source='id', target='en').translate(prompt)
-        print(f'\033[1mGeneration {key} translation:\033[0m {prompt}')
-        prompt = f"{prompt} | ultra detail, ultra elaboration, ultra quality, perfect."
-    except Exception as e:
-        print(f"Translation error: {e}")
+        translated_prompt = GoogleTranslator(source='id', target='en').translate(prompt)
+        prompt = f"{translated_prompt} | ultra detail, ultra quality, masterpiece"
+    except:
+        prompt = f"{prompt} | ultra detail, ultra quality, masterpiece"
     
-    print(f'\033[1mGeneration {key}:\033[0m {prompt}')
-    
-    # Set random seed if not specified
-    generator = None
-    if seed != -1:
-        generator = torch.Generator(device="cuda" if torch.cuda.is_available() else "cpu").manual_seed(seed)
-    else:
+    # Set generator dengan seed
+    generator = torch.Generator(device="cuda" if torch.cuda.is_available() else "cpu")
+    if seed == -1:
         seed = random.randint(1, 1000000000)
-        generator = torch.Generator(device="cuda" if torch.cuda.is_available() else "cpu").manual_seed(seed)
+    generator.manual_seed(seed)
     
-    # Map sampler names to Diffusers scheduler names
-    sampler_map = {
-        "DPM++ 2M Karras": "dpmsolver++",
-        "DPM++ SDE Karras": "dpmsolver++",
-        "Euler": "euler",
-        "Euler a": "euler_a",
-        "Heun": "heun",
-        "DDIM": "ddim"
+    # Pemetaan sampler ke scheduler
+    sampler_config = {
+        "DPM++ 2M Karras": {"use_karras_sigmas": True},
+        "DPM++ SDE Karras": {"use_karras_sigmas": True},
+        "Euler": {},
+        "Euler a": {"use_karras_sigmas": False},
+        "Heun": {},
+        "DDIM": {}
     }
     
     try:
-        # Generate image with LoRA
-        image = pipe(
+        # Generate gambar dengan LoRA
+        result = pipe(
             prompt=prompt,
-            negative_prompt=is_negative if is_negative else None,
+            negative_prompt=negative_prompt,
             num_inference_steps=steps,
             guidance_scale=cfg_scale,
-            generator=generator,
-            strength=strength,
             width=width,
             height=height,
-            cross_attention_kwargs={"scale": 0.8},  # LoRA strength adjustment
-        ).images[0]
+            generator=generator,
+            cross_attention_kwargs={"scale": 1.0},  # Kontrol kekuatan LoRA
+            **sampler_config[sampler]
+        )
         
-        png_img = convert_to_png(image)
-        print(f'\033[1mGeneration {key} completed as PNG!\033[0m')
+        # Konversi ke PNG
+        png_img = convert_to_png(result.images[0])
         return png_img
         
     except Exception as e:
-        print(f"Generation error: {e}")
-        raise gr.Error(f"Image generation failed: {str(e)}")
+        raise gr.Error(f"Generasi gambar gagal: {str(e)}")
 
-# Light theme CSS (same as before)
+# Antarmuka Gradio
 css = """
 #app-container {
     max-width: 800px;
@@ -139,7 +152,7 @@ h1 {
 """
 
 with gr.Blocks(theme=gr.themes.Default(primary_hue="green"), css=css) as app:
-    gr.HTML("<center><h1>FLUX.1-Dev with LoRA (PNG Output)</h1></center>")
+    gr.HTML("<center><h1>FLUX.1-Dev with Uncensored LoRA</h1></center>")
     
     with gr.Column(elem_id="app-container"):
         with gr.Row():
@@ -165,7 +178,6 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green"), css=css) as app:
                         steps = gr.Slider(35, label="Steps", minimum=10, maximum=100, step=1)
                         cfg = gr.Slider(7.0, label="CFG Scale", minimum=1.0, maximum=20.0, step=0.5)
                     with gr.Row():
-                        strength = gr.Slider(0.7, label="Strength", minimum=0.1, maximum=1.0, step=0.01)
                         seed = gr.Number(-1, label="Seed (-1 for random)")
                     method = gr.Radio(
                         ["DPM++ 2M Karras", "DPM++ SDE Karras", "Euler", "Euler a", "Heun", "DDIM"],
@@ -184,8 +196,8 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="green"), css=css) as app:
             )
         
         generate_btn.click(
-            fn=query,
-            inputs=[text_prompt, negative_prompt, steps, cfg, method, seed, strength, width, height],
+            fn=generate_image,
+            inputs=[text_prompt, negative_prompt, steps, cfg, method, seed, width, height],
             outputs=output_image
         )