285 lines
28 KiB
Python
285 lines
28 KiB
Python
CONTEXT = {'quant_console.cpp': '#include "channel_quant.hpp"\n#include <charconv>\n#include <iostream>\n#include <limits>\n#include <sstream>\n#include <string>\n#include <vector>\n\nnamespace {\nusing U64 = std::uint64_t;\nusing I64 = std::int64_t;\nusing channel_quant::Tensor;\nusing channel_quant::QuantParam;\n\nclass Arguments {\npublic:\n explicit Arguments(const std::vector<std::string> &words) : words_(words) {}\n template<class Number>\n bool next(Number &value)\n {\n if (position_ == words_.size()) return false;\n const std::string &token = words_[position_++];\n const auto result = std::from_chars(token.data(), token.data() + token.size(), value);\n return result.ec == std::errc{} && result.ptr == token.data() + token.size();\n }\n bool done() const { return position_ == words_.size(); }\nprivate:\n const std::vector<std::string> &words_;\n std::size_t position_ = 1;\n};\n\nstd::vector<std::string> words(const std::string &line)\n{\n std::istringstream stream(line);\n std::vector<std::string> result;\n std::string token;\n while (stream >> token) result.push_back(token);\n return result;\n}\n\ntemplate<class Number>\nvoid csv(const std::vector<Number> &values)\n{\n if (values.empty()) std::cout << \'-\';\n for (std::size_t index = 0; index < values.size(); ++index) {\n if (index != 0) std::cout << \',\';\n std::cout << values[index];\n }\n}\n\nvoid parameters(const std::vector<QuantParam> ¶ms)\n{\n if (params.empty()) std::cout << \'-\';\n for (std::size_t index = 0; index < params.size(); ++index) {\n if (index != 0) std::cout << \';\';\n const QuantParam &p = params[index];\n std::cout << p.numerator << \',\' << p.denominator << \',\' << p.zero << \',\' << p.qmin << \',\' << p.qmax;\n }\n}\n\nvoid hash_word(U64 &hash, U64 word)\n{\n for (unsigned byte = 0; byte < 8; ++byte) {\n hash ^= (word >> (byte * 8)) & 255;\n hash *= 1099511628211ULL;\n }\n}\n\ntemplate<class Number>\nvoid hash_vector(U64 &hash, const std::vector<Number> &values)\n{\n hash_word(hash, static_cast<U64>(values.size()));\n for (Number value : values) hash_word(hash, static_cast<U64>(value));\n}\n\nU64 tensor_hash(const Tensor &tensor)\n{\n U64 hash = 14695981039346656037ULL;\n hash_vector(hash, tensor.shape);\n hash_vector(hash, tensor.strides);\n hash_word(hash, static_cast<U64>(tensor.origin));\n hash_vector(hash, tensor.storage);\n return hash;\n}\n\nU64 params_hash(const std::vector<QuantParam> ¶ms)\n{\n U64 hash = 14695981039346656037ULL;\n hash_word(hash, params.size());\n for (const QuantParam &p : params) {\n hash_word(hash, p.numerator);\n hash_word(hash, p.denominator);\n hash_word(hash, static_cast<U64>(p.zero));\n hash_word(hash, static_cast<U64>(p.qmin));\n hash_word(hash, static_cast<U64>(p.qmax));\n }\n return hash;\n}\n\nbool view(Arguments &args, Tensor &tensor, int &axis)\n{\n unsigned rank = 0;\n unsigned strides = 0;\n std::size_t count = 0;\n Tensor replacement;\n int next_axis = 0;\n if (!args.next(rank) || !args.next(strides) || !args.next(next_axis) ||\n !args.next(replacement.origin) || !args.next(count) || rank > 5 || strides > 5 || count > 10000) return false;\n replacement.shape.resize(rank);\n replacement.strides.resize(strides);\n replacement.storage.resize(count);\n for (std::size_t &value : replacement.shape) if (!args.next(value)) return false;\n for (std::size_t &value : replacement.strides) if (!args.next(value)) return false;\n for (I64 &value : replacement.storage) if (!args.next(value)) return false;\n if (!args.done()) return false;\n tensor = std::move(replacement);\n axis = next_axis;\n return true;\n}\n\nbool load_params(Arguments &args, std::vector<QuantParam> (¶ms)[2])\n{\n unsigned target = 0;\n unsigned count = 0;\n if (!args.next(target) || !args.next(count) || target > 1 || count > 16) return false;\n std::vector<QuantParam> replacement(count);\n for (QuantParam &p : replacement) {\n if (!args.next(p.numerator) || !args.next(p.denominator) || !args.next(p.zero) ||\n !args.next(p.qmin) || !args.next(p.qmax)) return false;\n }\n if (!args.done()) return false;\n params[target].swap(replacement);\n return true;\n}\n}\n\nint main()\n{\n channel_quant::Calibrator banks[2];\n unsigned selected = 0;\n Tensor tensor{{1}, {1}, 0, {0}};\n int axis = 0;\n std::vector<QuantParam> params[2];\n std::string line;\n while (std::getline(std::cin, line)) {\n const std::vector<std::string> fields = words(line);\n if (fields.empty() || fields[0][0] == \'#\') continue;\n const std::string &op = fields[0];\n Arguments args(fields);\n channel_quant::Calibrator &bank = banks[selected];\n int number = 0;\n std::size_t index = 0;\n if (op == "V") {\n if (!view(args, tensor, axis)) return 2;\n std::cout << "V 0\\n";\n } else if (op == "F") {\n if (!load_params(args, params)) return 2;\n std::cout << "F 0\\n";\n } else if (op == "U" || op == "M") {\n unsigned other = 0;\n if (!args.next(other) || !args.done() || other > 1) return 2;\n if (op == "U") {\n selected = other;\n std::cout << "U " << selected << \'\\n\';\n } else {\n std::cout << "R " << bank.merge(banks[other]) << \'\\n\';\n }\n } else if (op == "C") {\n if (!args.next(index) || !args.next(number) || !args.done()) return 2;\n std::cout << "R " << bank.configure(index, number) << \'\\n\';\n } else if (op == "Z" && args.done()) {\n bank.reset();\n std::cout << "R 0\\n";\n } else if (op == "A" && args.done()) {\n std::cout << "R " << bank.update(tensor, axis) << \'\\n\';\n } else if (op == "B" && args.done()) {\n std::cout << "R " << bank.checkpoint() << \'\\n\';\n } else if (op == "R" && args.done()) {\n std::cout << "R " << bank.restore() << \'\\n\';\n } else if (op == "X" && args.done()) {\n std::cout << "R " << bank.clear() << \'\\n\';\n } else if (op == "D" && args.done()) {\n std::cout << "R " << bank.discard_checkpoint() << \'\\n\';\n } else if (op == "S" && args.done()) {\n std::cout << "S " << bank.channels() << \' \' << bank.mode() << \' \' << bank.total() << \'\\n\';\n } else if (op == "I" && args.done()) {\n std::cout << "I " << tensor_hash(tensor) << \' \' << params_hash(params[0]) << \' \' << params_hash(params[1]) << \'\\n\';\n } else if (op == "L" || op == "G" || op == "P") {\n if (!args.next(number) || !args.done() || number < 0) return 2;\n const std::size_t size = static_cast<std::size_t>(number);\n if (op == "L") {\n channel_quant::Layout out{{size}, {size}, size, number, size, size};\n const int result = channel_quant::inspect_layout(tensor, axis, out);\n std::cout << "L " << result << \' \' << out.axis << \' \' << out.origin << \' \' << out.elements << \' \' << out.channels << \' \';\n csv(out.shape); std::cout << \' \'; csv(out.strides); std::cout << \'\\n\';\n } else if (op == "G") {\n std::vector<I64> values{number};\n std::vector<std::size_t> channels{size};\n const int result = channel_quant::gather(tensor, axis, values, channels);\n std::cout << "G " << result << \' \'; csv(values); std::cout << \' \'; csv(channels); std::cout << \'\\n\';\n } else {\n std::vector<QuantParam> values{{size, size, number, number, number}};\n const int result = bank.parameters(values);\n std::cout << "P " << result << \' \'; parameters(values); std::cout << \'\\n\';\n }\n } else if (op == "E" || op == "Q") {\n if (!args.next(index) || !args.next(number) || !args.done() || number < 0) return 2;\n if (op == "E") {\n I64 value = number;\n std::size_t channel = static_cast<std::size_t>(number);\n const int result = channel_quant::element(tensor, axis, index, value, channel);\n std::cout << "E " << result << \' \' << value << \' \' << channel << \'\\n\';\n } else {\n channel_quant::Range range{static_cast<U64>(number), number, number};\n const int result = bank.query(index, range);\n std::cout << "Q " << result << \' \' << range.count << \' \' << range.minimum << \' \' << range.maximum << \'\\n\';\n }\n } else if (op == "T" || op == "H") {\n if (!args.next(number) || !args.done()) return 2;\n std::vector<int> out{number};\n const int result = op == "T" ? channel_quant::quantize(tensor, axis, params[0], out) :\n channel_quant::requantize(tensor, axis, params[0], params[1], out);\n std::cout << op << \' \' << result << \' \'; csv(out); std::cout << \'\\n\';\n } else if (op == "O") {\n I64 nonce = 0;\n if (!args.next(nonce) || !args.done()) return 2;\n std::vector<I64> out{nonce};\n const int result = channel_quant::dequantize(tensor, axis, params[0], out);\n std::cout << "O " << result << \' \'; csv(out); std::cout << \'\\n\';\n } else {\n return 2;\n }\n }\n return std::cin.bad() ? 2 : 0;\n}\n'}
|
|
CANDIDATES = ['channel_quant.hpp', 'tensor_layout.cpp', 'calibrator.cpp', 'quant_transform.cpp']
|
|
from pathlib import Path
|
|
import copy
|
|
import math
|
|
import random
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
|
|
LIMIT = 10**12
|
|
MASK = 2**64-1
|
|
|
|
def csv(values): return ','.join(map(str,values)) or '-'
|
|
def params_text(params): return ';'.join(csv(p) for p in params) or '-'
|
|
def rounded(n,d):
|
|
sign = -1 if n < 0 else 1; q,r = divmod(abs(n),d)
|
|
return sign * (q + int(2*r>d or (2*r==d and q%2)))
|
|
def clip(x,low,high): return min(high,max(low,x))
|
|
def layout(t, axis):
|
|
shape,strides,origin,data=t; rank=len(shape)
|
|
if not 1 <= rank <= 4 or len(strides)!=rank: return -22,None
|
|
if any(x>16 for x in shape): return -34,None
|
|
if not -rank <= axis < rank: return -22,None
|
|
axis %= rank
|
|
if shape[axis]==0: return -22,None
|
|
count=math.prod(shape)
|
|
if count>4096: return -34,None
|
|
if len(data)>8192 or any(abs(x)>10**9 for x in data): return -34,None
|
|
if origin>len(data): return -34,None
|
|
if count:
|
|
maximum=origin+sum((d-1)*s for d,s in zip(shape,strides))
|
|
if maximum>MASK or maximum>=len(data): return -34,None
|
|
return 0,dict(axis=axis,shape=shape,strides=strides,origin=origin,elements=count,channels=shape[axis])
|
|
def gathered(t, info):
|
|
shape,strides,origin,data=t; values=[]; channels=[]
|
|
for linear in range(info['elements']):
|
|
at=linear; offset=origin; channel=0
|
|
for d in range(len(shape)-1,-1,-1):
|
|
coordinate=at%shape[d];at//=shape[d];offset+=coordinate*strides[d]
|
|
if d==info['axis']:channel=coordinate
|
|
values.append(data[offset]);channels.append(channel)
|
|
return values,channels
|
|
|
|
def valid_params(params,channels):
|
|
return (len(params)==channels and all(1<=n<=2*10**9 and 1<=d<=255 and (lo,hi) in [(-127,127),(0,255)] and lo<=z<=hi for n,d,z,lo,hi in params))
|
|
|
|
def transform(t,axis,source,dest,op,nonce):
|
|
status,info=layout(t,axis)
|
|
if status:return status,[nonce]
|
|
if not valid_params(source,info['channels']):return -22,[nonce]
|
|
if op=='H' and not valid_params(dest,info['channels']):return -22,[nonce]
|
|
values,channels=gathered(t,info)
|
|
if op in ('O','H') and any(not source[c][3]<=x<=source[c][4] for x,c in zip(values,channels)):return -34,[nonce]
|
|
result=[]
|
|
for x,c in zip(values,channels):
|
|
n,d,z,lo,hi=source[c]
|
|
if op=='T':value=clip(rounded(x*d,n)+z,lo,hi)
|
|
elif op=='O':value=rounded((x-z)*n,d)
|
|
else:
|
|
nn,dd,zz,ll,hh=dest[c]
|
|
value=clip(rounded((x-z)*n*dd,d*nn)+zz,ll,hh)
|
|
result.append(value)
|
|
return 0,result
|
|
|
|
class Cal:
|
|
def __init__(self):self.reset()
|
|
def reset(self):self.mode=-1;self.ranges=[];self.saved=None
|
|
def configure(self,n,mode):
|
|
if not 1<=n<=16 or mode not in (0,1):return -22
|
|
self.mode=mode;self.ranges=[[0,0,0] for _ in range(n)];self.saved=None;return 0
|
|
def update(self,t,axis):
|
|
if self.mode==-1:return -19
|
|
status,info=layout(t,axis)
|
|
if status:return status
|
|
if info['channels']!=len(self.ranges):return -22
|
|
values,channels=gathered(t,info); additions=[channels.count(c) for c in range(len(self.ranges))]
|
|
if any(r[0]+n>LIMIT for r,n in zip(self.ranges,additions)):return -34
|
|
for value,c in zip(values,channels):
|
|
r=self.ranges[c]
|
|
if not r[0]:r[1:]=[value,value]
|
|
else:r[1]=min(r[1],value);r[2]=max(r[2],value)
|
|
r[0]+=1
|
|
return 0
|
|
def merge(self,other):
|
|
if self.mode==-1 or other.mode==-1:return -19
|
|
if self.mode!=other.mode or len(self.ranges)!=len(other.ranges):return -22
|
|
if any(a[0]+b[0]>LIMIT for a,b in zip(self.ranges,other.ranges)):return -34
|
|
updated=[]
|
|
for a,b in zip(self.ranges,other.ranges):
|
|
if not a[0]:updated.append(b[:])
|
|
elif not b[0]:updated.append(a[:])
|
|
else:updated.append([a[0]+b[0],min(a[1],b[1]),max(a[2],b[2])])
|
|
self.ranges=updated;return 0
|
|
def checkpoint(self):
|
|
if self.mode==-1:return -19
|
|
self.saved=copy.deepcopy(self.ranges);return 0
|
|
def restore(self):
|
|
if self.mode==-1:return -19
|
|
if self.saved is None:return -2
|
|
self.ranges=copy.deepcopy(self.saved);return 0
|
|
def clear(self):
|
|
if self.mode==-1:return -19
|
|
self.ranges=[[0,0,0] for _ in self.ranges];return 0
|
|
def discard(self):
|
|
if self.mode==-1:return -19
|
|
self.saved=None;return 0
|
|
def query(self,c,nonce):
|
|
if self.mode==-1:return [-19]+[nonce]*3
|
|
if c>=len(self.ranges):return [-22]+[nonce]*3
|
|
return [0]+self.ranges[c]
|
|
def parameters(self,nonce):
|
|
unchanged=[[nonce]*5]
|
|
if self.mode==-1:return -19,unchanged
|
|
if any(not r[0] for r in self.ranges):return -61,unchanged
|
|
params=[]
|
|
for count,low,high in self.ranges:
|
|
if self.mode==0:
|
|
span=max(abs(low),abs(high));params.append([span,127,0,-127,127] if span else [1,1,0,-127,127])
|
|
else:
|
|
low=min(0,low);high=max(0,high);span=high-low
|
|
params.append([span,255,clip(rounded(-low*255,span),0,255),0,255] if span else [1,1,0,0,255])
|
|
return 0,params
|
|
def summary(self):return [len(self.ranges),self.mode,sum(r[0] for r in self.ranges)]
|
|
|
|
def hash_words(values):
|
|
h=14695981039346656037
|
|
for value in values:
|
|
for b in (value&MASK).to_bytes(8,'little'):h=((h^b)*1099511628211)&MASK
|
|
return h
|
|
|
|
def tensor_hash(t):
|
|
shape,strides,origin,data=t
|
|
return hash_words([len(shape),*shape,len(strides),*strides,origin,len(data),*data])
|
|
def param_hash(params):return hash_words([len(params)]+[v for p in params for v in p])
|
|
|
|
class Suite:
|
|
def __init__(self):
|
|
self.t=([1],[1],0,[0]);self.axis=0;self.banks=[Cal(),Cal()];self.selected=0;self.params=[[],[]];self.commands=[];self.expected=[];self.labels=[]
|
|
def add(self,command,label,clauses):
|
|
fields=command.split();op=fields[0];a=list(map(int,fields[1:]));bank=self.banks[self.selected]
|
|
prefix=op
|
|
if op=='V':
|
|
rank,nstride,self.axis,origin,count=a[:5];self.t=(a[5:5+rank],a[5+rank:5+rank+nstride],origin,a[5+rank+nstride:]);assert len(self.t[3])==count;result=[0]
|
|
elif op=='F':
|
|
target,count=a[:2];self.params[target]=[a[2+i*5:7+i*5] for i in range(count)];result=[0]
|
|
elif op=='U':self.selected=a[0];result=a
|
|
elif op=='M':prefix='R';result=[bank.merge(self.banks[a[0]])]
|
|
elif op=='C':prefix='R';result=[bank.configure(*a)]
|
|
elif op=='Z':prefix='R';bank.reset();result=[0]
|
|
elif op=='A':prefix='R';result=[bank.update(self.t,self.axis)]
|
|
elif op in ('B','R','X','D'):
|
|
prefix='R';result=[{'B':bank.checkpoint,'R':bank.restore,'X':bank.clear,'D':bank.discard}[op]()]
|
|
elif op=='S':result=bank.summary()
|
|
elif op=='I':result=[tensor_hash(self.t),param_hash(self.params[0]),param_hash(self.params[1])]
|
|
elif op=='Q':result=bank.query(*a)
|
|
elif op=='P':
|
|
status,params=bank.parameters(a[0]);result=[status,params_text(params)]
|
|
elif op in ('L','G','E'):
|
|
nonce=a[-1];status,info=layout(self.t,self.axis)
|
|
if op=='L':
|
|
result=[status]+([info['axis'],info['origin'],info['elements'],info['channels'],csv(info['shape']),csv(info['strides'])] if not status else [nonce]*4+[str(nonce)]*2)
|
|
elif op=='G':
|
|
values,channels=gathered(self.t,info) if not status else ([nonce],[nonce]);result=[status,csv(values),csv(channels)]
|
|
elif status or a[0]>=info['elements']:result=[status or -34,nonce,nonce]
|
|
else:
|
|
values,channels=gathered(self.t,info);result=[0,values[a[0]],channels[a[0]]]
|
|
elif op in ('T','O','H'):
|
|
status,result_values=transform(self.t,self.axis,self.params[0],self.params[1],op,a[0]);result=[status,csv(result_values)]
|
|
else:raise ValueError(command)
|
|
self.commands.append(command);self.expected.append(prefix+' '+' '.join(map(str,result)));self.labels.append((label,clauses))
|
|
def view(self,shape,strides,origin,data,axis,label='view',clauses='Q01-Q07'):
|
|
self.add('V '+' '.join(map(str,[len(shape),len(strides),axis,origin,len(data),*shape,*strides,*data])),label,clauses)
|
|
def parameters(self,target,params,label='custom-params',clauses='Q23-Q27'):
|
|
self.add('F '+' '.join(map(str,[target,len(params),*[v for p in params for v in p]])),label,clauses)
|
|
|
|
def cases():
|
|
s=Suite();rng=random.Random(0x61786973)
|
|
def c(command,label,clauses):s.add(command,label,clauses)
|
|
for command in ('S','Q 0 3','P 5','B','R','X','D','A','I'):
|
|
c(command,'unconfigured-state-and-priority','Q08-Q10,Q15-Q18,Q36-Q37')
|
|
s.view([2,2],[2,1],0,[1,1000,2,2000],-1,'negative-axis-reproduction','Q02-Q03')
|
|
for command in ('L 7','G 11','C 2 0','A','Q 0 13','Q 1 17','P 19'):c(command,'negative-axis-observation','Q02-Q03,Q08-Q11,Q17-Q19')
|
|
c('B','checkpoint-save','Q15');c('Q 2 21','query-invalid-channel','Q17');c(f'Q {MASK} 22','query-huge-channel','Q17');c('X','checkpoint-clear','Q16');c('R','checkpoint-first-restore','Q15-Q16');c('R','checkpoint-repeated-restore','Q15');c('Q 1 23','checkpoint-restored-range','Q15-Q17');c('D','checkpoint-discard','Q16');c('R','checkpoint-absent','Q15')
|
|
# Quantization of a tie in the affine zero point must use even rounding.
|
|
for values in ([-1,1],[-1,5],[-7,-1],[1,9],[0,0],[-10**9,10**9]):
|
|
s.view([len(values),1],[1,1],0,values,1,'affine-ranges','Q01-Q04')
|
|
for command in ('C 1 1','A','P 29','S','Q 0 31','B','P 37','R','R'):c(command,'affine-zero-and-checkpoint','Q15-Q22')
|
|
s.view([2,1],[1,1],0,[1,-1],1,'requant-source','Q03,Q26')
|
|
s.parameters(0,[[3,5,0,-127,127]]);s.parameters(1,[[1,2,0,-127,127]])
|
|
for command in ('H -17','O -19','T -23','I'):c(command,'requant-one-round','Q21,Q23-Q28,Q36')
|
|
geometries=[([2,3],[3,1],0,[i-3 for i in range(6)]),([2,3],[1,2],0,[i-3 for i in range(6)]),([2,3],[0,1],0,[7,8,9]),([2,3],[4,1],1,[9,1,2,3,9,4,5,6]),([2,0,3],[MASK,1,MASK],0,[]),([1],[MASK],0,[7]),([4,4,4,4],[64,16,4,1],0,list(range(256))),([8,8,8,8],[512,64,8,1],0,[(i%19)-9 for i in range(4096)]),([1],[MASK],8191,[0]*8191+[17])]
|
|
for shape,strides,origin,data in geometries:
|
|
for axis in range(-len(shape),len(shape)):
|
|
s.view(shape,strides,origin,data,axis,'geometry-variants','Q01-Q07')
|
|
for command in ('L 41','G 43','E 0 47','E 4096 53','I'):c(command,'geometry-observation','Q01-Q07,Q36')
|
|
channels=shape[axis%len(shape)]
|
|
if channels:
|
|
for mode in (0,1):
|
|
c(f'C {channels} {mode}','geometry-configure','Q09');c('A','geometry-update','Q10-Q11');c('P 59','geometry-parameters','Q18-Q22')
|
|
for ch in range(channels):c(f'Q {ch} 61','geometry-ranges','Q11,Q17')
|
|
invalids=[([],[],0,[],0),([1,1,1,1,1],[1]*5,0,[1],0),([2,2],[1],0,[1]*4,0),([17],[1],0,[1],0),([1],[1],0,[1],1),([0],[1],0,[],0),([16,16,16,2],[8192,256,16,1],0,[1],0),([1],[1],0,[0]*8193,0),([1],[1],0,[10**9+1],0),([1],[1],1,[0],0),([2],[MASK],0,[0],0),([2],[1],0,[1],0),([1,0],[MASK,MASK],2,[],0)]
|
|
for shape,strides,origin,data,axis in invalids:
|
|
s.view(shape,strides,origin,data,axis,'invalid-layout','Q01-Q05')
|
|
for command in ('L 67','G 71','E 0 73','A','T -79','O -83','H -89','I'):c(command,'layout-error-atomicity','Q05-Q07,Q10,Q23-Q27,Q36')
|
|
# Empty source, empty target, and self-merge are distinct paths.
|
|
c('U 0','merge-bank0','Q08,Q28');c('C 2 0','merge-config0','Q09');c('U 1','merge-bank1','Q08');c('C 2 0','merge-config1','Q09');c('M 0','merge-empty-both','Q13');c('U 0','merge-back','Q08')
|
|
s.view([2,2],[2,1],0,[-2,3,5,-7],1,'merge-view','Q03')
|
|
c('A','merge-populate0','Q11');c('B','merge-save0','Q15');c('M 1','merge-empty-source','Q13');c('U 1','merge-select1','Q08');c('M 0','merge-empty-target','Q13');c('M 1','self-merge','Q14');c('Q 0 97','self-merge-range','Q14,Q17');c('U 0','merge-select0','Q08');c('M 1','merge-populated','Q13');c('R','merge-kept-checkpoint','Q13,Q15');c('Q 0 101','merge-restore-range','Q15,Q17')
|
|
for command in ('C 0 0','S','R','C 17 0','S','C 2 2','S','U 1','C 1 1','U 0','M 1','S','U 1','Z','U 0','M 1','S'):
|
|
c(command,'calibration-invalid-preservation','Q08-Q09,Q13-Q16')
|
|
# Build the exact count limit with binary doubling and additions in O(log limit).
|
|
s.view([1],[1],0,[1],0,'limit-view','Q01-Q04');c('U 1','limit-source','Q08');c('C 1 0','limit-source-config','Q09');c('A','limit-source-sample','Q11');c('U 0','limit-target','Q08');c('C 1 0','limit-target-config','Q09')
|
|
for bit in bin(LIMIT)[2:]:
|
|
c('M 0','count-limit-double','Q12-Q14')
|
|
if bit=='1':c('M 1','count-limit-add','Q12-Q14')
|
|
for command in ('Q 0 103','S','B','M 1','Q 0 107','A','Q 0 109','M 0','S','X','R','Q 0 113','R','Q 0 127'):
|
|
c(command,'count-limit-and-rollback','Q12-Q16,Q17')
|
|
for mode in (0,1):
|
|
for values in ([-100,-2,0,3,70],[-3,-1],[1,3],[0,0],[-10**9,10**9]):
|
|
s.view([len(values),1],[1,1],0,values,1,'policy-data','Q03');c(f'C 1 {mode}','policy-config','Q09');c('A','policy-update','Q11');c('P 131','policy-params','Q18-Q22')
|
|
# Exact rounding both sides of half; nonzero zero point is added after rounding.
|
|
for output_interval in [(-127,127),(0,255)]:
|
|
low,high=output_interval;zero=0 if low<0 else 127
|
|
for num,den in [(2,1),(3,2),(1,255),(2000000000,255)]:
|
|
source=[[num,den,zero,low,high]];s.parameters(0,source)
|
|
s.view([16,1],[1,1],0,[-1000000000,-7,-5,-3,-2,-1,0,1,2,3,5,7,9,11,13,1000000000],1,'rounding-view','Q21,Q24')
|
|
c('T -137','rounding-quantize','Q21,Q23-Q24,Q27');c('I','quantize-input-preserved','Q27,Q36')
|
|
qvalues=[low,low+1,0 if low<0 else 127,1 if low<0 else 128,high-1,high]
|
|
s.view([len(qvalues),1],[1,1],0,qvalues,1,'dequant-view','Q25');c('O -139','rounding-dequantize','Q21,Q25,Q27');c('I','dequant-input-preserved','Q27,Q36')
|
|
valid_param=[1,1,0,-127,127]
|
|
badparams=[[],[[0,1,0,-127,127]],[[2*10**9+1,1,0,-127,127]],[[1,0,0,-127,127]],[[1,256,0,-127,127]],[[1,1,0,-128,127]],[[1,1,128,-127,127]]]
|
|
for params in badparams:
|
|
s.view([1],[1],0,[128],0,'badparam-view','Q01-Q04');s.parameters(0,params,'bad-source','Q23-Q27');s.parameters(1,[valid_param])
|
|
for command in ('T -149','O -151','H -157','I'):c(command,'params-before-data-priority','Q23-Q27,Q36')
|
|
s.parameters(0,[valid_param]);s.parameters(1,[[1,0,0,-127,127]])
|
|
for command in ('H -163','I'):c(command,'destination-before-q-range','Q26-Q27,Q36')
|
|
s.parameters(1,[valid_param])
|
|
for command in ('O -167','H -173','I'):c(command,'source-range-error','Q25-Q27,Q36')
|
|
s.view([1,0],[MASK,MASK],0,[],0,'empty-conversion','Q04,Q27')
|
|
for params in ([valid_param],[]):
|
|
s.parameters(0,params);s.parameters(1,params)
|
|
for command in ('T -179','O -181','H -191','I'):c(command,'empty-validates-params','Q23-Q27,Q36')
|
|
for _ in range(180):
|
|
rank=rng.randrange(1,5);shape=[rng.randrange(1,5) for _ in range(rank)];axis=rng.randrange(-rank,rank);channels=shape[axis%rank]
|
|
strides=[];size=1
|
|
for dimension in reversed(shape):strides.insert(0,size);size*=dimension
|
|
data=[rng.randrange(-255,256) for _ in range(size)]
|
|
if rng.randrange(5)==0:strides[rng.randrange(rank)]=0
|
|
s.view(shape,strides,0,data,axis,'random-layout','Q01-Q07')
|
|
c('G 193','random-gather','Q02-Q06');c(f'C {channels} {rng.randrange(2)}','random-config','Q09');c('A','random-update','Q10-Q11');c('P 197','random-params','Q18-Q22');c('B','random-checkpoint','Q15');c('M '+str(s.selected),'random-selfmerge','Q14');c('R','random-restore','Q15');c('R','random-repeat-restore','Q15')
|
|
source=[];destination=[]
|
|
for _ in range(channels):
|
|
interval=rng.choice([(-127,127),(0,255)]);zero=rng.randrange(interval[0],interval[1]+1)
|
|
source.append([rng.randrange(1,300),rng.randrange(1,256),zero,*interval])
|
|
interval=rng.choice([(-127,127),(0,255)]);zero=rng.randrange(interval[0],interval[1]+1)
|
|
destination.append([rng.randrange(1,300),rng.randrange(1,256),zero,*interval])
|
|
s.parameters(0,source);s.parameters(1,destination);c('T -199','random-quantize','Q21,Q23-Q24,Q27');c('O -211','random-dequantize','Q21,Q25,Q27');c('H -223','random-requantize','Q21,Q26-Q27');c('I','random-input-unchanged','Q27,Q36')
|
|
return s
|
|
|
|
def main():
|
|
suite=cases()
|
|
scratch=Path(tempfile.mkdtemp(prefix='embedded-hard-numeric-',dir='/tmp'))
|
|
for name,content in CONTEXT.items():(scratch/name).write_text(content)
|
|
for name in CANDIDATES:(scratch/name).write_bytes((Path(sys.argv[1])/name).read_bytes())
|
|
command_input='\n'.join(suite.commands)+'\n'
|
|
build=subprocess.run(['g++','-std=c++17','-O2','-Wall','-Wextra','-pedantic','quant_console.cpp','tensor_layout.cpp','calibrator.cpp','quant_transform.cpp','-o','observe'],cwd=scratch,text=True,capture_output=True,timeout=25)
|
|
if build.returncode:print('check=build clauses=Q29 build failed: '+build.stderr[-1500:].replace('\n',' '));return 1
|
|
# shortcut: scratch is retained for container teardown; trusted-local cleanup is separate.
|
|
# All filesystem preparation completes before any candidate execution.
|
|
observed=subprocess.run([str(scratch/'observe')],input=command_input,cwd=scratch,text=True,capture_output=True,timeout=15)
|
|
if observed.returncode:print('check=execution clauses=Q29,Q35 exit='+str(observed.returncode)+' stderr='+observed.stderr[-300:]);return 1
|
|
actual=observed.stdout.splitlines();failures=[]
|
|
for index in range(max(len(actual),len(suite.expected))):
|
|
got=actual[index] if index<len(actual) else '<missing>';expected=suite.expected[index] if index<len(suite.expected) else '<end>'
|
|
if index>=len(actual) or index>=len(suite.expected) or got!=expected:
|
|
label,clauses=suite.labels[index] if index<len(suite.labels) else ('extra-output','Q29-Q35')
|
|
failures.append((index,label,clauses,got,expected))
|
|
if failures:
|
|
for index,label,clauses,got,expected in failures[:20]:print('check=%s clauses=%s observation=%d got=%r expected=%r'%(label,clauses,index,got[:180],expected[:180]))
|
|
print('mismatches=%d observations=%d'%(len(failures),len(suite.expected)));return 1
|
|
print('PASS');return 0
|
|
|
|
if __name__=='__main__':raise SystemExit(main())
|