Build

app.py

@@ -0,0 +1,82 @@
+import gradio as gr
+import numpy as np
+from options import Banner, Video
+from huggingface_hub import login
+import os
+login(token=os.getenv("TOKEN"))
+
+MAX_SEED = np.iinfo(np.int32).max
+MAX_IMAGE_SIZE = 2048
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Create your own Advertisement")
+    with gr.Tab("Banner"):
+        gr.Markdown("# Take your banner to the next LEVEL!")
+        with gr.TabItem("Create your Banner"):
+            textInput = gr.Textbox(label="Enter the text to get a good start")
+            with gr.Accordion("Advanced Settings", open=False):
+                with gr.Row():
+                    width = gr.Slider(
+                        label="Width",
+                        minimum=256,
+                        maximum=MAX_IMAGE_SIZE,
+                        step=8,
+                        value=1024,
+                    )
+
+                    height = gr.Slider(
+                        label="Height",
+                        minimum=256,
+                        maximum=MAX_IMAGE_SIZE,
+                        step=32,
+                        value=1024,
+                    )
+
+                guidance_scale = gr.Slider(
+                    label="Guidance Scale",
+                    minimum=1,
+                    maximum=15,
+                    step=0.1,
+                    value=3.5,
+                )
+
+                num_inference_steps = gr.Slider(
+                    label="Number of Inference Steps",
+                    minimum=1,
+                    maximum=50,
+                    step=1,
+                    value=28,
+                )
+
+            submit = gr.Button("Submit")
+            submit.click(
+                fn=Banner.TextImage,
+                inputs=[textInput, width, height, guidance_scale, num_inference_steps],
+                outputs=gr.Image()
+            )
+
+        with gr.TabItem("Edit your Banner"):
+            img = gr.ImageMask(sources=["upload"], layers=False, transforms=[], format="png", label="base image",
+                               show_label=True)
+            prompt = gr.Textbox(label="Enter the text to get a good start")
+            out_img=gr.Image()
+            btn = gr.Button()
+            btn.click(Banner.Image2Image, [prompt,img], out_img)
+
+        with gr.TabItem("Upgrade your Banner"):
+            img = gr.Image()
+            prompt = gr.Textbox(label="Enter the text to get a good start")
+            btn = gr.Button()
+            size = gr.Slider(label="Size", minimum=256, maximum=MAX_IMAGE_SIZE, step=8, value=1024)
+            out_img = gr.Image()
+            btn.click(Banner.Image2Image_2, [prompt, img,size,num_inference_steps], out_img)
+
+
+    with gr.Tab("Video"):
+        gr.Markdown("# Create your own Video")
+        img=gr.Image()
+        btn = gr.Button()
+        video=gr.Video()
+        btn.click(Video.Video, img, video)
+
+demo.launch()

options/Banner.py

@@ -0,0 +1,15 @@
+import torch
+from options.Banner_Model.Text2Banner import T2I
+from options.Banner_Model.Image2Image import I2I
+from options.Banner_Model.Image2Image_2 import I2I_2
+
+def TextImage(prompt, width=1024, height=1024, guidance_scale=3.5,
+              num_inference_steps=28):
+    img = T2I(prompt, width, height, guidance_scale, num_inference_steps)
+    return img
+
+def Image2Image(prompt,image, width=1024, height=1024, guidance_scale=3.5,num_inference_steps=28,strength=0.99):
+    return I2I(prompt, image, width, height, guidance_scale, num_inference_steps, strength)
+
+def Image2Image_2(prompt,image,size,num_inference_steps=30):
+    return I2I_2(image, prompt,size,num_inference_steps)

options/Banner_Model/Image2Image.py

@@ -0,0 +1,53 @@
+import imageio
+import numpy as np
+from PIL import Image
+from diffusers import AutoPipelineForInpainting
+import torch
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Using device for I2I: {device}")
+
+# Load the inpainting pipeline
+pipe = AutoPipelineForInpainting.from_pretrained(
+    "diffusers/stable-diffusion-xl-1.0-inpainting-0.1",
+    torch_dtype=torch.float16, variant="fp16").to(device)
+
+
+def resize_image(image, height, width):
+    """Resize image tensor to the desired height and width."""
+    return torch.nn.functional.interpolate(image, size=(height, width), mode='nearest')
+
+
+def dummy(img):
+    """Save the composite image and generate a mask from the alpha channel."""
+    imageio.imwrite("output_image.png", img["composite"])
+
+    # Extract alpha channel from the first layer to create the mask
+    alpha_channel = img["layers"][0][:, :, 3]
+    mask = np.where(alpha_channel == 0, 0, 255).astype(np.uint8)
+
+    return img["background"], mask
+
+
+def I2I(prompt, image, width=1024, height=1024, guidance_scale=8.0, num_inference_steps=20, strength=0.99):
+    img_url, mask = dummy(image)
+
+    # Resize image and mask to the target dimensions (height x width)
+    img_url = Image.fromarray(img_url, mode="RGB").resize((width, height))
+    mask_url = Image.fromarray(mask,mode="L").resize((width, height))
+
+    # Make sure both image and mask are converted into correct tensors
+    generator = torch.Generator(device=device).manual_seed(0)
+
+    # Generate the inpainted image
+    output = pipe(
+        prompt=prompt,
+        image=img_url,
+        mask_image=mask_url,
+        guidance_scale=guidance_scale,
+        num_inference_steps=num_inference_steps,  # steps between 15 and 30 work well for us
+        strength=strength,  # make sure to use `strength` below 1.0
+        generator=generator,
+    )
+
+    return output.images[0]

options/Banner_Model/Image2Image_2.py

@@ -0,0 +1,23 @@
+import torch
+from controlnet_aux import LineartDetector
+from diffusers import ControlNetModel,UniPCMultistepScheduler,FluxPipeline
+
+device= "cuda" if torch.cuda.is_available() else "cpu"
+print("Using device for I2I_2:", device)
+processor = LineartDetector.from_pretrained("lllyasviel/Annotators")
+
+checkpoint = "ControlNet-1-1-preview/control_v11p_sd15_lineart"
+controlnet = ControlNetModel.from_pretrained(checkpoint, torch_dtype=torch.float16).to(device)
+pipe = FluxPipeline.from_pretrained(
+    "black-forest-labs/FLUX.1-dev", controlnet=controlnet, torch_dtype=torch.float16
+).to(device)
+pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+# pipe.enable_model_cpu_offload()
+
+def I2I_2(image, prompt,size,num_inference_steps):
+    image.resize((size))
+    image=processor(image)
+    generator = torch.Generator(device=device).manual_seed(0)
+    image = pipe(prompt, num_inference_steps=num_inference_steps, generator=generator, image=image).images[0]
+    return image
+

options/Banner_Model/Text2Banner.py

@@ -0,0 +1,21 @@
+from huggingface_hub import InferenceClient
+
+
+def T2I(prompt, width=1024, height=1024, guidance_scale=3.5, num_inference_steps=28):
+    # Initialize the model client
+    model = InferenceClient(model="black-forest-labs/FLUX.1-dev")
+
+    # Prepare the request parameters
+    payload = {
+        "prompt": prompt,
+       "width": width,
+        "height": height,
+        "guidance_scale": guidance_scale,
+        "num_inference_steps": num_inference_steps
+    }
+
+    # Remove None values to avoid sending unsupported arguments
+    payload = {k: v for k, v in payload.items() if v is not None}
+
+    # Make the request to generate an image
+    return model.text_to_image(**payload)

options/Video.py

@@ -0,0 +1,4 @@
+from Video_model import Model
+
+def Video(image):
+    return Model.Video(image)

options/Video_model/Model.py

@@ -0,0 +1,19 @@
+import torch
+from diffusers import StableVideoDiffusionPipeline
+from diffusers.utils import load_image, export_to_video
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print("Using device for video:", device)
+
+pipeline = StableVideoDiffusionPipeline.from_pretrained(
+    "stabilityai/stable-video-diffusion-img2vid-xt-1-1", torch_dtype=torch.float16, variant="fp16"
+).to(device)
+# pipeline.enable_model_cpu_offload()
+def Video(image):
+    image = load_image(image)
+    image = image.resize((1024, 576))
+
+    generator = torch.Generator(device=device).manual_seed(42)
+    frames = pipeline(image, decode_chunk_size=8, generator=generator).frames[0]
+    # export_to_video(frames, "generated.mp4", fps=7)
+    return frames

requirements.txt

@@ -0,0 +1,4 @@
+torch
+imageio
+diffusers
+controlnet_aux