#!/usr/bin/env python
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
import spaces
import os
import random
import uuid
import re
import gradio as gr
import numpy as np
from PIL import Image
from typing import Tuple
import paramiko
import datetime
from gradio import themes
from image_gen_aux import UpscaleWithModel
from ip_adapter import IPAdapterXL
from huggingface_hub import snapshot_download
import gc
import torch
from diffusers import UNet2DConditionModel, AutoencoderKL, StableDiffusionXLPipeline, EulerAncestralDiscreteScheduler
from transformers import CLIPTextModelWithProjection, CLIPTextModel
#from transformers import AutoTokenizer, AutoModelForCausalLM
from transformers import Blip2Processor, Blip2ForConditionalGeneration
from transformers import Phi3ForCausalLM
from transformers import pipeline
from transformers import InstructBlipProcessor, InstructBlipForConditionalGeneration
torch.backends.cuda.matmul.allow_tf32 = False
torch.backends.cuda.matmul.allow_bf16_reduced_precision_reduction = False
torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction = False
torch.backends.cudnn.allow_tf32 = False
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.benchmark = False
#torch.backends.cuda.preferred_blas_library="cublas"
# torch.backends.cuda.preferred_linalg_library="cusolver"
torch.set_float32_matmul_precision("highest")
os.putenv("HF_HUB_ENABLE_HF_TRANSFER","1")
FTP_HOST = "1ink.us"
FTP_USER = "ford442"
FTP_PASS = os.getenv("FTP_PASS")
FTP_DIR = "1ink.us/stable_diff/" # Remote directory on FTP server
DESCRIPTIONXX = """
## ⚡⚡⚡⚡ REALVISXL V5.0 BF16 IP Adapter Test B ⚡⚡⚡⚡
"""
examples = [
"Many apples splashed with drops of water within a fancy bowl 4k, hdr --v 6.0 --style raw",
"A profile photo of a dog, brown background, shot on Leica M6 --ar 128:85 --v 6.0 --style raw",
]
MAX_IMAGE_SIZE = int(os.getenv("MAX_IMAGE_SIZE", "4096"))
BATCH_SIZE = int(os.getenv("BATCH_SIZE", "1"))
device = torch.device("cuda:0")
style_list = [
{
"name": "3840 x 2160",
"prompt": "hyper-realistic 8K image of {prompt}. ultra-detailed, lifelike, high-resolution, sharp, vibrant colors, photorealistic",
"negative_prompt": "cartoonish, low resolution, blurry, simplistic, abstract, deformed, ugly",
},
{
"name": "2560 x 1440",
"prompt": "hyper-realistic 4K image of {prompt}. ultra-detailed, lifelike, high-resolution, sharp, vibrant colors, photorealistic",
"negative_prompt": "cartoonish, low resolution, blurry, simplistic, abstract, deformed, ugly",
},
{
"name": "HD+",
"prompt": "hyper-realistic 2K image of {prompt}. ultra-detailed, lifelike, high-resolution, sharp, vibrant colors, photorealistic",
"negative_prompt": "cartoonish, low resolution, blurry, simplistic, abstract, deformed, ugly",
},
{
"name": "Style Zero",
"prompt": "{prompt}",
"negative_prompt": "",
},
]
styles = {k["name"]: (k["prompt"], k["negative_prompt"]) for k in style_list}
DEFAULT_STYLE_NAME = "Style Zero"
STYLE_NAMES = list(styles.keys())
HF_TOKEN = os.getenv("HF_TOKEN")
## load IP Adapter
repo_id = "ford442/SDXL-IP_ADAPTER"
subfolder = "image_encoder"
subfolder2 = "ip_adapter"
local_repo_path = snapshot_download(repo_id=repo_id, repo_type="model")
local_folder = os.path.join(local_repo_path, subfolder)
local_folder2 = os.path.join(local_repo_path, subfolder2) # Path to the ip_adapter dir
ip_ckpt = os.path.join(local_folder2, "ip-adapter_sdxl_vit-h.bin") # Correct path
upscaler = UpscaleWithModel.from_pretrained("Kim2091/ClearRealityV1").to(torch.device("cuda:0"))
def apply_style(style_name: str, positive: str, negative: str = "") -> Tuple[str, str]:
if style_name in styles:
p, n = styles.get(style_name, styles[DEFAULT_STYLE_NAME])
else:
p, n = styles[DEFAULT_STYLE_NAME]
if not negative:
negative = ""
return p.replace("{prompt}", positive), n + negative
#unetX = UNet2DConditionModel.from_pretrained('ford442/RealVisXL_V5.0_BF16', subfolder='unet', low_cpu_mem_usage=False, token=True) #.to(device).to(torch.bfloat16) #.to(device=device, dtype=torch.bfloat16)
def load_and_prepare_model():
vaeX = AutoencoderKL.from_pretrained("stabilityai/sdxl-vae", safety_checker=None, use_safetensors=False, low_cpu_mem_usage=False, torch_dtype=torch.float32, token=True) #.to(device).to(torch.bfloat16) #.to(device=device, dtype=torch.bfloat16)
pipe = StableDiffusionXLPipeline.from_pretrained(
'ford442/RealVisXL_V5.0_BF16',
# 'SG161222/RealVisXL_V5.0',
#'John6666/uber-realistic-porn-merge-xl-urpmxl-v3-sdxl',
#torch_dtype=torch.bfloat16,
add_watermarker=False,
#use_safetensors=True,
token=HF_TOKEN,
text_encoder=None,
text_encoder_2=None,
vae=None,
# unet=None,
)
'''
scaling_factor (`float`, *optional*, defaults to 0.18215):
The component-wise standard deviation of the trained latent space computed using the first batch of the
training set. This is used to scale the latent space to have unit variance when training the diffusion
model. The latents are scaled with the formula `z = z * scaling_factor` before being passed to the
diffusion model. When decoding, the latents are scaled back to the original scale with the formula: `z = 1
/ scaling_factor * z`. For more details, refer to sections 4.3.2 and D.1 of the [High-Resolution Image
Synthesis with Latent Diffusion Models](https://arxiv.org/abs/2112.10752) paper.
force_upcast (`bool`, *optional*, default to `True`):
If enabled it will force the VAE to run in float32 for high image resolution pipelines, such as SD-XL. VAE
can be fine-tuned / trained to a lower range without loosing too much precision in which case
`force_upcast` can be set to `False` - see: https://huggingface.co/madebyollin/sdxl-vae-fp16-fix
'''
#pipe.vae=vaeX
pipe.vae=vaeX.to(device)
pipe.to(device=device, dtype=torch.bfloat16)
# pipe.vae.enable_tiling()
# pipe.vae.fuse_qkv_projections()
#pipe.vae.to(device=device, dtype=torch.bfloat16)
#pipe.vae.do_resize=False
#pipe.vae.do_rescale=False
#pipe.vae.do_convert_rgb=True
#pipe.vae.vae_scale_factor=8
#pipe.unet.set_default_attn_processor()
# pipe.vae.set_default_attn_processor()
print(f'Pipeline: ')
#print(f'_optional_components: {pipe._optional_components}')
#print(f'watermark: {pipe.watermark}')
print(f'image_processor: {pipe.image_processor}')
#print(f'feature_extractor: {pipe.feature_extractor}')
print(f'init noise scale: {pipe.scheduler.init_noise_sigma}')
#print(f'UNET: {pipe.unet}')
pipe.watermark=None
pipe.safety_checker=None
return pipe
# Preload and compile both models
pipe = load_and_prepare_model()
# text models
#checkpoint = "microsoft/Phi-3.5-mini-instruct"
checkpoint = "ford442/Phi-3.5-mini-instruct-bf16"
#captioner = pipeline(model="ydshieh/vit-gpt2-coco-en",device='cuda:0', task="image-to-text")
#captioner_2 = pipeline(model="Salesforce/blip-image-captioning-base",device='cuda', task="image-to-text")
#captioner_2 = pipeline(model="ford442/blip-image-to-text-large-bf16",device='cuda', task="image-to-text")
#model5 = Blip2ForConditionalGeneration.from_pretrained("ford442/blip2-image-to-text-bf16").to('cuda')
#processor5 = Blip2Processor.from_pretrained("ford442/blip2-image-to-text-bf16", device_map='cuda')
#txt_tokenizer = AutoTokenizer.from_pretrained(checkpoint, device_map='cuda', add_prefix_space=False)
#txt_tokenizer.tokenizer_legacy=False
#model = Phi3ForCausalLM.from_pretrained(checkpoint).to('cuda:0')
#model = AutoModelForCausalLM.from_pretrained(checkpoint, device_map='cuda') #.to('cuda')
model5 = InstructBlipForConditionalGeneration.from_pretrained("Salesforce/instructblip-vicuna-7b").to('cuda',torch.bfloat16)
processor5 = InstructBlipProcessor.from_pretrained("Salesforce/instructblip-vicuna-7b")
ip_model = IPAdapterXL(pipe, local_folder, ip_ckpt, device)
text_encoder_1=CLIPTextModel.from_pretrained('ford442/RealVisXL_V5.0_BF16', subfolder='text_encoder',token=True) #.to(device=device, dtype=torch.bfloat16)
text_encoder_2=CLIPTextModelWithProjection.from_pretrained('ford442/RealVisXL_V5.0_BF16', subfolder='text_encoder_2',token=True) #.to(device=device, dtype=torch.bfloat16)
MAX_SEED = np.iinfo(np.int32).max
neg_prompt_2 = " 'non-photorealistic':1.5, 'unrealistic skin','unattractive face':1.3, 'low quality':1.1, ('dull color scheme', 'dull colors', 'digital noise':1.2),'amateurish', 'poorly drawn face':1.3, 'poorly drawn', 'distorted face', 'low resolution', 'simplistic' "
def filter_text(text,phraseC):
"""Filters out the text up to and including 'Rewritten Prompt:'."""
phrase = "Rewritten Prompt:"
phraseB = "rewritten text:"
pattern = f"(.*?){re.escape(phrase)}(.*)"
patternB = f"(.*?){re.escape(phraseB)}(.*)"
# matchB = re.search(patternB, text)
matchB = re.search(patternB, text, flags=re.DOTALL)
if matchB:
filtered_text = matchB.group(2)
match = re.search(pattern, filtered_text, flags=re.DOTALL)
if match:
filtered_text = match.group(2)
filtered_text = re.sub(phraseC, "", filtered_text, flags=re.DOTALL)
return filtered_text
else:
return filtered_text
else:
# Handle the case where no match is found
return text
def upload_to_ftp(filename):
try:
transport = paramiko.Transport((FTP_HOST, 22))
destination_path=FTP_DIR+filename
transport.connect(username = FTP_USER, password = FTP_PASS)
sftp = paramiko.SFTPClient.from_transport(transport)
sftp.put(filename, destination_path)
sftp.close()
transport.close()
print(f"Uploaded {filename} to FTP server")
except Exception as e:
print(f"FTP upload error: {e}")
def save_image(img):
unique_name = str(uuid.uuid4()) + ".png"
img.save(unique_name,optimize=False,compress_level=0)
return unique_name
def uploadNote(prompt,num_inference_steps,guidance_scale,timestamp):
filename= f'IP_{timestamp}.txt'
with open(filename, "w") as f:
f.write(f"Realvis 5.0 IP Adapter Test B\n")
f.write(f"Date/time: {timestamp} \n")
f.write(f"Prompt: {prompt} \n")
f.write(f"Steps: {num_inference_steps} \n")
f.write(f"Guidance Scale: {guidance_scale} \n")
f.write(f"SPACE SETUP: \n")
f.write(f"Model UNET: ford442/RealVisXL_V5.0_BF16 \n")
upload_to_ftp(filename)
def captioning(img):
prompts_array = [
"Adjectives describing this scene are:",
# "The color scheme of this image is",
# "This scene could be described in detail as",
# "The characters in this scene are",
# "The larger details in this scene include",
# "The smaller details in this scene include",
# "The feeling this scene seems like",
"The setting of this scene must be located",
# Add more prompts here
]
output_prompt=[]
cap_prompt = (
"Describe this image with a caption to be used for image generation."
)
cap_prompt2 = (
"Describe this image."
)
inputsa = processor5(images=img, text=cap_prompt, return_tensors="pt").to('cuda')
inputsb = processor5(images=img, text=cap_prompt2, return_tensors="pt").to('cuda')
'''
generated_ids = model5.generate(
**inputsa,
do_sample=True,
num_beams=5,
max_length=128,
min_length=64,
top_p=0.9,
repetition_penalty=1.5,
length_penalty=1.0,
temperature=1,
)
'''
generated_ids = model5.generate(
**inputsa,
do_sample=True,
num_beams=1,
max_length=128,
min_length=64,
top_p=0.9,
repetition_penalty=1.0,
length_penalty=2.0,
temperature=0.5,
)
generated_text = processor5.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
generated_idsb = model5.generate(
**inputsb,
do_sample=True,
num_beams=1,
max_length=42,
min_length=40,
top_p=0.9,
repetition_penalty=1.0,
length_penalty=2.0,
temperature=0.5,
)
generated_textb = processor5.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
generated_text = generated_text.replace(cap_prompt, "").strip() #Or could try .split(prompt, 1)[-1].strip()
generated_textb = generated_textb.replace(cap_prompt, "").strip() #Or could try .split(prompt, 1)[-1].strip()
output_prompt.append(generated_text)
print(generated_text)
# Loop through prompts array:
'''
for prompt in prompts_array:
inputs = processor5(images=img, text=prompt, return_tensors="pt").to('cuda')
#with torch.no_grad():
generated_ids = model5.generate(
**inputs,
do_sample=True,
num_beams=1,
max_length=64,
#min_length=16,
top_p=0.1,
repetition_penalty=1.0,
length_penalty=2.0,
temperature=0.5,
)
generated_text = processor5.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
response_text = generated_text.replace(prompt, "").strip() #Or could try .split(prompt, 1)[-1].strip()
output_prompt.append(response_text)
print(f"{response_text}\n")
inputf = processor5(
images=img,
text=generated_text + ' So therefore, ',
return_tensors="pt"
).to('cuda')
generated_ids = model5.generate(
**inputf,
do_sample=True,
num_beams=1,
max_length=96,
min_length=64,
top_p=0.1,
repetition_penalty=1.0,
length_penalty=1.0,
temperature=0.5,
)
generated_texta = processor5.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
response_text = generated_texta.replace(generated_text, "").strip()
print(f"{response_text}\n")
output_prompt.append(response_text)
'''
output_prompt = " ".join(output_prompt)
return output_prompt, generated_textb
def flatten_and_stringify(data):
return [str(item) for sublist in data if isinstance(sublist, list) for item in flatten_and_stringify(sublist) ] + [str(item) for item in data if not isinstance(item, list)]
def expand_prompt(prompt):
system_prompt_rewrite = (
"You are an AI assistant that rewrites image prompts to be more descriptive and detailed."
)
user_prompt_rewrite = (
"Rewrite this prompt to be more descriptive and detailed and only return the rewritten text: "
)
user_prompt_rewrite_2 = (
"Rephrase this scene to have more elaborate details: "
)
input_text = f"{system_prompt_rewrite} {user_prompt_rewrite} {prompt}"
print("-- got prompt --")
# Encode the input text and include the attention mask
encoded_inputs = txt_tokenizer(input_text, return_tensors="pt", return_attention_mask=True).to("cuda:0")
# Ensure all values are on the correct device
input_ids = encoded_inputs["input_ids"].to("cuda:0")
attention_mask = encoded_inputs["attention_mask"].to("cuda:0")
print("-- tokenize prompt --")
# Google T5
#input_ids = txt_tokenizer(input_text, return_tensors="pt").input_ids.to("cuda")
outputs = model.generate(
input_ids=input_ids,
attention_mask=attention_mask,
max_new_tokens=1024,
temperature=0.2,
top_p=0.9,
do_sample=True,
)
enhanced_prompt = txt_tokenizer.decode(outputs[0], skip_special_tokens=True)
print('-- generated prompt 1 --')
#print(enhanced_prompt)
#enhanced_prompt = filter_text(enhanced_prompt,prompt)
#enhanced_prompt = filter_text(enhanced_prompt,user_prompt_rewrite)
#enhanced_prompt = filter_text(enhanced_prompt,system_prompt_rewrite)
print('-- filtered prompt --')
enhanced_prompt = enhanced_prompt[len(input_text):]
print(enhanced_prompt)
'''
input_text_2 = f"{system_prompt_rewrite} {user_prompt_rewrite_2} {enhanced_prompt}"
encoded_inputs_2 = txt_tokenizer(input_text_2, return_tensors="pt", return_attention_mask=True).to("cuda:0")
input_ids_2 = encoded_inputs_2["input_ids"].to("cuda:0")
attention_mask_2 = encoded_inputs_2["attention_mask"].to("cuda:0")
outputs_2 = model.generate(
input_ids=input_ids_2,
attention_mask=attention_mask_2,
max_new_tokens=256,
temperature=0.2,
top_p=0.9,
do_sample=True,
)
# Use the encoded tensor 'text_inputs' here
enhanced_prompt_2 = txt_tokenizer.decode(outputs_2[0], skip_special_tokens=True)
print('-- generated prompt 2 --')
print(enhanced_prompt_2)
enhanced_prompt_2 = filter_text(enhanced_prompt_2,prompt)
enhanced_prompt_2 = filter_text(enhanced_prompt_2,user_prompt_rewrite_2)
enhanced_prompt_2 = filter_text(enhanced_prompt_2,system_prompt_rewrite)
print('-- filtered prompt 2 --')
print(enhanced_prompt_2)
enh_prompt=[enhanced_prompt,enhanced_prompt_2]
'''
return enhanced_prompt
@spaces.GPU(duration=40)
def generate_30(
prompt: str = "",
negative_prompt: str = "",
use_negative_prompt: bool = False,
style_selection: str = "",
width: int = 768,
height: int = 768,
guidance_scale: float = 4,
num_inference_steps: int = 125,
latent_file = gr.File(), # Add latents file input
latent_file_2 = gr.File(), # Add latents file input
latent_file_3 = gr.File(), # Add latents file input
latent_file_4 = gr.File(), # Add latents file input
latent_file_5 = gr.File(), # Add latents file input
text_scale: float = 1.0,
ip_scale: float = 1.0,
latent_file_1_scale: float = 1.0,
latent_file_2_scale: float = 1.0,
latent_file_3_scale: float = 1.0,
latent_file_4_scale: float = 1.0,
latent_file_5_scale: float = 1.0,
samples=1,
progress=gr.Progress(track_tqdm=True) # Add progress as a keyword argument
):
prompt1=None
prompt2=None
prompt3=None
prompt4=None
prompt5=None
image_paths=[]
seed = random.randint(0, MAX_SEED)
generator = torch.Generator(device='cuda').manual_seed(seed)
capt=[]
if latent_file is not None: # Check if a latent file is provided
sd_image_a = Image.open(latent_file.name).convert('RGB')
sd_image_a.resize((768,768), Image.LANCZOS)
#sd_image_a.resize((height,width), Image.LANCZOS)
caption=[]
#caption.append(captioning(sd_image_a))
prompt1, cap=captioning(sd_image_a)
capt.append(cap)
if latent_file_2 is not None: # Check if a latent file is provided
sd_image_b = Image.open(latent_file_2.name).convert('RGB')
#sd_image_b.resize((height,width), Image.LANCZOS)
sd_image_b.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_b))
prompt2, cap=captioning(sd_image_b)
capt.append(cap)
else:
sd_image_b = None
if latent_file_3 is not None: # Check if a latent file is provided
sd_image_c = Image.open(latent_file_3.name).convert('RGB')
#sd_image_c.resize((height,width), Image.LANCZOS)
sd_image_c.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_c))
prompt3, cap=captioning(sd_image_c)
capt.append(cap)
else:
sd_image_c = None
if latent_file_4 is not None: # Check if a latent file is provided
sd_image_d = Image.open(latent_file_4.name).convert('RGB')
#sd_image_d.resize((height,width), Image.LANCZOS)
sd_image_d.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_d))
prompt4, cap=captioning(sd_image_d)
capt.append(cap)
else:
sd_image_d = None
if latent_file_5 is not None: # Check if a latent file is provided
sd_image_e = Image.open(latent_file_5.name).convert('RGB')
#sd_image_e.resize((height,width), Image.LANCZOS)
sd_image_e.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_e))
prompt5, cap=captioning(sd_image_e)
capt.append(cap)
else:
sd_image_e = None
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
filename= f'rv_IPb_{timestamp}.png'
print("-- using image file --")
print("-- CURRENT PROMPT --")
print(prompt)
prompt = " ".join(prompt)
print("-- CURRENT PROMPT AFTER .join --")
print(prompt)
captions = " ".join(caption)
capt = " ".join(capt)
print(captions)
print("-- not generating further caption --")
global model5
global processor5
del model5
del processor5
gc.collect()
torch.cuda.empty_cache()
torch.cuda.reset_peak_memory_stats()
#expanded = expand_prompt(captions)
new_prompt = prompt + ' ' + captions
print("-- ------------ --")
print("-- FINAL PROMPT --")
print(capt)
print("-- FINAL PROMPT --")
print("-- ------------ --")
gc.collect()
torch.cuda.empty_cache()
global text_encoder_1
global text_encoder_2
pipe.text_encoder=text_encoder_1.to(device=device, dtype=torch.bfloat16)
pipe.text_encoder_2=text_encoder_2.to(device=device, dtype=torch.bfloat16)
print('-- generating image --')
sd_image = ip_model.generate(
pil_image_1=sd_image_a,
pil_image_2=sd_image_b,
pil_image_3=sd_image_c,
pil_image_4=sd_image_d,
pil_image_5=sd_image_e,
prompt=prompt,
prompt1=prompt1,
prompt2=prompt2,
prompt3=prompt3,
prompt4=prompt4,
prompt5=prompt5,
negative_prompt=negative_prompt,
text_scale=text_scale,
ip_scale=ip_scale,
scale_1=latent_file_1_scale,
scale_2=latent_file_2_scale,
scale_3=latent_file_3_scale,
scale_4=latent_file_4_scale,
scale_5=latent_file_5_scale,
num_samples=samples,
seed=seed,
num_inference_steps=num_inference_steps,
guidance_scale=guidance_scale,
)
sd_image[0].save(filename,optimize=False,compress_level=0)
upload_to_ftp(filename)
uploadNote(prompt,num_inference_steps,guidance_scale,timestamp)
torch.set_float32_matmul_precision("medium")
with torch.no_grad():
upscale = upscaler(sd_image, tiling=True, tile_width=256, tile_height=256)
downscale1 = upscale.resize((upscale.width // 4, upscale.height // 4), Image.LANCZOS)
downscale_path = f"rvIP_upscale_{timestamp}.png"
downscale1.save(downscale_path,optimize=False,compress_level=0)
upload_to_ftp(downscale_path)
image_paths = [save_image(downscale1)]
else:
print('-- IMAGE REQUIRED --')
return image_paths
@spaces.GPU(duration=70)
def generate_60(
prompt: str = "",
negative_prompt: str = "",
use_negative_prompt: bool = False,
style_selection: str = "",
width: int = 768,
height: int = 768,
guidance_scale: float = 4,
num_inference_steps: int = 125,
latent_file = gr.File(), # Add latents file input
latent_file_2 = gr.File(), # Add latents file input
latent_file_3 = gr.File(), # Add latents file input
latent_file_4 = gr.File(), # Add latents file input
latent_file_5 = gr.File(), # Add latents file input
text_scale: float = 1.0,
ip_scale: float = 1.0,
latent_file_1_scale: float = 1.0,
latent_file_2_scale: float = 1.0,
latent_file_3_scale: float = 1.0,
latent_file_4_scale: float = 1.0,
latent_file_5_scale: float = 1.0,
samples=1,
progress=gr.Progress(track_tqdm=True) # Add progress as a keyword argument
):
prompt1=None
prompt2=None
prompt3=None
prompt4=None
prompt5=None
image_paths=[]
seed = random.randint(0, MAX_SEED)
generator = torch.Generator(device='cuda').manual_seed(seed)
capt=[]
if latent_file is not None: # Check if a latent file is provided
sd_image_a = Image.open(latent_file.name).convert('RGB')
sd_image_a.resize((768,768), Image.LANCZOS)
#sd_image_a.resize((height,width), Image.LANCZOS)
caption=[]
#caption.append(captioning(sd_image_a))
prompt1, cap=captioning(sd_image_a)
capt.append(cap)
if latent_file_2 is not None: # Check if a latent file is provided
sd_image_b = Image.open(latent_file_2.name).convert('RGB')
#sd_image_b.resize((height,width), Image.LANCZOS)
sd_image_b.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_b))
prompt2, cap=captioning(sd_image_b)
capt.append(cap)
else:
sd_image_b = None
if latent_file_3 is not None: # Check if a latent file is provided
sd_image_c = Image.open(latent_file_3.name).convert('RGB')
#sd_image_c.resize((height,width), Image.LANCZOS)
sd_image_c.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_c))
prompt3, cap=captioning(sd_image_c)
capt.append(cap)
else:
sd_image_c = None
if latent_file_4 is not None: # Check if a latent file is provided
sd_image_d = Image.open(latent_file_4.name).convert('RGB')
#sd_image_d.resize((height,width), Image.LANCZOS)
sd_image_d.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_d))
prompt4, cap=captioning(sd_image_d)
capt.append(cap)
else:
sd_image_d = None
if latent_file_5 is not None: # Check if a latent file is provided
sd_image_e = Image.open(latent_file_5.name).convert('RGB')
#sd_image_e.resize((height,width), Image.LANCZOS)
sd_image_e.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_e))
prompt5, cap=captioning(sd_image_e)
capt.append(cap)
else:
sd_image_e = None
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
filename= f'rv_IPb_{timestamp}.png'
print("-- using image file --")
print("-- CURRENT PROMPT --")
print(prompt)
prompt = " ".join(prompt)
print("-- CURRENT PROMPT AFTER .join --")
print(prompt)
captions = " ".join(caption)
capt = " ".join(capt)
print(captions)
print("-- not generating further caption --")
global model5
global processor5
del model5
del processor5
gc.collect()
torch.cuda.empty_cache()
torch.cuda.reset_peak_memory_stats()
#expanded = expand_prompt(captions)
new_prompt = prompt + ' ' + captions
print("-- ------------ --")
print("-- FINAL PROMPT --")
print(capt)
print("-- FINAL PROMPT --")
print("-- ------------ --")
gc.collect()
torch.cuda.empty_cache()
global text_encoder_1
global text_encoder_2
pipe.text_encoder=text_encoder_1.to(device=device, dtype=torch.bfloat16)
pipe.text_encoder_2=text_encoder_2.to(device=device, dtype=torch.bfloat16)
print('-- generating image --')
sd_image = ip_model.generate(
pil_image_1=sd_image_a,
pil_image_2=sd_image_b,
pil_image_3=sd_image_c,
pil_image_4=sd_image_d,
pil_image_5=sd_image_e,
prompt=prompt,
prompt1=prompt1,
prompt2=prompt2,
prompt3=prompt3,
prompt4=prompt4,
prompt5=prompt5,
negative_prompt=negative_prompt,
text_scale=text_scale,
ip_scale=ip_scale,
scale_1=latent_file_1_scale,
scale_2=latent_file_2_scale,
scale_3=latent_file_3_scale,
scale_4=latent_file_4_scale,
scale_5=latent_file_5_scale,
num_samples=samples,
seed=seed,
num_inference_steps=num_inference_steps,
guidance_scale=guidance_scale,
)
sd_image[0].save(filename,optimize=False,compress_level=0)
upload_to_ftp(filename)
uploadNote(prompt,num_inference_steps,guidance_scale,timestamp)
torch.set_float32_matmul_precision("medium")
with torch.no_grad():
upscale = upscaler(sd_image, tiling=True, tile_width=256, tile_height=256)
downscale1 = upscale.resize((upscale.width // 4, upscale.height // 4), Image.LANCZOS)
downscale_path = f"rvIP_upscale_{timestamp}.png"
downscale1.save(downscale_path,optimize=False,compress_level=0)
upload_to_ftp(downscale_path)
image_paths = [save_image(downscale1)]
else:
print('-- IMAGE REQUIRED --')
return image_paths
@spaces.GPU(duration=100)
def generate_90(
prompt: str = "",
negative_prompt: str = "",
use_negative_prompt: bool = False,
style_selection: str = "",
width: int = 768,
height: int = 768,
guidance_scale: float = 4,
num_inference_steps: int = 125,
latent_file = gr.File(), # Add latents file input
latent_file_2 = gr.File(), # Add latents file input
latent_file_3 = gr.File(), # Add latents file input
latent_file_4 = gr.File(), # Add latents file input
latent_file_5 = gr.File(), # Add latents file input
text_scale: float = 1.0,
ip_scale: float = 1.0,
latent_file_1_scale: float = 1.0,
latent_file_2_scale: float = 1.0,
latent_file_3_scale: float = 1.0,
latent_file_4_scale: float = 1.0,
latent_file_5_scale: float = 1.0,
samples=1,
progress=gr.Progress(track_tqdm=True) # Add progress as a keyword argument
):
prompt1=None
prompt2=None
prompt3=None
prompt4=None
prompt5=None
image_paths=[]
seed = random.randint(0, MAX_SEED)
generator = torch.Generator(device='cuda').manual_seed(seed)
capt=[]
if latent_file is not None: # Check if a latent file is provided
sd_image_a = Image.open(latent_file.name).convert('RGB')
sd_image_a.resize((768,768), Image.LANCZOS)
#sd_image_a.resize((height,width), Image.LANCZOS)
caption=[]
#caption.append(captioning(sd_image_a))
prompt1, cap=captioning(sd_image_a)
capt.append(cap)
if latent_file_2 is not None: # Check if a latent file is provided
sd_image_b = Image.open(latent_file_2.name).convert('RGB')
#sd_image_b.resize((height,width), Image.LANCZOS)
sd_image_b.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_b))
prompt2, cap=captioning(sd_image_b)
capt.append(cap)
else:
sd_image_b = None
if latent_file_3 is not None: # Check if a latent file is provided
sd_image_c = Image.open(latent_file_3.name).convert('RGB')
#sd_image_c.resize((height,width), Image.LANCZOS)
sd_image_c.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_c))
prompt3, cap=captioning(sd_image_c)
capt.append(cap)
else:
sd_image_c = None
if latent_file_4 is not None: # Check if a latent file is provided
sd_image_d = Image.open(latent_file_4.name).convert('RGB')
#sd_image_d.resize((height,width), Image.LANCZOS)
sd_image_d.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_d))
prompt4, cap=captioning(sd_image_d)
capt.append(cap)
else:
sd_image_d = None
if latent_file_5 is not None: # Check if a latent file is provided
sd_image_e = Image.open(latent_file_5.name).convert('RGB')
#sd_image_e.resize((height,width), Image.LANCZOS)
sd_image_e.resize((768,768), Image.LANCZOS)
#caption.append(captioning(sd_image_e))
prompt5, cap=captioning(sd_image_e)
capt.append(cap)
else:
sd_image_e = None
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
filename= f'rv_IPb_{timestamp}.png'
print("-- using image file --")
print("-- CURRENT PROMPT --")
print(prompt)
prompt = " ".join(prompt)
print("-- CURRENT PROMPT AFTER .join --")
print(prompt)
captions = " ".join(caption)
capt = " ".join(capt)
print(captions)
print("-- not generating further caption --")
global model5
global processor5
del model5
del processor5
gc.collect()
torch.cuda.empty_cache()
torch.cuda.reset_peak_memory_stats()
#expanded = expand_prompt(captions)
new_prompt = prompt + ' ' + captions
print("-- ------------ --")
print("-- FINAL PROMPT --")
print(capt)
print("-- FINAL PROMPT --")
print("-- ------------ --")
gc.collect()
torch.cuda.empty_cache()
global text_encoder_1
global text_encoder_2
pipe.text_encoder=text_encoder_1.to(device=device, dtype=torch.bfloat16)
pipe.text_encoder_2=text_encoder_2.to(device=device, dtype=torch.bfloat16)
print('-- generating image --')
sd_image = ip_model.generate(
pil_image_1=sd_image_a,
pil_image_2=sd_image_b,
pil_image_3=sd_image_c,
pil_image_4=sd_image_d,
pil_image_5=sd_image_e,
prompt=prompt,
prompt1=prompt1,
prompt2=prompt2,
prompt3=prompt3,
prompt4=prompt4,
prompt5=prompt5,
negative_prompt=negative_prompt,
text_scale=text_scale,
ip_scale=ip_scale,
scale_1=latent_file_1_scale,
scale_2=latent_file_2_scale,
scale_3=latent_file_3_scale,
scale_4=latent_file_4_scale,
scale_5=latent_file_5_scale,
num_samples=samples,
seed=seed,
num_inference_steps=num_inference_steps,
guidance_scale=guidance_scale,
)
sd_image[0].save(filename,optimize=False,compress_level=0)
upload_to_ftp(filename)
uploadNote(prompt,num_inference_steps,guidance_scale,timestamp)
torch.set_float32_matmul_precision("medium")
with torch.no_grad():
upscale = upscaler(sd_image, tiling=True, tile_width=256, tile_height=256)
downscale1 = upscale.resize((upscale.width // 4, upscale.height // 4), Image.LANCZOS)
downscale_path = f"rvIP_upscale_{timestamp}.png"
downscale1.save(downscale_path,optimize=False,compress_level=0)
upload_to_ftp(downscale_path)
image_paths = [save_image(downscale1)]
else:
print('-- IMAGE REQUIRED --')
return image_paths
def load_predefined_images1():
predefined_images1 = [
"assets/7.png",
"assets/8.png",
"assets/9.png",
"assets/1.png",
"assets/2.png",
"assets/3.png",
"assets/4.png",
"assets/5.png",
"assets/6.png",
]
return predefined_images1
css = '''
#col-container {
margin: 0 auto;
max-width: 640px;
}
h1{text-align:center}
footer {
visibility: hidden
}
body {
background-color: green;
}
'''
with gr.Blocks(theme=gr.themes.Origin(),css=css) as demo:
gr.Markdown(DESCRIPTIONXX)
with gr.Row():
prompt = gr.Text(
label="Prompt",
show_label=False,
max_lines=1,
placeholder="Enter your prompt",
container=False,
)
text_strength = gr.Slider(
label="Text Strength",
minimum=0.0,
maximum=16.0,
step=0.01,
value=1.0,
)
run_button_30 = gr.Button("Run 30 Seconds", scale=0)
run_button_60 = gr.Button("Run 60 Seconds", scale=0)
run_button_90 = gr.Button("Run 90 Seconds", scale=0)
result = gr.Gallery(label="Result", columns=1, show_label=False)
ip_strength = gr.Slider(
label="Image Strength",
minimum=0.0,
maximum=16.0,
step=0.01,
value=1.0,
)
with gr.Row():
latent_file = gr.File(label="Image Prompt (Required)")
image_1_text = gr.Textbox(label="Image 1 Text", lines=5) # Add this line
file_1_strength = gr.Slider(
label="Img 1 %",
minimum=0.0,
maximum=16.0,
step=0.01,
value=1.0,
)
latent_file_2 = gr.File(label="Image Prompt 2 (Optional)")
file_2_strength = gr.Slider(
label="Img 2 %",
minimum=0.0,
maximum=16.0,
step=0.01,
value=1.0,
)
latent_file_3 = gr.File(label="Image Prompt 3 (Optional)")
file_3_strength = gr.Slider(
label="Img 3 %",
minimum=0.0,
maximum=16.0,
step=0.01,
value=1.0,
)
latent_file_4 = gr.File(label="Image Prompt 4 (Optional)")
file_4_strength = gr.Slider(
label="Img 4 %",
minimum=0.0,
maximum=16.0,
step=0.01,
value=1.0,
)
latent_file_5 = gr.File(label="Image Prompt 5 (Optional)")
file_5_strength = gr.Slider(
label="Img 5 %",
minimum=0.0,
maximum=16.0,
step=0.01,
value=1.0,
)
style_selection = gr.Radio(
show_label=True,
container=True,
interactive=True,
choices=STYLE_NAMES,
value=DEFAULT_STYLE_NAME,
label="Quality Style",
)
with gr.Row():
with gr.Column(scale=1):
use_negative_prompt = gr.Checkbox(label="Use negative prompt", value=True)
negative_prompt = gr.Text(
label="Negative prompt",
max_lines=5,
lines=4,
placeholder="Enter a negative prompt",
value="('deformed', 'distorted', 'disfigured':1.3),'not photorealistic':1.5, 'poorly drawn', 'bad anatomy', 'wrong anatomy', 'extra limb', 'missing limb', 'floating limbs', 'poorly drawn hands', 'poorly drawn feet', 'poorly drawn face':1.3, 'out of frame', 'extra limbs', 'bad anatomy', 'bad art', 'beginner', 'distorted face','amateur'",
visible=True,
)
samples = gr.Slider(
label="Samples",
minimum=0,
maximum=20,
step=1,
value=1,
)
randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
with gr.Row():
width = gr.Slider(
label="Width",
minimum=448,
maximum=MAX_IMAGE_SIZE,
step=64,
value=768,
)
height = gr.Slider(
label="Height",
minimum=448,
maximum=MAX_IMAGE_SIZE,
step=64,
value=768,
)
with gr.Row():
guidance_scale = gr.Slider(
label="Guidance Scale",
minimum=0.1,
maximum=30,
step=0.1,
value=3.8,
)
num_inference_steps = gr.Slider(
label="Number of inference steps",
minimum=10,
maximum=1000,
step=10,
value=170,
)
gr.Examples(
examples=examples,
inputs=prompt,
cache_examples=False
)
use_negative_prompt.change(
fn=lambda x: gr.update(visible=x),
inputs=use_negative_prompt,
outputs=negative_prompt,
api_name=False,
)
gr.on(
triggers=[
run_button_30.click,
],
# api_name="generate", # Add this line
fn=generate_30,
inputs=[
prompt,
negative_prompt,
use_negative_prompt,
style_selection,
width,
height,
guidance_scale,
num_inference_steps,
latent_file,
latent_file_2,
latent_file_3,
latent_file_4,
latent_file_5,
text_strength,
ip_strength,
file_1_strength,
file_2_strength,
file_3_strength,
file_4_strength,
file_5_strength,
samples,
],
outputs=[result],
)
gr.on(
triggers=[
run_button_60.click,
],
# api_name="generate", # Add this line
fn=generate_60,
inputs=[
prompt,
negative_prompt,
use_negative_prompt,
style_selection,
width,
height,
guidance_scale,
num_inference_steps,
latent_file,
latent_file_2,
latent_file_3,
latent_file_4,
latent_file_5,
text_strength,
ip_strength,
file_1_strength,
file_2_strength,
file_3_strength,
file_4_strength,
file_5_strength,
samples,
],
outputs=[result],
)
gr.on(
triggers=[
run_button_90.click,
],
# api_name="generate", # Add this line
fn=generate_90,
inputs=[
prompt,
negative_prompt,
use_negative_prompt,
style_selection,
width,
height,
guidance_scale,
num_inference_steps,
latent_file,
latent_file_2,
latent_file_3,
latent_file_4,
latent_file_5,
text_strength,
ip_strength,
file_1_strength,
file_2_strength,
file_3_strength,
file_4_strength,
file_5_strength,
samples,
],
outputs=[result],
)
gr.Markdown("### REALVISXL V5.0")
predefined_gallery = gr.Gallery(label="REALVISXL V5.0", columns=3, show_label=False, value=load_predefined_images1())
#gr.Markdown("### LIGHTNING V5.0")
#predefined_gallery = gr.Gallery(label="LIGHTNING V5.0", columns=3, show_label=False, value=load_predefined_images())
gr.Markdown(
"""
⚡Models used in the playground
[REALVISXL V5.0],
[REALVISXL V5.0 LIGHTNING] for image generation. Stable Diffusion XL piped (SDXL) model HF. This is the demo space for generating images using the Stable Diffusion XL models, with multiple different variants available.
⚡This is the demo space for generating images using Stable Diffusion XL with quality styles, different models, and types. Try the sample prompts to generate higher quality images. Try the sample prompts for generating higher quality images.
Try prompts.
⚠️ Users are accountable for the content they generate and are responsible for ensuring it meets appropriate ethical standards.
""")
def text_generation(input_text, seed):
full_prompt = "Text Generator Application by ecarbo"
return full_prompt
title = "Text Generator Demo GPT-Neo"
description = "Text Generator Application by ecarbo"
if __name__ == "__main__":
demo_interface = demo.queue(max_size=50) # Remove .launch() here
text_gen_interface = gr.Interface(
fn=text_generation,
inputs=[
gr.Textbox(lines=1, label="Expand the following prompt to be more detailed and descriptive for image generation: "),
gr.Number(value=10, label="Enter seed number")
],
outputs=gr.Textbox(label="Text Generated"),
title=title,
description=description,
)
combined_interface = gr.TabbedInterface([demo_interface, text_gen_interface], ["Image Generation", "Text Generation"])
combined_interface.launch(show_api=False)