LAB 06 · 表示、损失与学习步长

import json
import numpy as np
import matplotlib.pyplot as plt
np.set_printoptions(precision=4, suppress=True)
plt.rcParams.update({'figure.dpi':110,'font.size':10,'axes.spines.top':False,'axes.spines.right':False})
BLUE, GOLD, GREEN, PURPLE = '#002676','#FDB515','#00856A','#69458D'
CHECKS={}; RESULTS={}
def check(name,condition):
    CHECKS[name]=bool(condition)
    assert CHECKS[name], name
def table(headers,rows,title):
    fig,ax=plt.subplots(figsize=(max(7,len(headers)*1.5),1+len(rows)*.36))
    ax.axis('off'); ax.set_title(title,pad=12,color=BLUE)
    tab=ax.table(cellText=rows,colLabels=headers,loc='center',cellLoc='center')
    tab.auto_set_font_size(False);tab.set_fontsize(10);tab.scale(1,1.45)
    for (r,c),cell in tab.get_celld().items():
        cell.set_edgecolor('#CBD5DF')
        if r==0:cell.set_facecolor('#E9F0F7')
    fig.tight_layout();plt.show()

P=dict(lamp_gain=1.0, lamp_threshold=0.5, softmax_shift=100.0, softmax_scale=2.0,
       scalar_lr=0.1, steps=20, learning_rates=[0.05,0.1,0.25,0.45,0.55],
       regression_seed=20260921, regression_noise=0.20, regression_train_n=24,
       regression_degrees=[1,3,9], regression_ridge=1e-4, split_mode='random')
# 批量验证入口；平常只需改上面的P，不需要设置USER_OVERRIDES。
P.update(globals().get('USER_OVERRIDES',{}))
print('Teaching configuration:',json.dumps(P,ensure_ascii=False))

lamps=np.array([[0.,0.],[1.,0.],[0.,1.],[1.,1.]])
labels=np.array([0,1,1,0]);names=['A','B','C','D']
gain=float(P['lamp_gain']);threshold=float(P['lamp_threshold'])
assert gain>0,'本模块约定正gain；负gain请先重写预测。'
raw=lamps@np.array([[gain,-gain],[-gain,gain]])
hidden=np.maximum(raw,0);scores=hidden.sum(1)-threshold;pred=(scores>0).astype(int)
check('lamp_hidden_formula',np.allclose(hidden,[[0,0],[gain,0],[0,gain],[0,0]]))
check('without_relu_two_differences_cancel',np.allclose(raw.sum(1),0))
table(['ID','input','hidden','score','label','prediction'],
      [[names[i],str(lamps[i].astype(int).tolist()),str(hidden[i].tolist()),f'{scores[i]:.3f}',int(labels[i]),int(pred[i])] for i in range(4)],
      'Same four lamp states, different coordinates')
fig,axes=plt.subplots(1,2,figsize=(10,4))
for ax,points,title in zip(axes,[lamps,hidden],['Input coordinates','Hidden coordinates']):
    for i,(x,y) in enumerate(points):
        ax.scatter(x,y,s=100,facecolors='white' if i==3 else (BLUE if labels[i] else PURPLE),edgecolors=BLUE if labels[i] else PURPLE,zorder=3)
        dy=-.10 if i==3 else .08
        ax.annotate(names[i],(x,y),xytext=(8,-15 if i==3 else 8),textcoords='offset points')
    lim=max(1,gain)*1.25;ax.set(xlim=(-.2,lim),ylim=(-.2,lim),title=title,xlabel='coordinate 1',ylabel='coordinate 2');ax.set_aspect('equal');ax.grid(alpha=.2)
axis=np.linspace(0,max(gain,threshold,1),100)
axes[1].plot(axis,threshold-axis,'--',color=GREEN,label='h1 + h2 = threshold');axes[1].legend()
fig.tight_layout();plt.show()
RESULTS['lamps']={'hidden':hidden.tolist(),'predictions':pred.tolist(),'accuracy':float((pred==labels).mean())}

def softmax(z):
    z=np.asarray(z,dtype=float);e=np.exp(z-z.max());return e/e.sum()
def ce_logits(z,target):
    z=np.asarray(z,dtype=float);m=z.max();return float(m+np.log(np.exp(z-m).sum())-z[target])
z=np.array([2.,1.,0.]);assert P['softmax_scale']>0
p0=softmax(z);ps=softmax(z+P['softmax_shift']);pt=softmax(z*P['softmax_scale'])
check('softmax_translation',np.allclose(p0,ps,rtol=1e-12,atol=1e-12))
check('softmax_positive_scale_preserves_argmax',p0.argmax()==pt.argmax())
check('softmax_probabilities_sum_to_one',all(np.isclose(p.sum(),1) for p in [p0,ps,pt]))
table(['configuration','p(A)','p(B)','p(C)','CE if A true'],[[name,*[f'{v:.4f}' for v in prob],f'{-np.log(prob[0]):.4f}'] for name,prob in [('base',p0),('common shift',ps),('positive scale',pt)]],'Relative scores determine probabilities')
fig,ax=plt.subplots(figsize=(8,3.5));pos=np.arange(3)
for j,(p,name,color) in enumerate([(p0,'base',BLUE),(ps,'shift',GOLD),(pt,'scale',GREEN)]):ax.bar(pos+(j-1)*.23,p,.23,label=name,color=color)
ax.set(xticks=pos,xticklabels=['A','B','C'],ylim=(0,1),ylabel='Probability');ax.legend();fig.tight_layout();plt.show()
truth_prob=np.array([.6,.2,.01]);losses=-np.log(truth_prob)
table(['True-class probability','Cross-entropy'],[[f'{p:.2f}',f'{l:.4f}'] for p,l in zip(truth_prob,losses)],'Higher true-class probability, smaller cross-entropy')
eps=1e-5;numeric=np.array([(ce_logits(z+eps*np.eye(3)[i],0)-ce_logits(z-eps*np.eye(3)[i],0))/(2*eps) for i in range(3)])
analytic=p0-np.array([1,0,0]);check('CE_logit_gradient',np.allclose(numeric,analytic,atol=1e-9))
print('CE gradient, analytic:',analytic,' finite difference:',numeric)
RESULTS['softmax']={'base':p0.tolist(),'shifted':ps.tolist(),'scaled':pt.tolist(),'CE_examples':losses.tolist(),'gradient_max_error':float(np.max(np.abs(numeric-analytic)))}
# Exact logical counterexample: real class A=0; predicted class B stays wrong.
wrong_probs=np.array([[.1,.9],[.01,.99]],dtype=float)
wrong_entropy=-(wrong_probs*np.log(wrong_probs)).sum(1)
wrong_ce=-np.log(wrong_probs[:,0])
wrong_pred=wrong_probs.argmax(1)
assert np.array_equal(wrong_pred,[1,1])
assert wrong_entropy[1]<wrong_entropy[0] and wrong_ce[1]>wrong_ce[0]
table(['p(A)','p(B)','H (natural log)','CE if A true','correct?'],
      [[*p,round(float(h),6),round(float(l),6),False] for p,h,l in zip(wrong_probs,wrong_entropy,wrong_ce)],
      'Entropy falls while the prediction stays wrong: exact construction')
RESULTS['entropy_counterexample']={'probabilities':wrong_probs.tolist(),'entropy_nats':wrong_entropy.tolist(),
 'true_class':0,'predictions':wrong_pred.tolist(),'cross_entropy':wrong_ce.tolist(),'identity':'exact mathematical construction; no Tent execution'}
print('This is not a measured Tent trajectory. It only refutes entropy decrease => correctness.')

scalar_x,scalar_t,scalar_w=2.,0.,1.
def scalar_loss(w):return .5*(scalar_x*w-scalar_t)**2
old_y=scalar_x*scalar_w;old_loss=scalar_loss(scalar_w)
upstream=old_y-scalar_t;local=scalar_x;gradient=upstream*local
numeric=(scalar_loss(scalar_w+1e-5)-scalar_loss(scalar_w-1e-5))/(2e-5)
eta=float(P['scalar_lr']);new_w=scalar_w-eta*gradient;new_y=scalar_x*new_w;new_loss=scalar_loss(new_w)
check('scalar_chain_rule',np.isclose(gradient,4) and np.isclose(numeric,gradient,atol=1e-9))
if eta==.1:check('slide_scalar_update',np.allclose([new_w,new_y,new_loss],[.6,1.2,.72]))
table(['state','w','y','loss','gradient used'],[['before',scalar_w,old_y,old_loss,gradient],['after',f'{new_w:.4f}',f'{new_y:.4f}',f'{new_loss:.4f}','old-point g=4']],'One update, then a fresh forward pass')
grid=np.linspace(min(-.4,new_w-.3),max(1.3,new_w+.3),250)
fig,ax=plt.subplots(figsize=(8,3.6));ax.plot(grid,scalar_loss(grid),color=BLUE,label='L(w)=2w^2');ax.scatter([scalar_w,new_w],[old_loss,new_loss],c=[GOLD,GREEN],s=85,zorder=3)
ax.annotate('old',(scalar_w,old_loss),xytext=(8,10),textcoords='offset points');ax.annotate('new',(new_w,new_loss),xytext=(8,10),textcoords='offset points')
ax.annotate('',xy=(new_w,-.15),xytext=(scalar_w,-.15),arrowprops=dict(arrowstyle='->',color=GREEN));ax.set(xlabel='Parameter w',ylabel='Loss',title=f'Learning rate = {eta:g}');ax.legend();fig.tight_layout();plt.show()
RESULTS['scalar']={'gradient':gradient,'eta':eta,'w_new':new_w,'y_new':new_y,'loss_new':new_loss}

steps=int(P['steps']);assert 1<=steps<=100
rates=list(map(float,P['learning_rates']));assert all(0<=r<=1 for r in rates)
traces={}
for rate in rates:
    ws=[1.]
    for _ in range(steps):ws.append(ws[-1]-rate*4*ws[-1])
    ws=np.array(ws);check(f'scalar_closed_form_eta_{rate}',np.allclose(ws,(1-4*rate)**np.arange(steps+1)))
    traces[rate]=ws
fig,axes=plt.subplots(1,2,figsize=(11,4))
for rate,ws in traces.items():
    axes[0].plot(ws,marker='.',label=f'eta={rate:g}')
    axes[1].semilogy(np.maximum(scalar_loss(ws),1e-14),label=f'eta={rate:g}')
axes[0].set(xlabel='Update',ylabel='w',title='Parameter trajectories');axes[0].axhline(0,color='grey',lw=1)
axes[1].set(xlabel='Update',ylabel='Loss (display floor 1e-14)',title='Same objective, different step sizes')
for ax in axes:ax.legend(fontsize=8)
fig.tight_layout();plt.show()
table(['eta','multiplier 1-4 eta','final w','final loss'],[[r,f'{1-4*r:.3f}',f'{w[-1]:.6g}',f'{scalar_loss(w[-1]):.6g}'] for r,w in traces.items()],'Convergence depends on the local curvature and step size')
RESULTS['rates']={str(r):{'last_w':float(w[-1]),'last_loss':float(scalar_loss(w[-1]))} for r,w in traces.items()}

rng=np.random.default_rng(int(P['regression_seed']));ntr=int(P['regression_train_n']);assert 8<=ntr<=200
nval,ntest=60,60;total=ntr+nval+ntest
xx=rng.uniform(-1,1,total);truth=np.sin(np.pi*xx)+.25*xx
yy=truth+float(P['regression_noise'])*rng.normal(size=total)
mode=P['split_mode'];assert mode in ['random','ordered']
order=rng.permutation(total) if mode=='random' else np.argsort(xx)
itr,iva,ite=np.split(order,[ntr,ntr+nval])
check('regression_disjoint_splits',len(set(itr)&set(iva))==len(set(itr)&set(ite))==len(set(iva)&set(ite))==0)
ridge=float(P['regression_ridge']);assert ridge>=0
degrees=list(map(int,P['regression_degrees']));assert all(1<=d<=20 for d in degrees)
fits={};rows=[]
for degree in degrees:
    Xtr=np.polynomial.legendre.legvander(xx[itr],degree);Xva=np.polynomial.legendre.legvander(xx[iva],degree)
    penalty=np.eye(degree+1);penalty[0,0]=0
    # Augmented least squares: mean training squared error + ridge*||non-intercept weights||^2.
    A=np.vstack([Xtr/np.sqrt(ntr),np.sqrt(ridge)*penalty]);b=np.r_[yy[itr]/np.sqrt(ntr),np.zeros(degree+1)]
    coef=np.linalg.lstsq(A,b,rcond=None)[0]
    tr=float(np.mean((Xtr@coef-yy[itr])**2));va=float(np.mean((Xva@coef-yy[iva])**2))
    fits[degree]={'coef':coef,'train':tr,'validation':va};rows.append([degree,f'{tr:.5f}',f'{va:.5f}'])
selected=min(degrees,key=lambda d:fits[d]['validation'])
table(['Degree','Training MSE','Validation MSE'],rows,f'Selection uses validation only; split={mode}')
plot_x=np.linspace(-1,1,300);fig,axes=plt.subplots(1,2,figsize=(11,4))
axes[0].scatter(xx[itr],yy[itr],s=18,label='train',color=BLUE);axes[0].scatter(xx[iva],yy[iva],s=14,facecolors='none',edgecolors=GREEN,label='validation')
axes[0].plot(plot_x,np.sin(np.pi*plot_x)+.25*plot_x,'k--',label='known synthetic function')
for degree,fit in fits.items():axes[0].plot(plot_x,np.polynomial.legendre.legval(plot_x,fit['coef']),label=f'degree {degree}')
axes[0].set(xlabel='x',ylabel='y',title='Constructed regression; test points withheld',ylim=(-3,3));axes[0].legend(fontsize=7)
pos=np.arange(len(degrees));axes[1].bar(pos-.17,[fits[d]['train'] for d in degrees],.34,label='train',color=BLUE);axes[1].bar(pos+.17,[fits[d]['validation'] for d in degrees],.34,label='validation',color=GREEN)
axes[1].set(xticks=pos,xticklabels=degrees,xlabel='Polynomial degree',ylabel='MSE',title='Compare frozen fitted models');axes[1].legend();fig.tight_layout();plt.show()
# Only now evaluate the locked choice on test. Test values never entered selection.
test_prediction=np.polynomial.legendre.legval(xx[ite],fits[selected]['coef'])
test_mse=float(np.mean((test_prediction-yy[ite])**2))
check('selected_by_validation',fits[selected]['validation']==min(f['validation'] for f in fits.values()))
print('Locked degree:',selected,' final test MSE:',round(test_mse,6))
print('Split x ranges:',{name:[round(float(xx[ids].min()),3),round(float(xx[ids].max()),3)] for name,ids in [('train',itr),('validation',iva),('test',ite)]})
RESULTS['regression']={'mode':mode,'selected_degree':selected,'train_n':ntr,'validation_n':nval,'test_n':ntest,'test_mse':test_mse,'candidates':{str(d):{'train':fits[d]['train'],'validation':fits[d]['validation']} for d in degrees}}
print('Checks passed:',sum(CHECKS.values()),'/',len(CHECKS))

# 独立教学构造：二次目标与步长，不训练任何图像模型。
import math
def loss(w): return 0.5*(w[0]**2+10*w[1]**2)
def grad(w): return [w[0],10*w[1]]
def run(eta,steps=8):
    w=[2.,1.]; trace=[loss(w)]
    for _ in range(steps):
        g=grad(w); w=[a-eta*b for a,b in zip(w,g)]; trace.append(loss(w))
    return w,trace
for eta in [0.05,0.6]:
    w,trace=run(eta)
    print('eta',eta,'loss', [round(v,6) for v in trace])
assert run(.05)[1][-1] < run(.05)[1][0]
assert run(.6)[1][-1] > run(.6)[1][0]
scores=[2.,1.,0.]
softmax=lambda a:[math.exp(x-max(a))/sum(math.exp(z-max(a)) for z in a) for x in a]
assert all(abs(a-b)<1e-12 for a,b in zip(softmax(scores),softmax([x+10 for x in scores])))
print('共同平移的概率：',softmax(scores))