Datasets:
File size: 15,810 Bytes
7424015 | 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 219 220 221 222 223 224 225 226 227 | """Independent RegalFire label validators. Does not import generator or its oracles."""
import argparse
from collections import Counter, deque, defaultdict
import heapq
import json
from pathlib import Path
import zlib
from jsonschema import Draft202012Validator
from common import NAMES,FAMILIES,enc,sha,semantic,split,strict,schema,write_json
def assert_true(ok,reason):
if not ok:raise ValueError(reason)
def grid_info(inp):
grid=inp['grid'];h,w=len(grid),len(grid[0]);assert_true(all(len(row)==w for row in grid),'nonrectangular_grid')
free={(y,x) for y,row in enumerate(grid) for x,v in enumerate(row) if v=='.'}
return grid,h,w,free
def relaxation(grid,costs,start,target):
h,w=len(grid),len(grid[0]);dist={tuple(start):0}
# Bellman-style relaxations over all directed adjacent vertices, unlike A*.
for _ in range(h*w):
changed=False
for y in range(h):
for x in range(w):
if grid[y][x]!='.' or (y,x) not in dist:continue
value=dist[(y,x)]
for v in [(y-1,x),(y,x-1),(y+1,x),(y,x+1)]:
a,b=v
if 0<=a<h and 0<=b<w and grid[a][b]=='.' and value+costs[a][b]<dist.get(v,10**12):
dist[v]=value+costs[a][b];changed=True
if not changed:break
return dist.get(tuple(target))
def check_path(grid,costs,start,goal,result,best):
assert_true(result['cost']==best,'path_cost_oracle_disagreement')
if best is None:assert_true(result['path'] is None,'unreachable_path');return
path=result['path'];assert_true(path and path[0]==start and path[-1]==goal,'bad_endpoints')
for p in path:
assert_true(len(p)==2 and 0<=p[0]<len(grid) and 0<=p[1]<len(grid[0]) and grid[p[0]][p[1]]=='.','illegal_path_cell')
assert_true(all(abs(a[0]-b[0])+abs(a[1]-b[1])==1 for a,b in zip(path,path[1:])),'illegal_path_step')
assert_true(sum(costs[y][x] for y,x in path[1:])==best,'witness_cost_disagreement')
def nav(inp,out):
g,h,w,free=grid_info(inp);costs=inp['costs'];s,t,edit=inp['start'],inp['goal'],inp['edit']
assert_true(tuple(s) in free and tuple(t) in free and s!=t,'invalid_endpoints')
assert_true(len(costs)==h and all(len(row)==w for row in costs),'cost_dimensions')
assert_true(0<=edit[0]<h and 0<=edit[1]<w and edit not in [s,t],'invalid_edit')
changed=list(g);y,x=edit;row=list(changed[y]);row[x]='.' if row[x]=='#' else '#';changed[y]=''.join(row)
before=relaxation(g,costs,s,t);after=relaxation(changed,costs,s,t)
assert_true(before!=after,'noncritical_edit')
check_path(g,costs,s,t,out['before'],before);check_path(changed,costs,s,t,out['after'],after)
assert_true(out['reachability_changed']==((before is None)!=(after is None)),'reachability_label')
assert_true(set(out)=={'before','after','reachability_changed'},'expected_schema')
def goal_distances(free,goal):
d={tuple(goal):0};q=deque([tuple(goal)])
while q:
a=q.popleft()
for b in [(a[0]-1,a[1]),(a[0]+1,a[1]),(a[0],a[1]-1),(a[0],a[1]+1)]:
if b in free and b not in d:d[b]=d[a]+1;q.append(b)
return d
def joint_astar(free,starts,goals):
start=tuple(map(tuple,starts));target=tuple(map(tuple,goals));d0=goal_distances(free,target[0]);d1=goal_distances(free,target[1])
if start[0] not in d0 or start[1] not in d1:return None,None
lb=max(d0[start[0]],d1[start[1]])
adjacency={p:[p]+[v for v in [(p[0],p[1]-1),(p[0]-1,p[1]),(p[0],p[1]+1),(p[0]+1,p[1])] if v in free] for p in free}
queue=[(lb,0,start)];best={start:0}
while queue:
_,cost,p=heapq.heappop(queue)
if best[p]!=cost:continue
if p==target:return cost,lb
choices0=[p[0]] if p[0]==target[0] else adjacency[p[0]]
choices1=[p[1]] if p[1]==target[1] else adjacency[p[1]]
for a in choices0:
for b in choices1:
if a==b or (a==p[1] and b==p[0]):continue
state=(a,b);new=cost+1
if new<best.get(state,10**9):
best[state]=new;heapq.heappush(queue,(new+max(d0.get(a,10000),d1.get(b,10000)),new,state))
return None,lb
def coord(inp,out):
_,_,_,free=grid_info(inp);s,t=inp['starts'],inp['goals']
assert_true(all(tuple(p) in free for p in s+t) and s[0]!=s[1] and t[0]!=t[1],'invalid_agent_endpoints')
optimum,lower=joint_astar(free,s,t)
assert_true(out['optimal_makespan']==optimum and out['independent_lower_bound']==lower,'joint_oracle_disagreement')
assert_true(out['coordination_overhead']==(optimum-lower if optimum is not None else None),'overhead_label')
if optimum is None:assert_true(out['plan'] is None,'infeasible_plan');return
plan=out['plan'];assert_true(len(plan)==optimum+1 and plan[0]==s and plan[-1]==t,'joint_witness_length')
for state in plan:assert_true(len(state)==2 and state[0]!=state[1] and all(tuple(p) in free for p in state),'vertex_conflict_or_invalid_cell')
for a,b in zip(plan,plan[1:]):
assert_true(not (a[0]==b[1] and a[1]==b[0]),'edge_swap')
for j in range(2):
assert_true(sum(abs(x-y) for x,y in zip(a[j],b[j]))<=1,'agent_teleport')
if a[j]==t[j]:assert_true(b[j]==t[j],'left_absorbing_goal')
assert_true(set(out)=={'plan','optimal_makespan','independent_lower_bound','coordination_overhead'},'expected_schema')
def reads(inp,out):
lines=inp['fastq'].split('\n');assert_true(len(lines)==4,'FASTQ_not_four_lines')
h,s,sep,q=lines;assert_true(h in ['@synthetic_read','synthetic_read'],'non_synthetic_header')
failures=set()
if not h or h[0]!='@':failures.add('header')
if sep!='+':failures.add('separator')
if set(s)-set('ACGTN'):failures.add('alphabet')
if len(q)!=len(s):failures.add('quality_length')
if not all('!'<=c<='J' for c in q):failures.add('quality_ascii')
expected={'valid_fastq':not failures,'errors':sorted(failures),'passed_filter':False,'trimmed_sequence':None,'trimmed_quality':None,'quality_sum':None,'length':None,'n_count':None,'gc_count':None}
if not failures:
policy=inp['policy'];qualities=[ord(c)-ord('!') for c in q]
kept=[i+1 for i,value in enumerate(qualities) if value>=policy['trim_q_min']]
stop=max(kept,default=0);s=s[:stop];q=q[:stop]
counts=Counter(s);total=sum(qualities[:stop])
passing=stop>=policy['min_length'] and counts['N']<=policy['max_n'] and total>=stop*policy['mean_q_min']
expected.update(passed_filter=passing,trimmed_sequence=s,trimmed_quality=q,quality_sum=total,length=stop,n_count=counts['N'],gc_count=counts['G']+counts['C'])
assert_true(enc(expected)==enc(out),'read_QC_oracle_disagreement')
def myers(a,b):
if not a:return len(b)
masks={}
for i,letter in enumerate(a):masks[letter]=masks.get(letter,0)|(1<<i)
positive=~0;negative=0;score=len(a);top=1<<(len(a)-1)
for letter in b:
equal=masks.get(letter,0);vertical=equal|negative
horizontal=(((equal&positive)+positive)^positive)|equal
plus=negative|~(horizontal|positive);minus=positive&horizontal
if plus&top:score+=1
if minus&top:score-=1
plus=(plus<<1)|1;minus<<=1
positive=minus|~(vertical|plus);negative=plus&vertical
return score
def align(inp,out):
a,b=inp['a'],inp['b'];distance=myers(a,b)
assert_true(inp['source_sequence']==a,'source_sequence_mismatch')
assert_true(out['edit_distance']==distance and out['within_threshold']==(distance<=inp['threshold']),'alignment_oracle_disagreement')
aa,bb=out['aligned_a'],out['aligned_b']
assert_true(len(aa)==len(bb) and aa.replace('-','')==a and bb.replace('-','')==b,'alignment_witness_sequence')
assert_true(all(not(x=='-' and y=='-') for x,y in zip(aa,bb)),'double_gap')
assert_true(sum(x!=y for x,y in zip(aa,bb))==distance,'nonoptimal_alignment_witness')
assert_true(set(out)=={'edit_distance','within_threshold','aligned_a','aligned_b'},'expected_schema')
def intervals(inp,out):
def positions(item):
assert_true(item['contig'] in inp['contigs'] and item['contig'].startswith('synthetic_'),'invalid_synthetic_contig')
start=item['start'];end=item['end']
if item['basis']=='one_closed':
assert_true(1<=start<=end,'invalid_one_based_interval');start-=1
assert_true(0<=start<=end<=inp['contigs'][item['contig']],'out_of_bounds_interval')
return set(range(start,end)),start,end
q=inp['query'];qset,a,b=positions(q);matches=[];covered=set()
for i,f in enumerate(inp['features']):
fset,_,_=positions(f)
if f['contig']!=q['contig'] or (inp['same_strand'] and f['strand']!=q['strand']):continue
overlap=fset&qset
if overlap:matches.append({'feature_index':i,'overlap_bases':len(overlap)});covered |= overlap
expected={'query_bed':[a,b],'matches':matches,'union_overlap_bases':len(covered),'query_length':len(qset)}
assert_true(enc(expected)==enc(out),'interval_oracle_disagreement')
CHECKS={'nav':nav,'coord':coord,'reads':reads,'align':align,'intervals':intervals}
class NearAudit:
def __init__(self):self.buckets=defaultdict(list);self.flagged=[];self.examined=0
def add(self,row,kind):
if kind not in ['reads','align']:return
seq=row['input']['source_sequence'] if kind=='align' else row['input']['fastq'].split('\n')[1]
grams={seq[i:i+7] for i in range(len(seq)-6)}
if not grams:return
bottom=sorted({zlib.crc32(g.encode()) for g in grams})[:4];seen=set()
for i,key in enumerate(bottom):
bucket=self.buckets[(i,key)]
for old,oldgrams in bucket[-25:]:
if old['id'] in seen:continue
seen.add(old['id']);self.examined+=1
score=len(grams&oldgrams)/len(grams|oldgrams)
if score>=.85 and row['group_id']!=old['group_id'] and row['split']!=old['split']:
self.flagged.append({'left':old['id'],'right':row['id'],'jaccard':score})
bucket.append(({'id':row['id'],'group_id':row['group_id'],'split':row['split']},grams))
if len(bucket)>25:del bucket[0]
def validate(kind,path,count,out):
path=Path(path);out=Path(out);out.mkdir(parents=True,exist_ok=True)
rejected=[];total=0;ids=set();fingerprints=set();groups={};splits=Counter();families=Counter();labels=Counter();near=NearAudit()
validator=Draft202012Validator(schema(kind))
if not path.is_file():rejected.append({'line':0,'reasons':['missing_dataset_file']})
else:
with path.open(encoding='utf-8') as stream:
for line_number,line in enumerate(stream,1):
total+=1
try:
row=strict(line);validator.validate(row)
assert_true(row['id']==kind.upper()+f'-{line_number-1:07d}' and row['index']==line_number-1,'id_or_index_sequence')
assert_true(row['id'] not in ids,'duplicate_id');ids.add(row['id'])
fp,group=semantic(kind,row['input'])
assert_true(row['fingerprint']==fp and fp not in fingerprints,'duplicate_or_invalid_semantic_fingerprint');fingerprints.add(fp)
assert_true(group==row['group_id'] and split(group)==row['split'],'group_split_mismatch')
assert_true(group not in groups or groups[group]==row['split'],'split_leakage');groups[group]=row['split']
if kind=='coord' and row['family']=='crossing':
a,b=row['input']['starts']
assert_true(a[0]==b[0] and abs(a[1]-b[1])>=2 and row['input']['goals']==row['input']['starts'][::-1],'crossing_family_contract')
if kind=='coord' and row['family']=='adjacent_swap':
a,b=row['input']['starts']
assert_true(abs(a[0]-b[0])+abs(a[1]-b[1])==1 and row['input']['goals']==row['input']['starts'][::-1],'swap_family_contract')
CHECKS[kind](row['input'],row['expected']);near.add(row,kind)
splits[row['split']]+=1;families[row['family']]+=1
if kind=='nav':labels['reachability_changed' if row['expected']['reachability_changed'] else 'cost_only_changed']+=1
elif kind=='coord':labels['solvable' if row['expected']['optimal_makespan'] is not None else 'unsolvable']+=1
elif kind=='reads':labels['format_invalid' if not row['expected']['valid_fastq'] else 'filter_pass' if row['expected']['passed_filter'] else 'filter_fail']+=1
elif kind=='align':labels['within_threshold' if row['expected']['within_threshold'] else 'outside_threshold']+=1
else:labels['overlap' if row['expected']['union_overlap_bases'] else 'no_overlap']+=1
except Exception as exc:
rejected.append({'line':line_number,'raw':line.rstrip('\n'),'reasons':[type(exc).__name__+': '+str(exc)[:500]]})
if total%1000==0:print(f'{kind}: independently checked {total}/{count}',flush=True)
problems=[]
if total!=count:problems.append('record_count')
if rejected:problems.append('rejected_records')
if near.flagged:problems.append('near_duplicate_cross_split_candidates')
if set(families)!=set(FAMILIES[kind]) or any(n!=count//5 for n in families.values()):problems.append('family_distribution')
if any(splits[k]==0 for k in ['train','validation','test']):problems.append('missing_split')
report={'brand':'RegalFire','kind':kind,'status':'PASS' if not problems else 'FAIL','expected_records':count,'records_read':total,'accepted':sum(families.values()),'rejected':len(rejected),'problems':problems,
'unique_ids':len(ids),'unique_fingerprints':len(fingerprints),'unique_source_groups':len(groups),'splits':dict(splits),'families':dict(families),'labels':dict(labels),
'dataset_sha256':sha(path.read_text(encoding='utf-8')) if path.exists() else None,
'near_duplicate_audit':{'scope':'DNA 7-mer bottom-4 CRC sketches; at most 25 previous candidates per bucket; Jaccard >=0.85 flags cross-split source groups. Not exhaustive homology testing. Grid symmetry and interval translation are exact semantic canonical checks.','candidate_pairs_examined':near.examined,'cross_split_flags':near.flagged},
'privacy_scope':'All originals are procedural; synthetic headers/contigs checked. No external biological records or game assets. Computational fixtures only, not clinical or experimentally established biology.'}
write_json(out/'validation_report.json',report);write_json(out/'stats.json',{k:report[k] for k in ['records_read','splits','families','labels','unique_source_groups']})
(out/'rejected.jsonl').write_text(''.join(enc(r)+'\n' for r in rejected),encoding='utf-8')
(out/'QA_REPORT.md').write_text('# RegalFire independent computational QA\n\nStatus: '+report['status']+'\n\n```json\n'+json.dumps(report,indent=2)+'\n```\n\nGenerator and validator label algorithms are separately implemented. Shared code covers serialization, schema and semantic identity only. Independent code is not independent human or biological validation. Seed reproducibility and file packaging integrity are separate recorded gates.\n',encoding='utf-8')
print(enc({k:report[k] for k in ['kind','status','accepted','rejected','problems']}),flush=True)
return report
def main():
p=argparse.ArgumentParser();p.add_argument('--kind',choices=NAMES,required=True);p.add_argument('--dataset',type=Path,required=True);p.add_argument('--count',type=int,required=True);p.add_argument('--out',type=Path,required=True);a=p.parse_args()
return 0 if validate(a.kind,a.dataset,a.count,a.out)['status']=='PASS' else 1
if __name__=='__main__':raise SystemExit(main())
|