Upload 3 files

app.py

@@ -0,0 +1,161 @@
+"""
+app.py
+
+Interface Gradio para o Modelo de Extração de Entidades (SKILL, EXPERIENCE_DURATION)
+Carrega o modelo treinado e fornece uma UI para comparar CV e JD.
+"""
+
+import gradio as gr
+import re
+from typing import List, Dict, Set
+
+# Importa o extrator que já criamos
+# HF Spaces irá executar isso da raiz, então o caminho 'scripts' está correto.
+from scripts.inference import EntityExtractor
+
+# --- 1. Carregamento do Modelo ---
+# Carrega o modelo na memória apenas uma vez, quando o app inicia.
+# Certifique-se de que este caminho está correto para onde o HF Spaces irá encontrá-lo.
+MODEL_PATH = "feliponi/hirly-ner-multi"
+try:
+    extractor = EntityExtractor(MODEL_PATH)
+    print(f"Modelo carregado com sucesso de {MODEL_PATH}")
+except Exception as e:
+    print(f"ERRO CRÍTICO: Não foi possível carregar o modelo de {MODEL_PATH}.")
+    print("Certifique-se de que o modelo treinado está no diretório correto.")
+    # Se o modelo não carregar, o Gradio falhará, o que é esperado.
+    extractor = None
+
+# --- 2. Lógica de Negócio (Nova) ---
+
+def parse_and_sum_experience(entities: List[Dict]) -> float:
+    """
+    Analisa os spans de 'EXPERIENCE_DURATION' e os soma em anos.
+    Esta é uma lógica de negócio e pode ser complexa.
+    
+    Exemplos de conversão:
+    - "5+ years" -> 5.0
+    - "6 months"  -> 0.5
+    - "3-5 anos"  -> 3.0 (pegamos o primeiro número)
+    - "two years" -> 2.0
+    """
+    total_experience = 0.0
+    
+    # Mapeamento simples de palavras para números
+    num_words = {
+        'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5,
+        'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'ten': 10
+    }
+    
+    # Filtra apenas as entidades de experiência
+    durations = [e['entity'].lower() for e in entities if e['label'] == 'EXPERIENCE_DURATION']
+    
+    for text in durations:
+        found_number = None
+        
+        # 1. Tenta encontrar números (dígitos, ex: "5", "5.5", "3-5")
+        # Pega o primeiro número que encontrar
+        match = re.search(r'(\d+[\.,]\d+|\d+)', text)
+        if match:
+            found_number = float(match.group(1).replace(',', '.'))
+        else:
+            # 2. Tenta encontrar números por extenso
+            for word, number in num_words.items():
+                if word in text:
+                    found_number = number
+                    break
+        
+        if found_number is not None:
+            # 3. Verifica a unidade (meses ou anos)
+            if 'month' in text or 'mes' in text:
+                total_experience += found_number / 12
+            else:
+                # Assume "anos" (years) como padrão
+                total_experience += found_number
+                
+    return round(total_experience, 1)
+
+
+def analyze_cv_and_jd(cv_text: str, jd_text: str) -> (str, str, str, List[str], List[str]):
+    """
+    Função principal que o Gradio irá chamar.
+    Processa o CV e o JD, encontra skills, soma experiências e compara.
+    """
+    if not extractor:
+        return "ERRO: Modelo não carregado.", "", "", [], []
+
+    # 1. Processa ambos os textos
+    cv_entities = extractor.extract_entities_with_details(cv_text, confidence_threshold=0.7)
+    jd_entities = extractor.extract_entities_with_details(jd_text, confidence_threshold=0.7)
+    
+    # 2. Soma a experiência (lógica de negócio)
+    cv_exp = parse_and_sum_experience(cv_entities)
+    jd_exp = parse_and_sum_experience(jd_entities)
+    
+    # 3. Compara as skills
+    cv_skills = {e['entity'].lower() for e in cv_entities if e['label'] == 'SKILL'}
+    jd_skills = {e['entity'].lower() for e in jd_entities if e['label'] == 'SKILL'}
+    
+    matching_skills = cv_skills.intersection(jd_skills)
+    cv_only_skills = cv_skills - jd_skills
+    jd_only_skills = jd_skills - cv_skills
+    
+    # 4. Formata a saída
+    match_output = f"""
+    ## 🚀 Análise de Match
+    
+    **Skills Compatíveis (Encontradas em ambos): {len(matching_skills)}**
+    ---
+    {', '.join(sorted(list(matching_skills))) if matching_skills else 'Nenhuma skill compatível encontrada.'}
+    """
+    
+    cv_exp_str = f"{cv_exp} anos"
+    jd_exp_str = f"{jd_exp} anos (Nota: A extração de JDs pode listar o requisito, ex: '5+ anos')"
+    
+    return (
+        match_output, 
+        cv_exp_str, 
+        jd_exp_str, 
+        sorted(list(cv_only_skills)), 
+        sorted(list(jd_only_skills))
+    )
+
+# --- 3. Definição da Interface Gradio ---
+
+with gr.Blocks(title="Hirly - Analisador de CV/JD") as demo:
+    gr.Markdown("# 🚀 Analisador de CV vs. Job Description")
+    gr.Markdown(
+        "Forneça o texto de um CV e de um Job Description (JD) para extrair "
+        "skills, anos de experiência e ver a compatibilidade entre eles."
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            cv_input = gr.Textbox(lines=20, label="Texto do Currículo (CV)")
+        with gr.Column():
+            jd_input = gr.Textbox(lines=20, label="Texto do Job Description (JD)")
+            
+    analyze_button = gr.Button("Analisar Compatibilidade", variant="primary")
+    
+    gr.Markdown("---")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            match_output = gr.Markdown(label="Resultado do Match")
+        with gr.Column(scale=1):
+            cv_exp_output = gr.Textbox(label="Experiência Total (CV)", interactive=False)
+            jd_exp_output = gr.Textbox(label="Experiência Total (JD)", interactive=False)
+            
+    with gr.Row():
+        cv_only_output = gr.JSON(label="Skills Encontradas Apenas no CV")
+        jd_only_output = gr.JSON(label="Skills Exigidas Apenas no JD")
+
+    # Conecta o botão à função
+    analyze_button.click(
+        fn=analyze_cv_and_jd,
+        inputs=[cv_input, jd_input],
+        outputs=[match_output, cv_exp_output, jd_exp_output, cv_only_output, jd_only_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,4 @@
+torch>=2.0.0
+transformers>=4.35.0
+gradio>=4.0.0
+accelerate

scripts/inference.py

@@ -0,0 +1,162 @@
+"""
+inference.py (MULTI-LABEL)
+
+Inferência de extração de MÚLTIPLAS ENTIDADES (SKILL, EXPERIENCE_DURATION).
+
+Execução:
+    python scripts/inference.py --model-path models/skill_ner_multi --text "Experienced Python developer with 5+ years of experience."
+"""
+
+import argparse
+import logging
+from typing import List, Dict
+import torch
+from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+class EntityExtractor:
+    """Extrator de entidades (SKILL, EXPERIENCE_DURATION) usando modelo NER treinado."""
+
+    def __init__(self, model_path: str, device: str = None):
+        self.model_path = model_path
+
+        if device is None:
+            self.device = 0 if torch.cuda.is_available() else -1
+        else:
+            self.device = 0 if device == "cuda" else -1
+
+        logger.info(f"Carregando modelo de {model_path}...")
+
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+            self.model = AutoModelForTokenClassification.from_pretrained(model_path)
+        except Exception as e:
+            logger.error(
+                f"Erro ao carregar modelo de {model_path}. Verifique o caminho."
+            )
+            raise e
+
+        logger.info(f"Usando device: {'GPU' if self.device == 0 else 'CPU'}")
+
+        # Cria pipeline de NER
+        # A estratégia 'simple' agrupará B-SKILL/I-SKILL em SKILL
+        # e B-EXPERIENCE_DURATION/I-EXPERIENCE_DURATION em EXPERIENCE_DURATION
+        self.ner_pipeline = pipeline(
+            "ner",
+            model=self.model,
+            tokenizer=self.tokenizer,
+            aggregation_strategy="simple",
+            device=self.device,
+        )
+
+        logger.info("Modelo carregado com sucesso!")
+
+    def extract_skills(self, text: str, confidence_threshold: float = 0.5) -> List[str]:
+        """
+        Extrai APENAS skills (para manter compatibilidade).
+        """
+        entities = self.extract_entities_with_details(text, confidence_threshold)
+
+        # Filtra apenas por SKILL
+        skills = [e["entity"] for e in entities if e["label"] == "SKILL"]
+
+        # Remove duplicatas
+        seen = set()
+        unique_skills = []
+        for skill in skills:
+            skill_lower = skill.lower()
+            if skill_lower not in seen:
+                seen.add(skill_lower)
+                unique_skills.append(skill)
+        return unique_skills
+
+    def extract_entities_with_details(
+        self, text: str, confidence_threshold: float = 0.5
+    ) -> List[Dict]:
+        """
+        Extrai TODAS as entidades com detalhes (SKILL, EXPERIENCE_DURATION, etc.)
+        """
+        if not text or not isinstance(text, str):
+            return []
+
+        text = " ".join(text.split())
+        if not text:
+            return []
+
+        try:
+            # O pipeline retorna todas as entidades agrupadas
+            entities = self.ner_pipeline(text)
+        except Exception as e:
+            logger.error(f"Erro durante a inferência do pipeline: {e}")
+            return []
+
+        detailed_entities = []
+        for entity in entities:
+            if entity["score"] >= confidence_threshold:
+                detailed_entities.append(
+                    {
+                        "entity": entity["word"].strip(" .,;:"),
+                        "label": entity[
+                            "entity_group"
+                        ],  # Ex: 'SKILL' ou 'EXPERIENCE_DURATION'
+                        "start": entity["start"],
+                        "end": entity["end"],
+                        "confidence": round(float(entity["score"]), 3),
+                    }
+                )
+
+        return detailed_entities
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extrai entidades de textos")
+    parser.add_argument(
+        "--model-path", type=str, required=True, help="Caminho do modelo treinado"
+    )
+    parser.add_argument("--text", type=str, help="Texto para extrair entidades")
+    parser.add_argument("--file", type=str, help="Arquivo de texto para processar")
+    parser.add_argument(
+        "--confidence", type=float, default=0.5, help="Threshold de confidence (0-1)"
+    )
+
+    # Removido --detailed, pois a saída padrão agora é detalhada
+
+    args = parser.parse_args()
+
+    try:
+        extractor = EntityExtractor(args.model_path)
+    except Exception as e:
+        logger.error(f"Falha ao inicializar EntityExtractor: {e}")
+        return
+
+    if args.file:
+        logger.info(f"Lendo texto de {args.file}...")
+        try:
+            with open(args.file, "r", encoding="utf-8") as f:
+                text = f.read()
+        except FileNotFoundError:
+            logger.error(f"Arquivo não encontrado: {args.file}")
+            return
+    elif args.text:
+        text = args.text
+    else:
+        logger.error("Error: Especifique --text ou --file")
+        return
+
+    # Extrai todas as entidades
+    results = extractor.extract_entities_with_details(text, args.confidence)
+
+    print(f"\nExtracted {len(results)} entities:\n")
+    for result in results:
+        print(
+            f"  [{result['label']:<21}] {result['entity']:<30} confidence: {result['confidence']:.3f}"
+        )
+
+
+if __name__ == "__main__":
+    main()