Flux_lora

README.md

@@ -1,14 +1,14 @@
 ---
-title: FLUX.Dev LoRA
-emoji: 💻
-colorFrom: blue
-colorTo: blue
+title: FLUX.Dev LORA Serverless
+emoji: 🔥
+colorFrom: pink
+colorTo: purple
 sdk: gradio
-sdk_version: 5.23.1
+sdk_version: 4.43.0
 app_file: app.py
 pinned: true
 license: mit
-short_description: FLUX.1-Dev Text to Image with LoRA
+short_description: FLUX.1-Dev on serverless inference, no GPU required
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,143 +1,111 @@
 import gradio as gr
-import numpy as np
+import requests
+import io
 import random
-import spaces
-import torch
-from diffusers import  DiffusionPipeline, FlowMatchEulerDiscreteScheduler, AutoencoderTiny, AutoencoderKL
-from transformers import CLIPTextModel, CLIPTokenizer,T5EncoderModel, T5TokenizerFast
-from live_preview_helpers import calculate_shift, retrieve_timesteps, flux_pipe_call_that_returns_an_iterable_of_images
+import os
+import time
+from PIL import Image
+from deep_translator import GoogleTranslator
+import json
 
-dtype = torch.bfloat16
-device = "cuda" if torch.cuda.is_available() else "cpu"
 
-taef1 = AutoencoderTiny.from_pretrained("madebyollin/taef1", torch_dtype=dtype).to(device)
-good_vae = AutoencoderKL.from_pretrained("black-forest-labs/FLUX.1-dev", subfolder="vae", torch_dtype=dtype).to(device)
-pipe = DiffusionPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", torch_dtype=dtype, vae=taef1).to(device)
-torch.cuda.empty_cache()
+API_TOKEN = os.getenv("HF_READ_TOKEN")
+headers = {"Authorization": f"Bearer {API_TOKEN}"}
+timeout = 100
 
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 2048
+def query(lora_id, prompt, is_negative=False, steps=28, cfg_scale=3.5, sampler="DPM++ 2M Karras", seed=-1, strength=0.7):
+    if prompt == "" or prompt == None:
+        return None
 
-pipe.flux_pipe_call_that_returns_an_iterable_of_images = flux_pipe_call_that_returns_an_iterable_of_images.__get__(pipe)
+    if lora_id.strip() == "" or lora_id == None:
+        lora_id = "black-forest-labs/FLUX.1-dev" 
 
-@spaces.GPU()
-def infer(prompt, seed=42, randomize_seed=False, width=1024, height=1024, guidance_scale=3.5, num_inference_steps=28, lora_id=None, lora_scale=0.95, progress=gr.Progress(track_tqdm=True)):
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-    generator = torch.Generator().manual_seed(seed)
+    key = random.randint(0, 999)
 
+    API_URL = "https://api-inference.huggingface.co/models/"+ lora_id.strip()
     
-    # for img in pipe.flux_pipe_call_that_returns_an_iterable_of_images(
-    #         prompt=prompt,
-    #         guidance_scale=guidance_scale,
-    #         num_inference_steps=num_inference_steps,
-    #         width=width,
-    #         height=height,
-    #         generator=generator,
-    #         output_type="pil",
-    #         good_vae=good_vae,
-    #     ):
-    #         yield img, seed
-
-    # Handle LoRA loading
-    # Load LoRA weights and prepare joint_attention_kwargs
-    if lora_id and lora_id.strip() != "":
-        pipe.unload_lora_weights()
-        pipe.load_lora_weights(lora_id.strip())
-        joint_attention_kwargs = {"scale": lora_scale}
-    else:
-        joint_attention_kwargs = None
+    API_TOKEN = random.choice([os.getenv("HF_READ_TOKEN")])
+    headers = {"Authorization": f"Bearer {API_TOKEN}"}
     
-    try:
-        # Call the custom pipeline function with the correct keyword argument
-        for img in pipe.flux_pipe_call_that_returns_an_iterable_of_images(
-            prompt=prompt,
-            guidance_scale=guidance_scale,
-            num_inference_steps=num_inference_steps,
-            width=width,
-            height=height,
-            generator=generator,
-            output_type="pil",
-            good_vae=good_vae,  # Assuming good_vae is defined elsewhere
-            joint_attention_kwargs=joint_attention_kwargs,  # Fixed parameter name
-        ):
-            yield img, seed
-    finally:
-        # Unload LoRA weights if they were loaded
-        if lora_id:
-            pipe.unload_lora_weights()
+    prompt = GoogleTranslator(source='ru', target='en').translate(prompt)
+    print(f'\033[1mGeneration {key} translation:\033[0m {prompt}')
+
+    prompt = f"{prompt} | ultra detail, ultra elaboration, ultra quality, perfect."
+    print(f'\033[1mGeneration {key}:\033[0m {prompt}')
+
+    # If seed is -1, generate a random seed and use it
+    if seed == -1:
+        seed = random.randint(1, 1000000000)
+    
+    payload = {
+        "inputs": prompt,
+        "steps": steps,
+        "cfg_scale": cfg_scale,
+        "seed": seed,
+    }
+
+    response = requests.post(API_URL, headers=headers, json=payload, timeout=timeout)
+    if response.status_code != 200:
+        print(f"Error: Failed to get image. Response status: {response.status_code}")
+        print(f"Response content: {response.text}")
+        if response.status_code == 503:
+            raise gr.Error(f"{response.status_code} : The model is being loaded")
+        raise gr.Error(f"{response.status_code}")
     
+    try:
+        image_bytes = response.content
+        image = Image.open(io.BytesIO(image_bytes))
+        print(f'\033[1mGeneration {key} completed!\033[0m ({prompt})')
+        return image, seed
+    except Exception as e:
+        print(f"Error when trying to open the image: {e}")
+        return None
+
+
 examples = [
     "a tiny astronaut hatching from an egg on the moon",
     "a cat holding a sign that says hello world",
     "an anime illustration of a wiener schnitzel",
 ]
-    
+
 css = """
-#col-container {
-   margin: 0 auto;
-   max-width: 960px;
-}
-.generate-btn {
-   background: linear-gradient(90deg, #4B79A1 0%, #283E51 100%) !important;
-   border: none !important;
-   color: white !important;
-}
-.generate-btn:hover {
-   transform: translateY(-2px);
-   box-shadow: 0 5px 15px rgba(0,0,0,0.2);
+#app-container {
+    max-width: 600px;
+    margin-left: auto;
+    margin-right: auto;
 }
 """
 
-with gr.Blocks(css=css) as app:
+with gr.Blocks(theme='Nymbo/Nymbo_Theme', css=css) as app:
     gr.HTML("<center><h1>FLUX.1-Dev with LoRA support</h1></center>")
-    with gr.Column(elem_id="col-container"):
+    with gr.Column(elem_id="app-container"):
         with gr.Row():
-            with gr.Column():
+            with gr.Column(elem_id="prompt-container"):
                 with gr.Row():
-                    text_prompt = gr.Textbox(label="Prompt", placeholder="Enter a prompt here", lines=3, elem_id="prompt-text-input")
+                    text_prompt = gr.Textbox(label="Prompt", placeholder="Enter a prompt here", lines=2, elem_id="prompt-text-input")
                 with gr.Row():
                     custom_lora = gr.Textbox(label="Custom LoRA", info="LoRA Hugging Face path (optional)", placeholder="multimodalart/vintage-ads-flux")
                 with gr.Row():
                     with gr.Accordion("Advanced Settings", open=False):
-                        lora_scale = gr.Slider(
-                            label="LoRA Scale",
-                            minimum=0,
-                            maximum=2,
-                            step=0.01,
-                            value=0.95,
-                        )
-                        with gr.Row():
-                            width = gr.Slider(label="Width", value=1024, minimum=64, maximum=2048, step=8)
-                            height = gr.Slider(label="Height", value=1024, minimum=64, maximum=2048, step=8)
-                        seed = gr.Slider(label="Seed", value=-1, minimum=-1, maximum=4294967296, step=1)
-                        randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-                        with gr.Row():
-                            steps = gr.Slider(label="Inference steps steps", value=28, minimum=1, maximum=100, step=1)
-                            cfg = gr.Slider(label="Guidance Scale", value=3.5, minimum=1, maximum=20, step=0.5)
-                        # method = gr.Radio(label="Sampling method", value="DPM++ 2M Karras", choices=["DPM++ 2M Karras", "DPM++ SDE Karras", "Euler", "Euler a", "Heun", "DDIM"])
+                        negative_prompt = gr.Textbox(label="Negative Prompt", placeholder="What should not be in the image", value="(deformed, distorted, disfigured), poorly drawn, bad anatomy, wrong anatomy, extra limb, missing limb, floating limbs, (mutated hands and fingers), disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation, misspellings, typos", lines=3, elem_id="negative-prompt-text-input")
+                        steps = gr.Slider(label="Sampling steps", value=28, minimum=1, maximum=100, step=1)
+                        cfg = gr.Slider(label="CFG Scale", value=3.5, minimum=1, maximum=20, step=0.5)
+                        method = gr.Radio(label="Sampling method", value="DPM++ 2M Karras", choices=["DPM++ 2M Karras", "DPM++ SDE Karras", "Euler", "Euler a", "Heun", "DDIM"])
+                        strength = gr.Slider(label="Strength", value=0.7, minimum=0, maximum=1, step=0.001)
+                        seed = gr.Slider(label="Seed", value=-1, minimum=-1, maximum=1000000000, step=1)
 
-                with gr.Row():
-                    # text_button = gr.Button("Run", variant='primary', elem_id="gen-button")
-                    text_button = gr.Button("✨ Generate Image", variant='primary', elem_classes=["generate-btn"])
-            with gr.Column():
-                with gr.Row():
-                    image_output = gr.Image(type="pil", label="Image Output", elem_id="gallery")
-        
-        # gr.Markdown(article_text)
-        with gr.Column():
-            gr.Examples(
-                examples = examples,
-                inputs = [text_prompt],
-            )
-    gr.on(
-        triggers=[text_button.click, text_prompt.submit],
-        fn = infer,
-        inputs=[text_prompt, seed, randomize_seed, width, height, cfg, steps, custom_lora, lora_scale], 
-        outputs=[image_output, seed]
-    )
+        with gr.Row():
+            text_button = gr.Button("Run", variant='primary', elem_id="gen-button")
+        with gr.Row():
+            image_output = gr.Image(type="pil", label="Image Output", elem_id="gallery")
+        with gr.Row():
+            seed_output = gr.Textbox(label="Seed Used", show_copy_button = True, elem_id="seed-output")
+
+        gr.Examples(
+            examples = examples,
+            inputs = [text_prompt],
+        )
         
-        # text_button.click(query, inputs=[custom_lora, text_prompt, steps, cfg, randomize_seed, seed, width, height], outputs=[image_output,seed_output, seed])
-        # text_button.click(infer, inputs=[text_prompt, seed, randomize_seed, width, height, cfg, steps, custom_lora, lora_scale], outputs=[image_output,seed_output, seed])
+        text_button.click(query, inputs=[custom_lora, text_prompt, negative_prompt, steps, cfg, method, seed, strength], outputs=[image_output,seed_output])
 
-app.launch(share=True)
+app.launch(show_api=False, share=False)

live_preview_helpers.py

@@ -1,166 +0,0 @@
-import torch
-import numpy as np
-from diffusers import FluxPipeline, AutoencoderTiny, FlowMatchEulerDiscreteScheduler
-from typing import Any, Dict, List, Optional, Union
-
-# Helper functions
-def calculate_shift(
-    image_seq_len,
-    base_seq_len: int = 256,
-    max_seq_len: int = 4096,
-    base_shift: float = 0.5,
-    max_shift: float = 1.16,
-):
-    m = (max_shift - base_shift) / (max_seq_len - base_seq_len)
-    b = base_shift - m * base_seq_len
-    mu = image_seq_len * m + b
-    return mu
-
-def retrieve_timesteps(
-    scheduler,
-    num_inference_steps: Optional[int] = None,
-    device: Optional[Union[str, torch.device]] = None,
-    timesteps: Optional[List[int]] = None,
-    sigmas: Optional[List[float]] = None,
-    **kwargs,
-):
-    if timesteps is not None and sigmas is not None:
-        raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values")
-    if timesteps is not None:
-        scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs)
-        timesteps = scheduler.timesteps
-        num_inference_steps = len(timesteps)
-    elif sigmas is not None:
-        scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs)
-        timesteps = scheduler.timesteps
-        num_inference_steps = len(timesteps)
-    else:
-        scheduler.set_timesteps(num_inference_steps, device=device, **kwargs)
-        timesteps = scheduler.timesteps
-    return timesteps, num_inference_steps
-
-# FLUX pipeline function
-@torch.inference_mode()
-def flux_pipe_call_that_returns_an_iterable_of_images(
-    self,
-    prompt: Union[str, List[str]] = None,
-    prompt_2: Optional[Union[str, List[str]]] = None,
-    height: Optional[int] = None,
-    width: Optional[int] = None,
-    num_inference_steps: int = 28,
-    timesteps: List[int] = None,
-    guidance_scale: float = 3.5,
-    num_images_per_prompt: Optional[int] = 1,
-    generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-    latents: Optional[torch.FloatTensor] = None,
-    prompt_embeds: Optional[torch.FloatTensor] = None,
-    pooled_prompt_embeds: Optional[torch.FloatTensor] = None,
-    output_type: Optional[str] = "pil",
-    return_dict: bool = True,
-    joint_attention_kwargs: Optional[Dict[str, Any]] = None,
-    max_sequence_length: int = 512,
-    good_vae: Optional[Any] = None,
-):
-    height = height or self.default_sample_size * self.vae_scale_factor
-    width = width or self.default_sample_size * self.vae_scale_factor
-
-    # 1. Check inputs
-    self.check_inputs(
-        prompt,
-        prompt_2,
-        height,
-        width,
-        prompt_embeds=prompt_embeds,
-        pooled_prompt_embeds=pooled_prompt_embeds,
-        max_sequence_length=max_sequence_length,
-    )
-
-    self._guidance_scale = guidance_scale
-    self._joint_attention_kwargs = joint_attention_kwargs
-    self._interrupt = False
-
-    # 2. Define call parameters
-    batch_size = 1 if isinstance(prompt, str) else len(prompt)
-    device = self._execution_device
-
-    # 3. Encode prompt
-    lora_scale = joint_attention_kwargs.get("scale", None) if joint_attention_kwargs is not None else None
-    prompt_embeds, pooled_prompt_embeds, text_ids = self.encode_prompt(
-        prompt=prompt,
-        prompt_2=prompt_2,
-        prompt_embeds=prompt_embeds,
-        pooled_prompt_embeds=pooled_prompt_embeds,
-        device=device,
-        num_images_per_prompt=num_images_per_prompt,
-        max_sequence_length=max_sequence_length,
-        lora_scale=lora_scale,
-    )
-    # 4. Prepare latent variables
-    num_channels_latents = self.transformer.config.in_channels // 4
-    latents, latent_image_ids = self.prepare_latents(
-        batch_size * num_images_per_prompt,
-        num_channels_latents,
-        height,
-        width,
-        prompt_embeds.dtype,
-        device,
-        generator,
-        latents,
-    )
-    # 5. Prepare timesteps
-    sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps)
-    image_seq_len = latents.shape[1]
-    mu = calculate_shift(
-        image_seq_len,
-        self.scheduler.config.base_image_seq_len,
-        self.scheduler.config.max_image_seq_len,
-        self.scheduler.config.base_shift,
-        self.scheduler.config.max_shift,
-    )
-    timesteps, num_inference_steps = retrieve_timesteps(
-        self.scheduler,
-        num_inference_steps,
-        device,
-        timesteps,
-        sigmas,
-        mu=mu,
-    )
-    self._num_timesteps = len(timesteps)
-
-    # Handle guidance
-    guidance = torch.full([1], guidance_scale, device=device, dtype=torch.float32).expand(latents.shape[0]) if self.transformer.config.guidance_embeds else None
-
-    # 6. Denoising loop
-    for i, t in enumerate(timesteps):
-        if self.interrupt:
-            continue
-
-        timestep = t.expand(latents.shape[0]).to(latents.dtype)
-
-        noise_pred = self.transformer(
-            hidden_states=latents,
-            timestep=timestep / 1000,
-            guidance=guidance,
-            pooled_projections=pooled_prompt_embeds,
-            encoder_hidden_states=prompt_embeds,
-            txt_ids=text_ids,
-            img_ids=latent_image_ids,
-            joint_attention_kwargs=self.joint_attention_kwargs,
-            return_dict=False,
-        )[0]
-        # Yield intermediate result
-        latents_for_image = self._unpack_latents(latents, height, width, self.vae_scale_factor)
-        latents_for_image = (latents_for_image / self.vae.config.scaling_factor) + self.vae.config.shift_factor
-        image = self.vae.decode(latents_for_image, return_dict=False)[0]
-        yield self.image_processor.postprocess(image, output_type=output_type)[0]
-        
-        latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0]
-        torch.cuda.empty_cache()
-
-    # Final image using good_vae
-    latents = self._unpack_latents(latents, height, width, self.vae_scale_factor)
-    latents = (latents / good_vae.config.scaling_factor) + good_vae.config.shift_factor
-    image = good_vae.decode(latents, return_dict=False)[0]
-    self.maybe_free_model_hooks()
-    torch.cuda.empty_cache()
-    yield self.image_processor.postprocess(image, output_type=output_type)[0]

requirements.txt

@@ -1,7 +1,4 @@
-accelerate
-git+https://github.com/huggingface/diffusers.git
-torch
-transformers==4.48.3
-xformers
-sentencepiece
-git+https://github.com/huggingface/peft.git
+requests
+pillow
+deep-translator
+langdetect