first commit

.gitignore

@@ -0,0 +1,2 @@
+**venv
+main.py

app.py

@@ -1,63 +1,57 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
+import json
+from nameder import init_model_ner, get_entity_results
+from speech2text import init_model_trans, transcribe
+from translation import translate
+from resources import NER_Response, NER_Request, entity_labels_sample, set_start, audit_elapsedtime
+
+
+def translation_to_english(text: str):
+   resultado = translate(text)
+   return resultado
+
+def transcription(audio: bytes):
+    
+    s2t = init_model_trans()
+    return transcribe(audio, s2t)
+
+def named_entity_recognition(text: str):
+    tokenizer, ner = init_model_ner()
+    # print('NER:',ner)
+    result = get_entity_results(entities_list=entity_labels_sample, 
+                                model=ner,
+                                tokenizer=tokenizer,
+                                text=text)
+    print('result:',result,type(result))
+    return result
+
+def get_lead(audio: bytes):
+    start = set_start()
+    transcribe = transcription(audio)
+    translate = translation_to_english(transcribe)
+    ner = named_entity_recognition(NER_Request(
+        entities=entity_labels_sample,
+        text=translate
+    ))
+    audit_elapsedtime("VoiceLead", start)
+    return ner
+
+audio_input = gr.Microphone(
+    label="Record your audio"
+)
+text_output = gr.Textbox(
+            label="Labels",
+            info="",
+            lines=9,
+            value=""
+        )
+demo = gr.Interface(
+    fn=named_entity_recognition,
+    description= "Get the ",
+    inputs=[audio_input],
+    outputs=[text_output],
+    title="VoiceLead"
 )
-
 
 if __name__ == "__main__":
     demo.launch()

nameder.py

@@ -0,0 +1,62 @@
+from typing import List 
+from resources import set_start, audit_elapsedtime, entities_list_to_dict
+from transformers import BertTokenizer, BertForTokenClassification
+import torch
+
+#Named-Entity Recognition model
+
+def init_model_ner():
+    print("Initiating NER model...")
+    start = set_start()
+    
+    # Load pre-trained tokenizer and model
+    tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+    model = BertForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
+
+    audit_elapsedtime(function="Initiating NER model", start=start)
+    return tokenizer, model
+
+def get_entity_results(tokenizer, model, text: str, entities_list: List[str]): #-> Lead_labels:
+    print("Initiating entity recognition...")
+    start = set_start()
+    tokens = tokenizer.tokenize(tokenizer.decode(tokenizer.encode(text)))
+    labels = entities_list
+
+    # Convert tokens to IDs
+    input_ids = tokenizer.encode(text, return_tensors="pt")
+
+    # Perform NER prediction
+    with torch.no_grad():
+        outputs = model(input_ids)
+
+    # Get the predicted labels
+    predicted_labels = torch.argmax(outputs.logits, dim=2)[0]
+
+    # Map predicted labels to actual entities
+    entities = []
+    current_entity = ""
+    for i, label_id in enumerate(predicted_labels):
+        label = model.config.id2label[label_id.item()]
+        token = tokens[i]
+        if label.startswith('B-'):  # Beginning of a new entity
+            if current_entity:
+                entities.append(current_entity.strip())
+            current_entity = token
+        elif label.startswith('I-'):  # Inside of an entity
+            current_entity += " " + token
+        else:  # Outside of any entity
+            if current_entity:
+                entities.append(current_entity.strip())
+                current_entity = ""
+
+    # Filter out only the entities you are interested in
+    filtered_entities = [entity for entity in entities if entity in labels]
+    # entities_result = model.predict_entities(text, labels)
+        
+    # entities_dict = entities_list_to_dict(entities_list)
+    # for entity in entities_result:
+    #     print(entity["text"], "=>", entity["label"])
+    #     entities_dict[entity["label"]] = entity["text"]
+
+    audit_elapsedtime(function="Retreiving entity labels from text", start=start)
+    return filtered_entities

resources.py

@@ -0,0 +1,41 @@
+from pydantic import BaseModel
+from typing import Optional
+from typing import List
+import time
+
+class NER_Request (BaseModel):
+    text: str
+    entities: List[str]
+    
+class NER_Response (BaseModel):
+    success: int
+    result: str
+    description: Optional[str] = ""
+    errorCode: Optional[int] = 0
+    errorDescriptin: Optional[str] = ""
+
+entity_labels_sample = [
+    "team",
+    "developer",
+    "technology",
+    "tool",
+    "amount",
+    "duration",
+    "capacity",
+    "company",
+    "currency"
+]
+
+def entities_list_to_dict(entitiesList: List[str]):
+    return {key: 'string' for key in entitiesList}
+
+def set_start () -> time:
+    return time.time()
+
+def audit_elapsedtime(function: str, start: time):
+    end = time.time()
+    elapsedtime = end-start
+    print("------------------")
+    print(f"[{function}] Elapsed time: {elapsedtime}")
+    print("------------------")
+    return elapsedtime

speech2text.py

@@ -0,0 +1,63 @@
+from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor, pipeline
+import torch
+from resources import set_start, audit_elapsedtime 
+
+#Speech to text transcription model
+
+def init_model_trans ():
+    print("Initiating transcription model...")
+    start = set_start()
+
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
+    torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+
+    model_id = "openai/whisper-large-v3"
+
+    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+        model_id, torch_dtype=torch_dtype, low_cpu_mem_usage=True, use_safetensors=True
+    )
+    model.to(device)
+
+    processor = AutoProcessor.from_pretrained(model_id)
+
+    pipe = pipeline(
+        "automatic-speech-recognition",
+        model=model,
+        tokenizer=processor.tokenizer,
+        feature_extractor=processor.feature_extractor,
+        max_new_tokens=128,
+        chunk_length_s=30,
+        batch_size=16,
+        return_timestamps=True,
+        torch_dtype=torch_dtype,
+        device=device,
+    )
+    print(f'Init model successful')
+    audit_elapsedtime(function="Init transc model", start=start)
+    return pipe
+
+def transcribe (audio_sample: bytes, pipe) -> str:
+    print("Initiating transcription...")
+    start = set_start()
+    result = pipe(audio_sample)
+
+    audit_elapsedtime(function="Transcription", start=start)
+    print("transcription result",result)
+
+    #st.write('trancription: ', result["text"])
+    return result["text"]
+
+# def translate (audio_sample: bytes, pipe) -> str:
+#     print("Initiating Translation...")
+#     start = set_start()
+#     # dataset = load_dataset("distil-whisper/librispeech_long", "clean", split="validation")
+#     # sample = dataset[0]["audio"]
+    
+#     #result = pipe(audio_sample)
+#     result = pipe(audio_sample, generate_kwargs={"task": "translate"})
+
+#     audit_elapsedtime(function="Translation", start=start)
+#     print("Translation result",result)
+
+#     #st.write('trancription: ', result["text"])
+#     return result["text"]

translation.py

@@ -0,0 +1,26 @@
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
+from resources import set_start, audit_elapsedtime
+from pydantic import BaseModel
+
+#def get_model_name(languageCode: str) -> str:
+#    match languageCode:
+#        case "pt":
+#            model_name = "Helsinki-NLP/opus-mt-pt-en"
+#        case _:
+#            model_name
+#    
+#    return model_name
+
+def translate(text_to_translate: str) -> str:
+    
+    start = set_start()
+    print("Initiating translation model...")
+    text_size = len(text_to_translate)*2
+    tokenizer = AutoTokenizer.from_pretrained("unicamp-dl/translation-pt-en-t5")
+    model = AutoModelForSeq2SeqLM.from_pretrained("unicamp-dl/translation-pt-en-t5")
+    pten_pipeline = pipeline('text2text-generation', model=model, tokenizer=tokenizer)
+    translated_text = pten_pipeline(text_to_translate, max_new_tokens= text_size)[0]['generated_text']
+
+    elapsedtime=audit_elapsedtime(function="Finished translation", start=start)
+    print("Translated text:", translated_text)
+    return translated_text