Download pytorch/base/shared/compact_title_pointer.py from sasakiy84/bibform: direct link, hf CLI and curl.
- Browser
- Download file 5.33 kB
-
https://huggingface.co/sasakiy84/bibform/resolve/main/pytorch/base/shared/compact_title_pointer.py
- Command line
-
hf download hf://sasakiy84/bibform/pytorch/base/shared/compact_title_pointer.py
-
curl -L -o compact_title_pointer.py https://huggingface.co/sasakiy84/bibform/resolve/main/pytorch/base/shared/compact_title_pointer.py
5.33 kB
| """Score complete title spans from a frozen character representation.""" | |
| import numpy as np | |
| import torch | |
| from torch import nn | |
| from shared.dataset_schema import visible_value | |
| TITLE_ACTIONS = ('absorb_fields', 'expand', 'shrink') | |
| TITLE_POINTER_WIDTH = 96 | |
| class CompactTitlePointer(nn.Module): | |
| def __init__(self, width=TITLE_POINTER_WIDTH): | |
| super().__init__() | |
| self.character = nn.Linear(192,width) | |
| self.boundary = nn.Sequential(nn.LayerNorm(3*width+1),nn.Linear(3*width+1,width),nn.GELU()) | |
| self.unary = nn.Linear(width,2) | |
| self.start_query = nn.Linear(width,32) | |
| self.end_key = nn.Linear(width,32) | |
| def forward(self, hidden, lengths): | |
| features = self.character(hidden) | |
| offsets = torch.arange(features.size(1)+1,device=features.device) | |
| mask = offsets[:-1][None,:] < lengths[:,None] | |
| features = features * mask[...,None] | |
| edge = torch.zeros_like(features[:,:1]) | |
| before = torch.cat((edge,features),dim=1) | |
| after = torch.cat((features,edge),dim=1) | |
| context = (features.sum(1)/lengths[:,None])[:,None].expand_as(before) | |
| position = offsets[None,:].expand(hidden.size(0),-1) / lengths[:,None] | |
| boundary = self.boundary(torch.cat((before,after,context,position[...,None]),dim=-1)) | |
| unary = self.unary(boundary) | |
| return unary[...,0],unary[...,1],self.start_query(boundary)/np.sqrt(32),self.end_key(boundary) | |
| def boundary_masks(rows, width, device): | |
| start = np.zeros((len(rows),width),dtype=bool) | |
| end = np.zeros_like(start) | |
| for i,row in enumerate(rows): | |
| visible = [not char.isspace() for char in row['text']] | |
| length = len(visible) | |
| start[i,:length] = visible | |
| end[i,1:length+1] = visible | |
| return torch.from_numpy(start).to(device),torch.from_numpy(end).to(device) | |
| def title_alternatives(text, baseline, scores, actions=TITLE_ACTIONS): | |
| titles = [(i,f) for i,f in enumerate(baseline['fields']) if f['label']=='TITLE'] | |
| if len(titles) != 1: | |
| return {} | |
| title_index, title = titles[0] | |
| old_start, old_end = title['start'],title['end'] | |
| other = [(i,f['start'],f['end']) for i,f in enumerate(baseline['fields']) if i!=title_index] | |
| people = [(p['start'],p['end']) for p in baseline['contributors']] | |
| left,right,query,key = scores | |
| starts = np.array([n for n in range(max(0,old_start-12),min(len(text),old_start+13)) | |
| if not text[n].isspace()],dtype=np.int64) | |
| ends = np.array([n for n in range(max(1,old_end-100),min(len(text),old_end+100)+1) | |
| if not text[n-1].isspace()],dtype=np.int64) | |
| if not len(starts) or not len(ends): | |
| return {} | |
| values = (left[starts,None]+right[None,ends]+query[starts]@key[ends].T) | |
| valid = starts[:,None]<ends[None,:] | |
| # Only propose intervals that overlap the detected title and preserve every contributor. | |
| valid &= (starts[:,None]<old_end) & (ends[None,:]>old_start) | |
| for begin,finish in people: | |
| valid &= (starts[:,None]>=finish) | (ends[None,:]<=begin) | |
| absorbed = np.zeros_like(valid) | |
| for _,begin,finish in other: | |
| overlap = (starts[:,None]<finish) & (ends[None,:]>begin) | |
| contained = (starts[:,None]<=begin) & (ends[None,:]>=finish) | |
| valid &= (~overlap | contained) | |
| absorbed |= contained | |
| base = float(left[old_start]+right[old_end]+query[old_start]@key[old_end]) | |
| valid &= (starts[:,None]!=old_start) | (ends[None,:]!=old_end) | |
| expanding = (starts[:,None]<old_start) | (ends[None,:]>old_end) | |
| variants = {} | |
| for action,mask in zip(TITLE_ACTIONS,(absorbed,~absorbed & expanding,~absorbed & ~expanding),strict=True): | |
| if action not in actions: | |
| continue | |
| allowed = valid & mask | |
| if not allowed.any(): | |
| continue | |
| ranked = np.where(allowed,values,-np.inf) | |
| i,j = np.unravel_index(ranked.argmax(),ranked.shape) | |
| start,end = int(starts[i]),int(ends[j]) | |
| dropped = {p for p,a,b in other if start<=a and b<=end} | |
| result = [f for p,f in enumerate(baseline['fields']) if p!=title_index and p not in dropped] | |
| result.append({'label':'TITLE','start':start,'end':end,'value':visible_value(text[start:end],'TITLE')}) | |
| result.sort(key=lambda field:field['start']) | |
| variants[action] = (float(ranked[i,j])-base,{**baseline,'fields':result}) | |
| return variants | |
| def title_comparisons(rows, predictions, hidden, pointer, actions=TITLE_ACTIONS): | |
| lengths = torch.tensor([len(row['text']) for row in rows],device=hidden.device) | |
| tensors = pointer(hidden.float(),lengths) | |
| scores = [tensor.float().cpu().numpy() for tensor in tensors] | |
| return [title_alternatives(row['text'],pred,tuple(array[i] for array in scores),actions) | |
| for i,(row,pred) in enumerate(zip(rows,predictions,strict=True))] | |
| def apply_title_comparisons(predictions, alternatives, thresholds): | |
| adjusted = [] | |
| for baseline,options in zip(predictions,alternatives,strict=True): | |
| eligible = [(score-thresholds[action],action,proposal) for action,(score,proposal) in options.items() | |
| if action in thresholds and score>thresholds[action]] | |
| adjusted.append(max(eligible)[2] if eligible else baseline) | |
| return adjusted | |