{
 "nbformat": 4,
 "nbformat_minor": 5,
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.12.14"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e5f0c52afe",
   "metadata": {},
   "source": [
    "# 100 identical loss logs, 100 different model states\n",
    "\n",
    "Aryan Putta · November 6, 2026\n",
    "\n",
    "A Megatron-inspired CPU replay lab shows why matching seeds and rounded loss curves cannot establish bitwise reproducibility.\n",
    "\n",
    "The experiment uses CPU float32 regression and Adam with synthetic data. Run the cells in order; results and figures are written to the working directory. Dependencies: NumPy and Matplotlib.\n",
    "\n",
    "**Method:** CPU float32 regression with Adam on synthetic data. The controlled comparisons change gradient-reduction order and checkpoint state to test exact replay.\n",
    "\n",
    "Sources:\n",
    "- https://developer.nvidia.com/blog/scale-bitwise-deterministic-pretraining-with-nvidia-megatron-core/\n",
    "- https://docs.pytorch.org/docs/stable/notes/randomness.html\n",
    "- https://docs.nvidia.com/cuda/floating-point/index.html\n"
   ]
  },
  {
   "cell_type": "code",
   "id": "148ba11896",
   "metadata": {},
   "source": [
    "import os\n",
    "os.environ.setdefault('OPENBLAS_NUM_THREADS', '1')\n",
    "os.environ.setdefault('OMP_NUM_THREADS', '1')\n",
    "\"\"\"A deterministic CPU training replay lab inspired by NVIDIA Megatron Core.\n",
    "Run: OPENBLAS_NUM_THREADS=1 python experiment.py\n",
    "Dependencies: Python, NumPy, Matplotlib. No downloads, network, model or GPU.\n",
    "\"\"\"\n",
    "import os\n",
    "os.environ.setdefault('MPLCONFIGDIR','/tmp/engineering-blog-mpl')\n",
    "import copy,json,hashlib,csv\n",
    "from pathlib import Path\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "matplotlib.use('Agg')\n",
    "import matplotlib.pyplot as plt\n",
    "ROOT=Path(__file__).resolve().parent if '__file__' in globals() else Path.cwd()\n",
    "STEPS=100;CUT=40;BATCH=64;D=24\n",
    "COLORS={'Same seed + full state':'#eeeeee','Full checkpoint':'#eeeeee','Reversed reduction':'#333333','Optimizer reset':'#9a9a9a','Sampler RNG reset':'#536b7a'}\n",
    "\n",
    "def digest(a):\n",
    "    a=np.ascontiguousarray(a)\n",
    "    return hashlib.sha256(str(a.shape).encode()+str(a.dtype).encode()+a.tobytes()).hexdigest()\n",
    "\n",
    "def make_data():\n",
    "    r=np.random.default_rng(20261106)\n",
    "    x=r.normal(size=(512,D)).astype(np.float32)\n",
    "    truth=r.normal(size=D).astype(np.float32)\n",
    "    y=(x@truth+.2*np.sin(3*x[:,0])+.03*r.normal(size=512)).astype(np.float32)\n",
    "    return x,y\n",
    "\n",
    "def init_state():\n",
    "    return {'w':np.random.default_rng(17).normal(0,.01,size=D).astype(np.float32),'m':np.zeros(D,np.float32),'v':np.zeros(D,np.float32),'step':0,'rng':copy.deepcopy(np.random.default_rng(99).bit_generator.state)}\n",
    "\n",
    "def state_digest(s):\n",
    "    return hashlib.sha256((''.join(digest(s[k]) for k in ['w','m','v'])+json.dumps({'step':s['step'],'rng':s['rng']},sort_keys=True)).encode()).hexdigest()\n",
    "\n",
    "def reduce_rows(x,reverse=False):\n",
    "    out=np.zeros(x.shape[1],np.float32)\n",
    "    for row in (x[::-1] if reverse else x):\n",
    "        out=np.add(out,row,dtype=np.float32)\n",
    "    return out\n",
    "\n",
    "def step(state,data,reverse=False):\n",
    "    x,y=data\n",
    "    rng=np.random.default_rng();rng.bit_generator.state=copy.deepcopy(state['rng'])\n",
    "    idx=rng.choice(len(x),BATCH,replace=False)\n",
    "    state['rng']=copy.deepcopy(rng.bit_generator.state)\n",
    "    xb=x[idx];yb=y[idx]\n",
    "    pred=np.sum(xb*state['w'],axis=1,dtype=np.float32)\n",
    "    residual=pred-yb\n",
    "    per_example=(np.float32(2/BATCH)*residual[:,None]*xb).astype(np.float32)\n",
    "    g=reduce_rows(per_example,reverse)\n",
    "    input_hash=digest(per_example);grad_hash=digest(g)\n",
    "    state['step']+=1;t=state['step']\n",
    "    b1=np.float32(.9);b2=np.float32(.999);lr=np.float32(.04)\n",
    "    state['m']=(b1*state['m']+(np.float32(1)-b1)*g).astype(np.float32)\n",
    "    state['v']=(b2*state['v']+(np.float32(1)-b2)*g*g).astype(np.float32)\n",
    "    mh=state['m']/np.float32(1-float(b1)**t)\n",
    "    vh=state['v']/np.float32(1-float(b2)**t)\n",
    "    state['w']=(state['w']-lr*mh/(np.sqrt(vh)+np.float32(1e-8))).astype(np.float32)\n",
    "    # Float64 evaluation avoids hiding loss changes inside its own float32 reduction.\n",
    "    residual_eval=x.astype(np.float64)@state['w'].astype(np.float64)-y\n",
    "    loss=float(np.mean(residual_eval**2))\n",
    "    return {'step':t,'loss':loss,'printed_loss':f'{loss:.4f}','weights':state['w'].copy(),'weight_hash':digest(state['w']),'state_hash':state_digest(state),'gradient_input_hash':input_hash,'gradient_hash':grad_hash,'sample_hash':digest(idx)}\n",
    "\n",
    "def run(data,state=None,steps=STEPS,reverse=False):\n",
    "    s=init_state() if state is None else copy.deepcopy(state);trace=[]\n",
    "    for _ in range(steps):trace.append(step(s,data,reverse))\n",
    "    return s,trace\n",
    "\n",
    "def serial_trace(trace):\n",
    "    return [{k:v for k,v in t.items() if k!='weights'} for t in trace]\n",
    "\n",
    "def run_experiment():\n",
    "    data=make_data();final,ref=run(data)\n",
    "    _,same=run(data)\n",
    "    checkpoint,prefix=run(data,steps=CUT)\n",
    "    restored,tail=run(data,checkpoint,STEPS-CUT)\n",
    "    _,reverse=run(data,reverse=True)\n",
    "    broken_optimizer=copy.deepcopy(checkpoint);broken_optimizer['m'][:]=0;broken_optimizer['v'][:]=0\n",
    "    # Model the common partial-restart behavior: reset both Adam moments and its step counter.\n",
    "    broken_optimizer['step']=0\n",
    "    _,badopt=run(data,broken_optimizer,STEPS-CUT)\n",
    "    # Report training positions on the common x-axis; the optimizer counter remains reset internally.\n",
    "    for j,t in enumerate(badopt):t['step']=CUT+j+1\n",
    "    broken_rng=copy.deepcopy(checkpoint);broken_rng['rng']=copy.deepcopy(np.random.default_rng(99).bit_generator.state)\n",
    "    _,badrng=run(data,broken_rng,STEPS-CUT)\n",
    "    traces={'Reference':ref,'Same seed + full state':same,'Full checkpoint':prefix+tail,'Reversed reduction':reverse,'Optimizer reset':prefix+badopt,'Sampler RNG reset':prefix+badrng}\n",
    "    rows=[]\n",
    "    for name,trace in traces.items():\n",
    "        if name=='Reference':continue\n",
    "        for a,b in zip(ref,trace):\n",
    "            rows.append({'scenario':name,'step':a['step'],'exact_weights_match':a['weight_hash']==b['weight_hash'],'exact_state_match':a['state_hash']==b['state_hash'],'same_4dp_loss':a['printed_loss']==b['printed_loss'],'max_weight_error':float(np.max(np.abs(a['weights'].astype(float)-b['weights']))),'loss':b['loss'],'reference_loss':a['loss']})\n",
    "    return data,traces,rows,checkpoint,final,restored\n",
    "\n",
    "def validate(data,traces,rows,checkpoint,final,restored):\n",
    "    tests=[]\n",
    "    def check(name,ok):assert ok,name;tests.append(name)\n",
    "    check('same-state repeat matches at every step',all(r['exact_state_match'] for r in rows if r['scenario']=='Same seed + full state'))\n",
    "    check('full checkpoint matches at every step',all(r['exact_state_match'] for r in rows if r['scenario']=='Full checkpoint'))\n",
    "    check('full resumed final arrays are byte equal',all(final[k].tobytes()==restored[k].tobytes() for k in ['w','m','v']))\n",
    "    check('full resumed RNG and step equal',final['step']==restored['step'] and final['rng']==restored['rng'])\n",
    "    a=traces['Reference'][0];b=traces['Reversed reduction'][0]\n",
    "    check('reduction comparison has identical ordered inputs',a['gradient_input_hash']==b['gradient_input_hash'])\n",
    "    check('reduction order changes first gradient bytes',a['gradient_hash']!=b['gradient_hash'])\n",
    "    check('changed order is hidden by rounded logging somewhere',any(not r['exact_weights_match'] and r['same_4dp_loss'] for r in rows if r['scenario']=='Reversed reduction'))\n",
    "    for name in ['Optimizer reset','Sampler RNG reset']:\n",
    "        check(name+' matches prefix',all(r['exact_state_match'] for r in rows if r['scenario']==name and r['step']<=CUT))\n",
    "        check(name+' breaks replay after restore',any(not r['exact_state_match'] for r in rows if r['scenario']==name and r['step']>CUT))\n",
    "    check('training loss decreases',traces['Reference'][-1]['loss']<traces['Reference'][0]['loss'])\n",
    "    check('fingerprint detects permutation',digest(np.array([1,2,3]))!=digest(np.array([3,2,1])))\n",
    "    # Different dtypes and shapes must not accidentally share a byte-only digest.\n",
    "    check('fingerprint includes shape and dtype',digest(np.array([1,2],np.int32))!=digest(np.array([[1,2]],np.int32)))\n",
    "    return tests\n",
    "\n",
    "def summarize(rows,traces):\n",
    "    out=[]\n",
    "    for name in COLORS:\n",
    "        r=[r for r in rows if r['scenario']==name]\n",
    "        bad=[v['step'] for v in r if not v['exact_weights_match']]\n",
    "        out.append({'scenario':name,'first_weight_mismatch':min(bad) if bad else None,'weight_mismatch_steps':len(bad),'hidden_weight_mismatch_steps':sum(not v['exact_weights_match'] and v['same_4dp_loss'] for v in r),'maximum_weight_difference':max(v['max_weight_error'] for v in r),'final_loss':r[-1]['loss']})\n",
    "    return out\n",
    "\n",
    "def make_figures(rows,traces,out=ROOT):\n",
    "    plt.rcParams.update({'font.family':'DejaVu Sans','font.size':11,'axes.spines.top':False,'axes.spines.right':False,'axes.edgecolor':'#555555','axes.labelcolor':'#333333','text.color':'#222222','xtick.color':'#555555','ytick.color':'#555555','axes.titleweight':'normal','axes.titlesize':12,'svg.fonttype':'none','figure.facecolor':'white','axes.facecolor':'white','grid.color':'#dddddd','grid.linewidth':.6})\n",
    "    fig,axs=plt.subplots(2,1,figsize=(9.2,6.4),gridspec_kw={'height_ratios':[1.1,1.5]})\n",
    "    names=list(COLORS);matrix=np.array([[int(r['exact_weights_match']) for r in rows if r['scenario']==n] for n in names])\n",
    "    from matplotlib.colors import ListedColormap\n",
    "    from matplotlib.patches import Patch\n",
    "    axs[0].imshow(matrix,aspect='auto',extent=(.5,100.5,4.5,-.5),cmap=ListedColormap(['#536b7a','#eeeeee']),vmin=0,vmax=1,interpolation='nearest')\n",
    "    axs[0].set_yticks(range(5),names);axs[0].set_xticks([1,20,40,60,80,100]);axs[0].tick_params(axis='y',length=0);axs[0].set_title('Exact weight agreement with the reference',loc='left',pad=30);axs[0].axvline(CUT+.5,color='#333333',lw=.8)\n",
    "    axs[0].legend(handles=[Patch(facecolor='#eeeeee',label='Matching bytes'),Patch(facecolor='#536b7a',label='Different bytes')],loc='lower left',bbox_to_anchor=(0,1.01),ncol=2,frameon=False,fontsize=9,borderaxespad=0)\n",
    "    styles={'Reversed reduction':('#333333','-'),'Optimizer reset':('#9a9a9a','--'),'Sampler RNG reset':('#536b7a',':')}\n",
    "    for n,(c,ls) in styles.items():\n",
    "        aa=[r for r in rows if r['scenario']==n and r['max_weight_error']>0]\n",
    "        axs[1].plot([r['step'] for r in aa],[r['max_weight_error'] for r in aa],color=c,ls=ls,label=n,lw=1.6)\n",
    "    axs[1].set_yscale('log');axs[1].set_xlabel('Training step');axs[1].set_ylabel('Maximum weight difference');axs[1].axvline(CUT+.5,color='#bbbbbb',ls=':',lw=1);axs[1].grid(axis='y');axs[1].legend(frameon=False,fontsize=9,ncol=3,loc='upper center',bbox_to_anchor=(.5,-.22))\n",
    "    fig.text(.03,.012,'Float32 CPU study · checkpoint after step 40 · zero differences omitted from the logarithmic plot',fontsize=9,color='#666666')\n",
    "    fig.tight_layout(rect=(0,.055,1,1),h_pad=2.5)\n",
    "    for name in ['replay','cover']:\n",
    "        fig.savefig(out/(name+'.svg'),bbox_inches='tight');fig.savefig(out/(name+'.png'),dpi=180,bbox_inches='tight')\n",
    "    plt.close(fig)\n",
    "    ref=traces['Reference'];rev=traces['Reversed reduction']\n",
    "    fig,ax=plt.subplots(figsize=(7,4))\n",
    "    ax.plot(range(1,STEPS+1),[x['loss'] for x in ref],color='#aaaaaa',lw=2.2,label='Reference');ax.plot(range(1,STEPS+1),[x['loss'] for x in rev],color='#333333',lw=1.2,ls='--',label='Reversed reduction')\n",
    "    ax.set_xlabel('Training step');ax.set_ylabel('Evaluation mean squared error');ax.legend(frameon=False,fontsize=10);ax.grid(axis='y');fig.tight_layout();fig.savefig(out/'hidden-drift.svg',bbox_inches='tight');fig.savefig(out/'hidden-drift.png',dpi=180,bbox_inches='tight');plt.close(fig)\n",
    "\n",
    "def main():\n",
    "    data,traces,rows,checkpoint,final,restored=run_experiment();tests=validate(data,traces,rows,checkpoint,final,restored);summary=summarize(rows,traces)\n",
    "    (ROOT/'results.json').write_text(json.dumps({'config':{'steps':STEPS,'checkpoint_step':CUT,'batch':BATCH,'dimensions':D,'rows':512,'data_seed':20261106,'weights_seed':17,'sampler_seed':99,'dtype':'float32','optimizer':'Adam','learning_rate':.04},'summary':summary,'tests':tests,'traces':{k:serial_trace(v) for k,v in traces.items()}},indent=2))\n",
    "    with (ROOT/'comparisons.csv').open('w',newline='') as f:w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows)\n",
    "    np.savez(ROOT/'checkpoint.npz',w=checkpoint['w'],m=checkpoint['m'],v=checkpoint['v'])\n",
    "    (ROOT/'checkpoint-state.json').write_text(json.dumps({'step':checkpoint['step'],'rng':checkpoint['rng'],'data_sha256':digest(data[0])+':'+digest(data[1]),'note':'Load checkpoint.npz with allow_pickle=False. Recreate the documented fixed data and configuration.'},indent=2))\n",
    "    # Verify the file round-trip independently of the in-memory replay.\n",
    "    loaded=np.load(ROOT/'checkpoint.npz',allow_pickle=False);meta=json.loads((ROOT/'checkpoint-state.json').read_text());s={k:loaded[k] for k in ['w','m','v']};s.update(step=meta['step'],rng=meta['rng']);disk_final,_=run(data,s,STEPS-CUT)\n",
    "    assert state_digest(disk_final)==state_digest(final);tests.append('saved checkpoint file round-trip matches reference')\n",
    "    make_figures(rows,traces)\n",
    "    saved=json.loads((ROOT/'results.json').read_text());saved['tests']=tests;(ROOT/'results.json').write_text(json.dumps(saved,indent=2))\n",
    "    (ROOT/'checks.json').write_text(json.dumps({'passed':tests,'count':len(tests)},indent=2))\n",
    "    print(json.dumps({'checks_passed':len(tests),'summary':summary,'reference_final_loss':traces['Reference'][-1]['loss']},indent=2))\n",
    "\n"
   ],
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "id": "89f6f076ee",
   "metadata": {},
   "source": [
    "## Run the study and its assertions\n",
    "The printed results are computed, not illustrative. Change the constants in the previous cell to explore a different controlled setup."
   ]
  },
  {
   "cell_type": "code",
   "id": "a8b6c5ba40",
   "metadata": {},
   "source": [
    "main()\n"
   ],
   "execution_count": 2,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{\n",
      "  \"checks_passed\": 15,\n",
      "  \"summary\": [\n",
      "    {\n",
      "      \"scenario\": \"Same seed + full state\",\n",
      "      \"first_weight_mismatch\": null,\n",
      "      \"weight_mismatch_steps\": 0,\n",
      "      \"hidden_weight_mismatch_steps\": 0,\n",
      "      \"maximum_weight_difference\": 0.0,\n",
      "      \"final_loss\": 0.020268479118598137\n",
      "    },\n",
      "    {\n",
      "      \"scenario\": \"Full checkpoint\",\n",
      "      \"first_weight_mismatch\": null,\n",
      "      \"weight_mismatch_steps\": 0,\n",
      "      \"hidden_weight_mismatch_steps\": 0,\n",
      "      \"maximum_weight_difference\": 0.0,\n",
      "      \"final_loss\": 0.020268479118598137\n",
      "    },\n",
      "    {\n",
      "      \"scenario\": \"Reversed reduction\",\n",
      "      \"first_weight_mismatch\": 1,\n",
      "      \"weight_mismatch_steps\": 100,\n",
      "      \"hidden_weight_mismatch_steps\": 100,\n",
      "      \"maximum_weight_difference\": 1.1920928955078125e-07,\n",
      "      \"final_loss\": 0.020268477811632834\n",
      "    },\n",
      "    {\n",
      "      \"scenario\": \"Optimizer reset\",\n",
      "      \"first_weight_mismatch\": 41,\n",
      "      \"weight_mismatch_steps\": 60,\n",
      "      \"hidden_weight_mismatch_steps\": 1,\n",
      "      \"maximum_weight_difference\": 0.1605449914932251,\n",
      "      \"final_loss\": 0.024593437931813907\n",
      "    },\n",
      "    {\n",
      "      \"scenario\": \"Sampler RNG reset\",\n",
      "      \"first_weight_mismatch\": 41,\n",
      "      \"weight_mismatch_steps\": 60,\n",
      "      \"hidden_weight_mismatch_steps\": 1,\n",
      "      \"maximum_weight_difference\": 0.02873385325074196,\n",
      "      \"final_loss\": 0.02016254975299807\n",
      "    }\n",
      "  ],\n",
      "  \"reference_final_loss\": 0.020268479118598137\n",
      "}\n"
     ]
    }
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8df3ada6d2",
   "metadata": {},
   "source": [
    "## Inspect the generated figures\n",
    "These are rendered from the results just computed."
   ]
  },
  {
   "cell_type": "code",
   "id": "6cf44ad689",
   "metadata": {},
   "source": [
    "from IPython.display import Image, display\n",
    "display(Image(filename=str(ROOT / 'replay.png')))\n",
    "display(Image(filename=str(ROOT / 'hidden-drift.png')))\n"
   ],
   "execution_count": 3,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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"
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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"
     },
     "metadata": {}
    }
   ]
  }
 ]
}