Spaces:
Sleeping
Sleeping
| import os | |
| import gradio as gr | |
| from transformers import AutoProcessor, AutoModelForCausalLM | |
| from PIL import Image | |
| import torch | |
| from gtts import gTTS | |
| import spacy | |
| import requests | |
| import nltk.tree | |
| import re | |
| # Baixar o modelo de português do spaCy | |
| os.system("python -m spacy download pt_core_news_sm") | |
| # Carregar o modelo de português do spaCy | |
| nlp = spacy.load("pt_core_news_sm") | |
| # Chave para o LX-Parser | |
| key = "eb159d39469d84f0ff47167a4d89cada" | |
| # Funções de manipulação gramatical | |
| def invert_adj_n(doc, tags): | |
| frase = [] | |
| already = False | |
| for i in range(len(doc)): | |
| if already: | |
| already = False | |
| continue | |
| if doc[i].tag_ != "PUNCT": | |
| if tags[i] == "A": | |
| if i + 1 < len(tags) and tags[i + 1] == "N": | |
| frase.append(doc[i + 1].text) | |
| frase.append(doc[i].text) | |
| already = True | |
| else: | |
| frase.append(doc[i].text) | |
| else: | |
| frase.append(doc[i].text) | |
| else: | |
| frase.append(doc[i].text) | |
| return frase | |
| def adjust_adj(doc, tags): | |
| frase = [] | |
| for i in range(len(doc)): | |
| frase.append(doc[i].text) | |
| if tags[i] == "A": | |
| if i + 1 < len(tags) and tags[i + 1] == "A": | |
| frase.append("e") | |
| return frase | |
| def adjust_art(doc, tags): | |
| frase = [] | |
| already = False | |
| for i in range(len(doc)): | |
| if already: | |
| already = False | |
| continue | |
| text = doc[i].text | |
| if tags[i] == "ART" and text.lower() == "a": | |
| if i + 1 < len(doc): | |
| gender = doc[i + 1].morph.get("Gender") | |
| number = doc[i + 1].morph.get("Number") | |
| if gender and number: | |
| if gender[0] == "Masc" and number[0] == "Sing": | |
| frase.append("um") | |
| elif gender[0] == "Fem" and number[0] == "Sing": | |
| frase.append("uma") | |
| elif gender[0] == "Masc" and number[0] != "Sing": | |
| frase.append("os") | |
| else: | |
| frase.append("as") | |
| else: | |
| frase.append(text) | |
| else: | |
| frase.append(text) | |
| else: | |
| frase.append(text) | |
| return frase | |
| def create_sentence(doc, tags, frase): | |
| tmp = frase | |
| for i in range(len(doc)): | |
| text = doc[i].text | |
| if doc[i].is_sent_start: | |
| tmp[i] = tmp[i].capitalize() | |
| if doc[i].tag_ == "PUNCT": | |
| tmp[i - 1] += text | |
| return tmp | |
| def get_productions(texto): | |
| format = 'parentheses' | |
| url = "https://portulanclarin.net/workbench/lx-parser/api/" | |
| request_data = { | |
| 'method': 'parse', | |
| 'jsonrpc': '2.0', | |
| 'id': 0, | |
| 'params': { | |
| 'text': texto, | |
| 'format': format, | |
| 'key': key, | |
| }, | |
| } | |
| request = requests.post(url, json=request_data) | |
| response_data = request.json() | |
| if "error" in response_data: | |
| print("Error:", response_data["error"]) | |
| return [] | |
| else: | |
| result = response_data["result"] | |
| productions = [] | |
| tree = nltk.tree.Tree.fromstring(result) | |
| for tag in tree.productions(): | |
| if len(re.findall(r"'.*'", str(tag))) > 0: | |
| productions.append(str(tag)) | |
| return productions | |
| def get_tags(productions): | |
| tags = [] | |
| for item in productions: | |
| if isinstance(item, str): | |
| tags.append(item[:item.find(' ->')]) | |
| else: | |
| tags.append(item) | |
| for item in tags: | |
| if "'" in item: | |
| tags.remove(item) | |
| return tags | |
| def reordenar_sentenca(sentenca): | |
| if not sentenca.strip(): | |
| return sentenca | |
| sentenca = sentenca.lower() | |
| sentence = get_productions(sentenca) | |
| tags = get_tags(sentence) | |
| doc = nlp(sentenca) | |
| if tags[0] != "ART": | |
| sentenca = "A " + sentenca.strip() | |
| sentence = get_productions(sentenca) | |
| tags = get_tags(sentence) | |
| doc = nlp(sentenca) | |
| if not sentence: | |
| return sentenca.strip() | |
| aux = [] | |
| if len(tags) > 2 and tags[1] == "N" and tags[2] == "N": | |
| aux = sentenca.split() | |
| tmp = aux[1] | |
| aux[1] = aux[2] | |
| aux.insert(2, "de") | |
| aux[3] = tmp | |
| sentenca = " ".join(aux) | |
| sentence = get_productions(sentenca) | |
| tags = get_tags(sentence) | |
| doc = nlp(sentenca) | |
| frase = [] | |
| already = False | |
| person = 3 | |
| tmp_doc = [] | |
| for token in doc: | |
| tmp_doc.append(token) | |
| frase = invert_adj_n(tmp_doc, tags) | |
| nova_sentenca = ' '.join(frase) | |
| productions = get_productions(nova_sentenca) | |
| tags = get_tags(productions) | |
| doc = nlp(nova_sentenca) | |
| while nova_sentenca != sentenca: | |
| frase = invert_adj_n(doc, tags) | |
| sentenca = nova_sentenca | |
| nova_sentenca = ' '.join(frase) | |
| productions = get_productions(nova_sentenca) | |
| tags = get_tags(productions) | |
| doc = nlp(nova_sentenca) | |
| frase = adjust_adj(doc, tags) | |
| nova_sentenca = ' '.join(frase) | |
| productions = get_productions(nova_sentenca) | |
| tags = get_tags(productions) | |
| doc = nlp(nova_sentenca) | |
| while nova_sentenca != sentenca: | |
| frase = adjust_adj(doc, tags) | |
| sentenca = nova_sentenca | |
| nova_sentenca = ' '.join(frase) | |
| productions = get_productions(nova_sentenca) | |
| tags = get_tags(productions) | |
| doc = nlp(nova_sentenca) | |
| frase = adjust_art(doc, tags) | |
| sentenca = ' '.join(frase) | |
| productions = get_productions(sentenca) | |
| tags = get_tags(productions) | |
| doc = nlp(sentenca) | |
| frase = create_sentence(doc, tags, frase) | |
| sentenca_normalizada = "" | |
| for i in range(len(frase)): | |
| sentenca_normalizada += frase[i] + " " | |
| return sentenca_normalizada.strip() | |
| # Carregar os modelos | |
| processor = AutoProcessor.from_pretrained("histlearn/microsoft-git-portuguese-neuro-simbolic") | |
| model = AutoModelForCausalLM.from_pretrained("histlearn/microsoft-git-portuguese-neuro-simbolic") | |
| # Configurar o dispositivo (GPU ou CPU) | |
| device = "cuda" if torch.cuda.is_available() else "cpu" | |
| model.to(device) | |
| # Funções auxiliares | |
| def prepare_image(image_path): | |
| image = Image.open(image_path).convert("RGB") | |
| inputs = processor(images=image, return_tensors="pt").to(device) | |
| return image, inputs.pixel_values | |
| def generate_caption(pixel_values): | |
| model.eval() | |
| with torch.no_grad(): | |
| generated_ids = model.generate( | |
| pixel_values=pixel_values, | |
| max_length=50, | |
| num_beams=4, | |
| early_stopping=True, | |
| no_repeat_ngram_size=2 | |
| ) | |
| return processor.batch_decode(generated_ids, skip_special_tokens=True)[0] | |
| def text_to_speech_gtts(text, lang='pt'): | |
| tts = gTTS(text=text, lang=lang) | |
| tts.save("output.mp3") | |
| return "output.mp3" | |
| # Função principal para processar a imagem e gerar a voz | |
| def process_image(image): | |
| _, pixel_values = prepare_image(image) | |
| caption_pt = generate_caption(pixel_values) | |
| caption_pt = reordenar_sentenca(caption_pt) | |
| audio_file = text_to_speech_gtts(caption_pt) | |
| return caption_pt, audio_file | |
| # Caminhos para as imagens de exemplo | |
| example_image_paths = [ | |
| "main/example1.jpeg", | |
| "main/example2.jpeg", | |
| "main/example3.jpeg" | |
| ] | |
| # Interface Gradio | |
| iface = gr.Interface( | |
| fn=process_image, | |
| inputs=gr.Image(type="filepath"), | |
| outputs=[gr.Textbox(), gr.Audio(type="filepath")], | |
| examples=example_image_paths, | |
| title="Image to Voice", | |
| description="Gera uma descrição em português e a converte em voz a partir de uma imagem." | |
| ) | |
| if __name__ == "__main__": | |
| iface.launch() | |