import gradio as gr
import json
import torch
import time
import random
try:
# Only on HuggingFace
import spaces
is_space_imported = True
except ImportError:
is_space_imported = False
from tqdm import tqdm
from huggingface_hub import snapshot_download
from models import AudioDiffusion, DDPMScheduler
from audioldm.audio.stft import TacotronSTFT
from audioldm.variational_autoencoder import AutoencoderKL
# Old import
import numpy as np
import torch.nn.functional as F
from torchvision.transforms.functional import normalize
from huggingface_hub import hf_hub_download
from gradio_imageslider import ImageSlider
from briarmbg import BriaRMBG
import PIL
from PIL import Image
from typing import Tuple
max_64_bit_int = 2**63 - 1
# Automatic device detection
if torch.cuda.is_available():
device_type = "cuda"
device_selection = "cuda:0"
else:
device_type = "cpu"
device_selection = "cpu"
class Tango:
def __init__(self, name = "declare-lab/tango2", device = device_selection):
path = snapshot_download(repo_id = name)
vae_config = json.load(open("{}/vae_config.json".format(path)))
stft_config = json.load(open("{}/stft_config.json".format(path)))
main_config = json.load(open("{}/main_config.json".format(path)))
self.vae = AutoencoderKL(**vae_config).to(device)
self.stft = TacotronSTFT(**stft_config).to(device)
# self.model = AudioDiffusion(**main_config).to(device)
#
# vae_weights = torch.load("{}/pytorch_model_vae.bin".format(path), map_location = device)
# stft_weights = torch.load("{}/pytorch_model_stft.bin".format(path), map_location = device)
# main_weights = torch.load("{}/pytorch_model_main.bin".format(path), map_location = device)
#
# self.vae.load_state_dict(vae_weights)
# self.stft.load_state_dict(stft_weights)
# self.model.load_state_dict(main_weights)
#
# print ("Successfully loaded checkpoint from:", name)
#
# self.vae.eval()
# self.stft.eval()
# self.model.eval()
#
# self.scheduler = DDPMScheduler.from_pretrained(main_config["scheduler_name"], subfolder = "scheduler")
def chunks(self, lst, n):
# Yield successive n-sized chunks from a list
for i in range(0, len(lst), n):
yield lst[i:i + n]
def generate(self, prompt, steps = 100, guidance = 3, samples = 1, disable_progress = True):
# Generate audio for a single prompt string
with torch.no_grad():
latents = self.model.inference([prompt], self.scheduler, steps, guidance, samples, disable_progress = disable_progress)
mel = self.vae.decode_first_stage(latents)
wave = self.vae.decode_to_waveform(mel)
return wave
def generate_for_batch(self, prompts, steps = 200, guidance = 3, samples = 1, batch_size = 8, disable_progress = True):
# Generate audio for a list of prompt strings
outputs = []
for k in tqdm(range(0, len(prompts), batch_size)):
batch = prompts[k: k + batch_size]
with torch.no_grad():
latents = self.model.inference(batch, self.scheduler, steps, guidance, samples, disable_progress = disable_progress)
mel = self.vae.decode_first_stage(latents)
wave = self.vae.decode_to_waveform(mel)
outputs += [item for item in wave]
if samples == 1:
return outputs
return list(self.chunks(outputs, samples))
# Initialize TANGO
tango = Tango(device = "cpu")
#tango.vae.to(device_type)
#tango.stft.to(device_type)
#tango.model.to(device_type)
#def update_seed(is_randomize_seed, seed):
# if is_randomize_seed:
# return random.randint(0, max_64_bit_int)
# return seed
#
#def check(
# prompt,
# output_number,
# steps,
# guidance,
# is_randomize_seed,
# seed
#):
# if prompt is None or prompt == "":
# raise gr.Error("Please provide a prompt input.")
# if not output_number in [1, 2, 3]:
# raise gr.Error("Please ask for 1, 2 or 3 output files.")
#
#def update_output(output_format, output_number):
# return [
# gr.update(format = output_format),
# gr.update(format = output_format, visible = (2 <= output_number)),
# gr.update(format = output_format, visible = (output_number == 3)),
# gr.update(visible = False)
# ]
#
#def text2audio(
# prompt,
# output_number,
# steps,
# guidance,
# is_randomize_seed,
# seed
#):
# start = time.time()
#
# if seed is None:
# seed = random.randint(0, max_64_bit_int)
#
# random.seed(seed)
# torch.manual_seed(seed)
#
# output_wave = tango.generate(prompt, steps, guidance, output_number)
#
# output_wave_1 = gr.make_waveform((16000, output_wave[0]))
# output_wave_2 = gr.make_waveform((16000, output_wave[1])) if (2 <= output_number) else None
# output_wave_3 = gr.make_waveform((16000, output_wave[2])) if (output_number == 3) else None
#
# end = time.time()
# secondes = int(end - start)
# minutes = secondes // 60
# secondes = secondes - (minutes * 60)
# hours = minutes // 60
# minutes = minutes - (hours * 60)
# return [
# output_wave_1,
# output_wave_2,
# output_wave_3,
# gr.update(visible = True, value = "Start again to get a different result. The output have been generated in " + ((str(hours) + " h, ") if hours != 0 else "") + ((str(minutes) + " min, ") if hours != 0 or minutes != 0 else "") + str(secondes) + " sec.")
# ]
#
#if is_space_imported:
# text2audio = spaces.GPU(text2audio, duration = 420)
# Old code
net=BriaRMBG()
model_path = hf_hub_download("cocktailpeanut/gbmr", 'model.pth')
if torch.cuda.is_available():
net.load_state_dict(torch.load(model_path))
net=net.cuda()
device = "cuda"
elif torch.backends.mps.is_available():
net.load_state_dict(torch.load(model_path,map_location="mps"))
net=net.to("mps")
device = "mps"
else:
net.load_state_dict(torch.load(model_path,map_location="cpu"))
device = "cpu"
net.eval()
def resize_image(image):
image = image.convert('RGB')
model_input_size = (1024, 1024)
image = image.resize(model_input_size, Image.BILINEAR)
return image
def process(image):
# prepare input
orig_image = Image.fromarray(image)
w,h = orig_im_size = orig_image.size
image = resize_image(orig_image)
im_np = np.array(image)
im_tensor = torch.tensor(im_np, dtype=torch.float32).permute(2,0,1)
im_tensor = torch.unsqueeze(im_tensor,0)
im_tensor = torch.divide(im_tensor,255.0)
im_tensor = normalize(im_tensor,[0.5,0.5,0.5],[1.0,1.0,1.0])
if device == "cuda":
im_tensor=im_tensor.cuda()
elif device == "mps":
im_tensor=im_tensor.to("mps")
#inference
result=net(im_tensor)
# post process
result = torch.squeeze(F.interpolate(result[0][0], size=(h,w), mode='bilinear') ,0)
ma = torch.max(result)
mi = torch.min(result)
result = (result-mi)/(ma-mi)
# image to pil
im_array = (result*255).cpu().data.numpy().astype(np.uint8)
pil_im = Image.fromarray(np.squeeze(im_array))
# paste the mask on the original image
new_im = Image.new("RGBA", pil_im.size, (0,0,0,0))
new_im.paste(orig_image, mask=pil_im)
return new_im
gr.Markdown("## BRIA RMBG 1.4")
gr.HTML('''
This is a demo for BRIA RMBG 1.4 that using
BRIA RMBG-1.4 image matting model as backbone.
''')
title = "Background Removal"
description = r"""Background removal model developed by BRIA.AI, trained on a carefully selected dataset and is available as an open-source model for non-commercial use.
For test upload your image and wait. Read more at model card briaai/RMBG-1.4.
"""
examples = [['./input.jpg'],]
demo = gr.Interface(fn=process,inputs="image", outputs="image", examples=examples, title=title, description=description)
if __name__ == "__main__":
demo.launch(share=False)