import stanza class ClassicExtractorV2: def __init__(self): self.rules = { 'who': ['nsubj', 'nsubj:pass', 'csubj', 'agent'], 'what_verb': ['root'], 'what_obj': ['obj', 'ccomp', 'xcomp'], 'circumstantial': ['obl', 'advmod'], 'why_markers': ['porque', 'debido', 'causa', 'pues'] } # Pronombres personales anafóricos que SÍ necesitan resolución self.anaphoric_pronouns = { 'él', 'ella', 'ellos', 'ellas', 'este', 'esta', 'estos', 'estas', 'ese', 'esa', 'esos', 'esas', 'aquel', 'aquella', 'aquellos', 'aquellas', 'lo', 'la', 'los', 'las', 'le', 'les', 'quien', 'quienes' # Solo cuando NO son relativos (interrogativos) } # Pronombres relativos que NO necesitan resolución (su antecedente es sintáctico) self.relative_pronouns = {'que', 'cual', 'cuales', 'cuyo', 'cuya', 'cuyos', 'cuyas'} # MEMORIA: Lista de candidatos recientes self.context_memory = [] def reset_context(self): self.context_memory = [] def _infer_gender(self, word): """Intenta inferir el género si Stanza no lo da.""" feats = {} if word.feats: for pair in word.feats.split('|'): if '=' in pair: k, v = pair.split('=') feats[k] = v gender = feats.get('Gender') if not gender and word.upos == 'PROPN': if word.text.endswith('a') or word.text.endswith('as'): gender = 'Fem' elif word.text.endswith('o') or word.text.endswith('os'): gender = 'Masc' return gender, feats.get('Number') def _is_anaphoric_pronoun(self, word): """ Determina si un pronombre necesita resolución de correferencia. Retorna True solo para pronombres personales/demostrativos anafóricos. """ if word.upos != 'PRON': return False text_lower = word.text.lower() # Los pronombres relativos NO necesitan resolución if text_lower in self.relative_pronouns: return False # Verificar por features de Stanza si es relativo if word.feats: if 'PronType=Rel' in word.feats: return False # Solo resolver si es un pronombre anafórico conocido return text_lower in self.anaphoric_pronouns def get_span_data(self, word, sent, ner_map, dbpedia_ents=None): def get_descendants(head_id, words_list): children = [w.id for w in words_list if w.head == head_id] descendants = [head_id] for child in children: descendants.extend(get_descendants(child, words_list)) return descendants subtree_ids = get_descendants(word.id, sent.words) subtree_words = [ sent.words[i-1] for i in subtree_ids if sent.words[i-1].start_char is not None and sent.words[i-1].end_char is not None ] if not subtree_words: return {"span": "", "start": -1, "end": -1, "uri": None, "type": None} start_char = min(w.start_char for w in subtree_words) end_char = max(w.end_char for w in subtree_words) subtree_words.sort(key=lambda w: w.id) text_span = " ".join([w.text for w in subtree_words]) entity_type = ner_map.get(word.id, None) uri = None if dbpedia_ents: for ent in dbpedia_ents: ent_text = ent.get('text', ent.get('surfaceForm', '')) if ent_text and ent_text in text_span: uri = ent.get('uri') break return { "span": text_span, "start": start_char, "end": end_char, "uri": uri, "type": entity_type } def _update_memory(self, word, span_data): """Añade un candidato a la memoria.""" gender, number = self._infer_gender(word) candidate = { 'gender': gender, 'number': number, 'data': span_data } self.context_memory.append(candidate) if len(self.context_memory) > 5: self.context_memory.pop(0) def _resolve_coreference(self, word): """Busca antecedente compatible.""" p_gender, p_number = self._infer_gender(word) for candidate in reversed(self.context_memory): c_gender = candidate['gender'] c_number = candidate['number'] match_gender = True if p_gender and c_gender: match_gender = (p_gender == c_gender) match_number = True if p_number and c_number: match_number = (p_number == c_number) if match_gender and match_number: return candidate['data'] return None def extract(self, sent, dbpedia_ents=None): event = { "who": [], "what": [], "when": [], "where": [], "why": [], "how": [] } ner_map = {} for ent in sent.ents: for word in sent.words: if (word.start_char is not None and word.end_char is not None and ent.start_char is not None and ent.end_char is not None): if word.start_char >= ent.start_char and word.end_char <= ent.end_char: ner_map[word.id] = ent.type root_verb = None for word in sent.words: if word.start_char is None: continue dep = word.deprel span_data = self.get_span_data(word, sent, ner_map, dbpedia_ents) # WHO if dep in self.rules['who']: # CAMBIO CLAVE: Solo resolver correferencia para pronombres anafóricos if self._is_anaphoric_pronoun(word): antecedent = self._resolve_coreference(word) if antecedent: span_data['uri'] = antecedent['uri'] span_data['type'] = antecedent['type'] span_data['span'] = f"{span_data['span']} (Ref: {antecedent['span']})" elif word.upos in ['NOUN', 'PROPN']: if len(span_data['span']) > 2: self._update_memory(word, span_data) event["who"].append(span_data) # WHAT if dep == 'root': root_verb = word event["what"].append({ "span": word.text, "start": word.start_char, "end": word.end_char, "uri": None, "type": None }) if dep in self.rules['what_obj'] and word.head == (root_verb.id if root_verb else -1): # (Mejora futura): En frases con orden OVS (e.g., "A María la vi ayer"), # el objeto aparece ANTES del verbo root, por lo que root_verb aún es None # cuando se procesa. Solución: hacer dos pasadas (1a para encontrar root, # 2a para extraer argumentos). Impacto bajo en corpus periodístico (<5% frases). if word.upos in ['NOUN', 'PROPN']: self._update_memory(word, span_data) event["what"].append(span_data) # RESTO if dep in self.rules['circumstantial']: entity_type = ner_map.get(word.id, "O") if entity_type in ['LOC', 'GPE']: event["where"].append(span_data) elif entity_type in ['DATE', 'TIME']: event["when"].append(span_data) else: event["how"].append(span_data) if dep == 'mark' and word.text.lower() in self.rules['why_markers']: head_id = word.head if head_id > 0: head_word = sent.words[head_id-1] event["why"].append(self.get_span_data(head_word, sent, ner_map, dbpedia_ents)) placeholder = {"span": "", "start": -1, "end": -1, "uri": None, "type": None} for key in event: if not event[key]: event[key] = [placeholder] return event