Datasets:
File size: 8,504 Bytes
77fb120 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 | 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 |