{ "cells": [ { "cell_type": "markdown", "id": "4ecc6afd", "metadata": {}, "source": [ "# MEOK: pinned process replay on Kaggle CPU\n", "\n", "A separately written Python-standard-library implementation recomputes six existing checkpoint variants on 1,200 already-public synthetic transitions. No GPU/TPU, internet, training, provider calls or private data.\n", "\n", "This is a cross-runtime reproduction, not an independent organisation or new general-capability benchmark. The original approximately 75-percentage-point worst error remains visible. The reference outputs are used only for comparison, not fitting. The immutable manifest is checked before loading any model or dataset." ] }, { "cell_type": "code", "execution_count": null, "id": "5a15a9fd", "metadata": {}, "outputs": [], "source": [ "\"\"\"Independent standard-library implementation of the fixed synthetic process replay.\n", "No training, downloads, model SDK, execution authority or network requests.\n", "New wrapper: MIT. Original artifacts retain their own MIT LICENSE/NOTICE files.\n", "\"\"\"\n", "from pathlib import Path\n", "import copy,csv,hashlib,json,math,platform,time\n", "VARIANTS=('original_float64','weight_float32','weight_int8','weight_int4','refitted_head','shuffled_head_control')\n", "TOLERANCE=1e-12\n", "MANIFEST_SHA256='9ad0d91f9f6a80e89252c897b20dc689b4e6cba0a73babc0a5967c41289b58b2'\n", "\n", "def reject(code):raise ValueError(code)\n", "def unique_pairs(pairs):\n", " d={}\n", " for k,v in pairs:\n", " if k in d:reject('DUPLICATE_JSON_KEY')\n", " d[k]=v\n", " return d\n", "\n", "def decode(raw):\n", " if not isinstance(raw,bytes)or len(raw)>2000000:reject('INPUT_SIZE')\n", " return json.loads(raw.decode('utf-8'),object_pairs_hook=unique_pairs,parse_constant=lambda x:reject('NONFINITE_JSON'))\n", "\n", "def finite(x):return type(x)in(int,float)and math.isfinite(x)\n", "def validate_features(x):\n", " if not isinstance(x,list)or len(x)!=11 or not all(finite(v)for v in x):reject('FEATURE_SHAPE_OR_TYPE')\n", " if any(v<0 or v>1 for v in x[:7])or abs(sum(x[:4])-1)>1e-8 or abs(sum(x[4:7])-1)>1e-8:reject('FEATURE_PROPORTIONS')\n", " if x[7]not in(0,1)or x[9]not in(0,1)or not -.875<=x[8]<=1.125 or not 0<=x[10]<=.875:reject('FEATURE_DOMAIN')\n", "\n", "def validate_model(m):\n", " if m.get('format')!='meok.experimental-process-predictor/1' or m.get('hidden_activation')!='relu' or m.get('output_activation')!='identity':reject('MODEL_FORMAT')\n", " means,scales=m['scaler_mean'],m['scaler_scale']\n", " if len(means)!=11 or len(scales)!=11 or not all(finite(v)for v in means)or not all(finite(v)and v>0 for v in scales):reject('SCALER')\n", " width=11\n", " if not 1<=len(m['coefs'])<=5 or len(m['coefs'])!=len(m['intercepts']):reject('LAYERS')\n", " for matrix,bias in zip(m['coefs'],m['intercepts']):\n", " if not 1<=len(bias)<=1024 or len(matrix)!=width or not all(finite(v)for v in bias):reject('TENSOR_SHAPE')\n", " if any(len(row)!=len(bias)or not all(finite(v)for v in row)for row in matrix):reject('TENSOR_SHAPE')\n", " width=len(bias)\n", " if width!=4:reject('OUTPUT_WIDTH')\n", "\n", "def predict(m,x):\n", " validate_features(x)\n", " state=[(v-m['scaler_mean'][i])/m['scaler_scale'][i] for i,v in enumerate(x)]\n", " for layer,(matrix,bias)in enumerate(zip(m['coefs'],m['intercepts'])):\n", " nxt=[]\n", " for column,b in enumerate(bias):\n", " value=0.0\n", " for row,v in enumerate(state):value+=v*matrix[row][column]\n", " value+=b\n", " nxt.append(max(0.0,value)if layer+1TOLERANCE:reject('METRIC_MISMATCH:'+field)\n", " return delta\n", "\n", "def replay(models,rows,expected_count):\n", " if len(rows)!=expected_count:reject('BANK_SIZE')\n", " predictions={};metrics={}\n", " for name in VARIANTS:\n", " m=models[name];validate_model(m);answers=[];total=0.0;worst=0.0\n", " for r in rows:\n", " target=r['target']\n", " if len(target)!=4 or not all(finite(v)and 0<=v<=1 for v in target)or abs(sum(target)-1)>1e-8:reject('TARGET_DOMAIN')\n", " answer=predict(m,r['features']);answers.append(answer)\n", " for a,b in zip(answer,target):\n", " e=abs(a-b);total+=e;worst=max(worst,e)\n", " predictions[name]=answers\n", " metrics[name]={'mae':total/(len(rows)*4),'max_abs_error':worst,'argmax_changes_from_base':sum(argmax(a)!=argmax(b)for a,b in zip(answers,predictions['original_float64']))}\n", " return predictions,metrics\n", "\n", "def load_locked(root):\n", " root=Path(root);raw=(root/'manifest.json').read_bytes()\n", " if hashlib.sha256(raw).hexdigest()!=MANIFEST_SHA256:reject('MANIFEST_PIN_MISMATCH')\n", " manifest=decode(raw);assets={}\n", " for name,pin in manifest['files'].items():\n", " flat=pin['flat_name']\n", " if Path(flat).name!=flat or flat in('.','..'):reject('UNSAFE_ASSET_PATH')\n", " file=root/flat\n", " if file.is_symlink()or not file.is_file()or file.stat().st_size!=pin['bytes']:reject('ASSET_SIZE_OR_TYPE:'+name)\n", " content=file.read_bytes()\n", " if hashlib.sha256(content).hexdigest()!=pin['sha256']:reject('ASSET_DIGEST:'+name)\n", " assets[name]=content\n", " return manifest,assets\n", "\n", "def run(root,out):\n", " begin=time.perf_counter();manifest,assets=load_locked(root);out=Path(out);out.mkdir(parents=True,exist_ok=True)\n", " models={n:decode(assets['research-v03/models/'+n+'.json'])for n in VARIANTS}\n", " old=decode(assets['research-v03/prediction-cases.json']);fresh=decode(assets['research-v03/fresh-stress-rows.json'])\n", " expected_old=decode(assets['research-v03/results.json'])['results'];expected_new=decode(assets['research-v03/fresh-stress-results.json'])['metrics']\n", " old_pred,old_metrics=replay(models,old,560);new_pred,new_metrics=replay(models,fresh,640)\n", " metric_delta=0.;row_delta=0.\n", " for n in VARIANTS:\n", " metric_delta=max(metric_delta,compare_metrics(old_metrics[n],expected_old[n]['constrained']),compare_metrics(new_metrics[n],expected_new[n]))\n", " if old_metrics[n]['argmax_changes_from_base']!=expected_old[n]['constrained']['argmax_changed_from_base']:reject('OLD_ARGMAX_MISMATCH')\n", " if new_metrics[n]['argmax_changes_from_base']!=expected_new[n]['argmax_changes_from_base']:reject('NEW_ARGMAX_MISMATCH')\n", " for r,y in zip(old,old_pred[n]):\n", " for a,b in zip(y,r['outputs'][n]):row_delta=max(row_delta,abs(a-b))\n", " if row_delta>TOLERANCE:reject('PER_ROW_PARITY')\n", " controls=[]\n", " def negative(name,fn):\n", " try:fn()\n", " except (ValueError,TypeError,KeyError):controls.append({'name':name,'status':'REFUSED_AS_EXPECTED'});return\n", " reject('NEGATIVE_CONTROL_ACCEPTED:'+name)\n", " x=old[0]['features']\n", " negative('boolean_feature',lambda:validate_features([True]+x[1:]))\n", " negative('nonfinite_feature',lambda:validate_features([float('nan')]+x[1:]))\n", " negative('missing_feature',lambda:validate_features(x[:-1]))\n", " negative('invalid_proportions',lambda:validate_features([1,1,1,1]+x[4:]))\n", " negative('duplicate_json_key',lambda:decode(b'{\"a\":1,\"a\":2}'))\n", " negative('nonfinite_json_constant',lambda:decode(b'{\"a\":NaN}'))\n", " negative('wrong_bank_size',lambda:replay(models,old[:-1],560))\n", " bogus=copy.deepcopy(old_metrics['refitted_head']);bogus['mae']=0\n", " negative('false_zero_error_claim',lambda:compare_metrics(bogus,expected_old['refitted_head']['constrained']))\n", " bogus=copy.deepcopy(old_metrics['refitted_head']);bogus['max_abs_error']=0\n", " negative('hidden_tail_failure',lambda:compare_metrics(bogus,expected_old['refitted_head']['constrained']))\n", " bad=copy.deepcopy(models['original_float64']);bad['scaler_scale'][0]=0\n", " negative('zero_scaler',lambda:validate_model(bad))\n", " bad=copy.deepcopy(models['original_float64']);bad['coefs'][0][0].pop()\n", " negative('damaged_weight_shape',lambda:validate_model(bad))\n", " # Check the byte rule with altered content, without modifying the source dataset.\n", " original=assets['research-v03/models/original_float64.json'];pin=manifest['files']['research-v03/models/original_float64.json']['sha256']\n", " negative('changed_weight_bytes',lambda:None if hashlib.sha256(original+b' ').hexdigest()==pin else reject('ASSET_DIGEST'))\n", " report={'schema':'csoai.meok.python-port-replay/1','status':'PASS','source_revision':manifest['source_revision'],'manifest_sha256':MANIFEST_SHA256,'source_files_checked':len(assets),'old_rows':len(old),'fresh_rows':len(fresh),'model_variants':6,'inference_evaluations':7200,'metrics':{'old_bank':old_metrics,'fresh_bank':new_metrics},'max_metric_delta_vs_retained_js_numpy':metric_delta,'max_old_bank_output_delta':row_delta,'negative_controls':controls,'negative_control_count':len(controls),'absolute_tolerance':TOLERANCE,'python':platform.python_version(),'machine':platform.machine(),'system':platform.system(),'elapsed_seconds_diagnostic':time.perf_counter()-begin,'new_training':False,'gpu_requested':False,'network_requests_in_replay':0,'execution_authority':False,'gspc_admitted':False,'independent_organisation':False,'limits':['New standard-library Python implementation checked against the existing synthetic research outputs; same author/owner.','Already-public same-generator banks, not new independent real-world benchmarks.','Matching arithmetic does not authenticate source truth, human authority or producer identity.','Timing is a single diagnostic, not a platform performance comparison.']}\n", " (out/'cross-platform-results.json').write_text(json.dumps(report,indent=2,sort_keys=True,allow_nan=False)+'\\n')\n", " with(out/'metrics.csv').open('w',newline='')as f:\n", " writer=csv.writer(f);writer.writerow(['bank','variant','mean_absolute_error_fraction','worst_error_fraction','argmax_changes'])\n", " for bank,values in report['metrics'].items():\n", " for name,m in values.items():writer.writerow([bank,name,m['mae'],m['max_abs_error'],m['argmax_changes_from_base']])\n", " print(json.dumps({k:v for k,v in report.items()if k not in('metrics','negative_controls','limits')},indent=2),flush=True)\n", " return report\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "19c2f504", "metadata": {}, "outputs": [], "source": [ "# Kaggle attaches the source dataset under /kaggle/input; no download occurs here.\n", "from pathlib import Path\n", "matches=list(Path('/kaggle/input').glob('**/manifest.json'))\n", "qualified=[p.parent for p in matches if p.stat().st_size<20000 and hashlib.sha256(p.read_bytes()).hexdigest()==MANIFEST_SHA256]\n", "assert len(qualified)==1, 'Expected exactly one pinned input dataset'\n", "report=run(qualified[0],Path('/kaggle/working'))\n", "print('VARIANT | old mean / worst (percentage points) | fresh mean / worst')\n", "for name in VARIANTS:\n", " a=report['metrics']['old_bank'][name];b=report['metrics']['fresh_bank'][name]\n", " print(f\"{name}: {a['mae']*100:.6f} / {a['max_abs_error']*100:.6f}; {b['mae']*100:.6f} / {b['max_abs_error']*100:.6f}\")\n", "assert report['status']=='PASS' and report['negative_control_count']==12\n" ] }, { "cell_type": "markdown", "id": "c52579c1", "metadata": {}, "source": [ "## Read the result precisely\n", "\n", "`cross-platform-results.json` and `metrics.csv` contain the actual run outputs. Error units are population fractions in JSON and labelled percentage points in the display. Matching the reference does not establish real-world validity, authenticated human approval, producer identity or GSPC admission. No automatic model promotion follows.\n", "\n", "Canonical research remains on Hugging Face and Council PR #4176. This notebook runs a small CPU replay; it does not restart the separate Cosmos LoRA job or reproduce transformer KV-cache/StrataFlux experiments." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python", "version": "3" } }, "nbformat": 4, "nbformat_minor": 5 }