Publish Ling-3.0-tiny RKNN engine and model (part 2)

Includes the final RK3588 model, verified portable runtime, canonical C++ source, conversion tooling, evaluation docs, and third-party notices.

tools/validate_selective_release_board.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Isolated portable release acceptance; restore the existing 64K service on exit."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import signal
+import socket
+import statistics
+import subprocess
+import tempfile
+import time
+import urllib.request
+
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--root',type=Path,required=True)
+    a=p.parse_args()
+    root=a.root.resolve()
+    package=root/'package/mindnano-ling3-rk3588-selective-20260911'
+    output=root/'validation'
+    output.mkdir(exist_ok=False)
+    deployment=root/'deployment/mindnano-ling3-rk3588'
+    reference=root/'calibrated-selective-20260911/kda_out_mla_in_mla_out_shared_dense_head'
+    suite=root/'mixed-precision-reference/suite.json'
+    env={'PATH':'/usr/bin:/bin','LANG':'C.UTF-8','no_proxy':'*'}
+    client=urllib.request.build_opener(urllib.request.ProxyHandler({}))
+    result={}
+    def request(port,path,body=None):
+        r=urllib.request.Request(f'http://127.0.0.1:{port}'+path,
+            data=None if body is None else json.dumps(body).encode(),headers={'Content-Type':'application/json'})
+        with client.open(r,timeout=600) as f:return json.load(f)
+    def ready(port,child=None):
+        deadline=time.monotonic()+600
+        while time.monotonic()<deadline:
+            if child is not None and child.poll() is not None:raise RuntimeError('service exited: '+str(child.returncode))
+            try:
+                h=request(port,'/health')
+                if h['status']=='ok':return h
+            except (OSError,ValueError):pass
+            time.sleep(1)
+        raise TimeoutError('service initialization')
+    def stop(child):
+        if child.poll() is None:
+            child.terminate()
+            try:child.wait(timeout=30)
+            except subprocess.TimeoutExpired:
+                os.killpg(child.pid,signal.SIGKILL);child.wait()
+                raise RuntimeError('test process required SIGKILL')
+        if child.returncode:raise RuntimeError('test process exit: '+str(child.returncode))
+    def interrupt(signum,frame):raise SystemExit(128+signum)
+    for s in (signal.SIGINT,signal.SIGTERM):signal.signal(s,interrupt)
+    result['health_before']=request(9091,'/health')
+    assert not result['health_before']['active'] and result['health_before']['context_length']==65536
+    with socket.socket() as s:
+        s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1);s.bind(('127.0.0.1',19096))
+    (output/'health-before.json').write_text(json.dumps(result['health_before'],indent=2)+'\n')
+    try:
+        subprocess.run(['systemctl','--user','stop','mindnano-ling3.service'],check=True)
+        print('PHASE portable package 64K service, clean environment and unrelated cwd',flush=True)
+        with tempfile.TemporaryDirectory(prefix='ling3-release-empty-') as cwd, (output/'service.log').open('w') as log:
+            child=subprocess.Popen([str(package/'mindnano-infer'),'--context','64K','--no-console',
+                '--host','127.0.0.1','--port','19096','--log',str(output/'metrics.jsonl')],
+                cwd=cwd,env=env,stdout=log,stderr=subprocess.STDOUT,start_new_session=True)
+            try:
+                h=ready(19096,child);result['health']=h
+                assert h['context_length']==65536
+                fmt=h['weight_format']
+                assert fmt['source']=='self_contained_selective_w4_w8' and fmt['shared_stage']
+                assert fmt['linear_counts']=={'original_w4':5888,'calibrated_w4':18,'w8':91}
+                body={'model':'mindnano-ling3-tiny','temperature':0,'max_tokens':64,'cache_prompt':False,
+                      'messages':[{'role':'user','content':'1'*107}]}
+                result['warm_request']=request(19096,'/v1/chat/completions',body)
+                result['runs']=[]
+                for i in range(3):
+                    r=request(19096,'/v1/chat/completions',body)
+                    assert r['usage']['prompt_tokens']==128 and r['usage']['completion_tokens']==64
+                    assert r['mindnano_metrics']['cached_tokens']==0
+                    result['runs'].append(r)
+                    print(json.dumps(dict(run=i+1,metrics=r['mindnano_metrics'])),flush=True)
+                result['performance']={
+                    'ttft_median_ms':statistics.median(r['mindnano_metrics']['ttft_ms'] for r in result['runs']),
+                    'decode_median_tokens_per_second':statistics.median(r['mindnano_metrics']['decode_tokens_per_second'] for r in result['runs']),
+                    'peak_rss_mib':max(r['mindnano_metrics']['peak_rss_mib'] for r in result['runs'])}
+                with (output/'api.json').open('w') as f:
+                    subprocess.run(['/usr/bin/python3',str(root/'source/tests/portable_api_test.py'),
+                        '--url','http://127.0.0.1:19096'],env=env,stdout=f,check=True)
+                print('PASS portable API / SSE / cancellation / request isolation',flush=True)
+                with (output/'prefix-cache.log').open('w') as f:
+                    subprocess.run(['/usr/bin/python3',str(root/'source/tests/prefix_cache_api_test.py'),
+                        '--url','http://127.0.0.1:19096','--output',str(output/'prefix-cache.json')],env=env,stdout=f,check=True)
+                print('PASS prefix cache / branching / namespace / streaming',flush=True)
+            finally:stop(child)
+        print('PHASE full Think / No-think equality against tested candidate',flush=True)
+        logits=output/'logits'
+        with (output/'probe.log').open('w') as log:
+            child=subprocess.Popen([str(root/'build/ling3-quant-loss-probe'),str(package/'ling3-tiny-w4.l3r'),
+                str(suite),str(logits)],env=env,stdout=log,stderr=subprocess.STDOUT,start_new_session=True)
+            try:
+                if child.wait()!=0:raise RuntimeError('full numerical probe failed')
+            finally:stop(child)
+        result['logit_equality']=[]
+        for case in json.loads(suite.read_text())['cases']:
+            name=case['id']+'.rknn.f32'
+            hashes=[]
+            for directory in (reference,logits):
+                file=directory/name
+                assert file.stat().st_size==len(case['teacher_ids'])*157184*4
+                with file.open('rb') as f:hashes.append(hashlib.file_digest(f,'sha256').hexdigest())
+            result['logit_equality'].append(dict(case=case['id'],sha256=hashes[1],bitwise_equal=hashes[0]==hashes[1]))
+        assert all(r['bitwise_equal'] for r in result['logit_equality']),result['logit_equality']
+        result['passed']=True
+        print('PASS all 4217 full-vocabulary logits bitwise identical to tested candidate',flush=True)
+    finally:
+        print('PHASE restoring original W4 / 64K service',flush=True)
+        state=subprocess.run(['systemctl','--user','show','mindnano-ling3.service','--property=LoadState','--value'],
+                             capture_output=True,text=True).stdout.strip()
+        if state=='loaded':
+            subprocess.run(['systemctl','--user','start','mindnano-ling3.service'],check=True)
+        else:
+            subprocess.run(['systemd-run','--user','--unit=mindnano-ling3','--collect','--property=Restart=on-failure',
+                '--property=RestartSec=5','--working-directory='+str(deployment),str(deployment/'mindnano-infer'),
+                '--context','64K','--host','0.0.0.0','--port','9091','--no-console','--log',str(deployment/'metrics-live.jsonl')],check=True)
+        result['health_restored']=ready(9091)
+        assert result['health_restored']['context_length']==65536
+        (output/'results.json').write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n')
+        print('PASS original service restored',flush=True)
+
+
+if __name__=='__main__':main()

tools/validate_weight_reclaim.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Compare deterministic API responses before/after source-weight reclamation."""
+import argparse
+import json
+from pathlib import Path
+import urllib.request
+
+p = argparse.ArgumentParser()
+p.add_argument("--url", required=True)
+p.add_argument("--output", type=Path, required=True)
+p.add_argument("--reference", type=Path)
+p.add_argument("--boundaries", action="store_true", help="also check partial final prefill blocks")
+a = p.parse_args()
+client = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
+
+def call(path, body=None):
+    req = urllib.request.Request(a.url.rstrip("/") + path,
+                                 None if body is None else json.dumps(body).encode(),
+                                 {"Content-Type": "application/json"})
+    with client.open(req, timeout=180) as response:
+        return json.load(response)
+
+
+office = "请用中文列出三条会议纪要的写作建议。"
+cases = [("office", office, 64), ("digits128_a", "1" * 107, 64),
+         ("digits128_b", "1" * 107, 64), ("digits128_c", "1" * 107, 64),
+         ("digits1024", "1" * 1003, 24), ("office_repeat", office, 64)]
+if a.boundaries:
+    cases.extend((f"digits{count}", "1" * (count - 21), 16) for count in (129, 131, 255, 257))
+    cases.append(("office_after_boundaries", office, 64))
+result = {"health_before": call("/health"), "cases": []}
+for name, prompt, tokens in cases:
+    response = call("/v1/chat/completions", {
+        "model": "mindnano-ling3-tiny",
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0, "max_tokens": tokens, "cache_prompt": False})
+    result["cases"].append({"name": name, "response": response})
+    print(json.dumps({"case": name, "usage": response["usage"],
+                      "metrics": response["mindnano_metrics"]}, ensure_ascii=False), flush=True)
+result["health_after"] = call("/health")
+a.output.parent.mkdir(parents=True, exist_ok=True)
+a.output.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n")
+assert result["cases"][0]["response"]["choices"] == result["cases"][-1]["response"]["choices"]
+if a.reference:
+    ref = json.loads(a.reference.read_text())
+    assert len(ref["cases"]) == len(result["cases"])
+    for before, after in zip(ref["cases"], result["cases"]):
+        assert before["name"] == after["name"]
+        for field in ("choices", "usage"):
+            assert before["response"][field] == after["response"][field], (after["name"], field)
+    print("PASS: all response texts, finish reasons and token counts exactly match baseline")

tools/verify_release_archive.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Verify all release members and embedded SHA256SUMS without extracting the model."""
+import argparse
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import tarfile
+
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('archive',type=Path)
+    a=p.parse_args()
+    expected={};actual={};roots=set();metadata={}
+    with tarfile.open(a.archive,'r|gz') as tar:
+        for member in tar:
+            path=PurePosixPath(member.name)
+            assert not path.is_absolute() and '..' not in path.parts
+            roots.add(path.parts[0])
+            if member.isdir():continue
+            assert member.isfile() and len(path.parts)==2,member.name
+            name=path.name
+            assert name not in actual,'duplicate member: '+name
+            digest=hashlib.sha256();parts=[]
+            with tar.extractfile(member) as f:
+                while block:=f.read(8*1024*1024):
+                    digest.update(block)
+                    if name in ('SHA256SUMS','MODEL.json','VALIDATION.json'):parts.append(block)
+            actual[name]=digest.hexdigest()
+            if name=='SHA256SUMS':
+                for line in b''.join(parts).decode().splitlines():
+                    checksum,filename=line.split('  ',1)
+                    assert filename not in expected
+                    expected[filename]=checksum
+            elif parts:metadata[name]=json.loads(b''.join(parts))
+    assert len(roots)==1
+    assert expected and set(expected)==set(actual)-{'SHA256SUMS'}
+    for name,checksum in expected.items():assert actual[name]==checksum,name
+    assert metadata['VALIDATION.json']['passed']
+    model = metadata['MODEL.json']
+    if model.get('mindnano_integration_version', 0) >= 5:
+        assert 'qa_cache_default' in model['capabilities']
+        assert 'resident_session_cache' in model['capabilities']
+        assert metadata['VALIDATION.json']['health']['mindnano_integration_version'] >= 5
+    else:
+        assert model['all_payload_sha256_valid']
+    print(json.dumps(dict(archive=str(a.archive),verified_files=len(expected),
+        all_member_sha256_valid=True,validation_passed=True,
+        performance=metadata['VALIDATION.json'].get('performance')),indent=2))
+
+
+if __name__=='__main__':main()