ఒక భాషా నమూనా తన సొంత బరువులను తానే తిరగరాసుకుంటుంది
ఒక భాషా నమూనాకు ఒకసారి శిక్షణ ఇస్తారు, స్తంభింపజేస్తారు, వినియోగంలోకి తెస్తారు. దాన్ని మెరుగుపరచాలంటే, సాధారణంగా మరో శిక్షణ అవసరం — పెద్ద కంప్యూటింగ్ క్లస్టర్లు, ఒక శిక్షణ పైప్లైన్, వాటిని ఉపయోగించడం తెలిసిన మనుషులు. వినియోగదారు మార్చగలిగేది — ప్రాంప్ట్ (prompt) — పని మారగానే మాయమవుతుంది. UIUC, CMU, Rutgers, Princeton, Stanford లకు చెందిన జియాజున్ ఫాన్ (Jiajun Fan), గే లియు (Ge Liu), సహచరులు ఒక భిన్నమైన ప్రశ్న అడిగారు: ఒక నమూనా, ఏ శిక్షణా లేకుండా కేవలం తర్కం ద్వారా, తన సొంత బరువులను తిరగరాసుకోగలదా? బరువులు (weights) అంటే దాన్ని నిర్వచించే బిలియన్ల కొద్దీ సంఖ్యలు.
వారి సమాధానం అవును అని, అదీ “మాకు తెలిసినంతవరకు మొదటిసారిగా” అని వారు రాశారు. దీన్ని వారు స్వీయ-పునర్లేఖనం (self-rewriting) అని పిలుస్తారు.
తన సొంత బరువులపై ఒక సెషన్
ప్రయోగాలు ఓపెన్ నమూనాల ఒకే కుటుంబాన్ని, Qwen3.5ను, నాలుగు పరిమాణాల్లో ఉపయోగిస్తాయి: 2, 4, 9, 27 బిలియన్ పారామితులు. ప్రతి నమూనాకు తన సొంత బరువులపై ఒక సెషన్ లభిస్తుంది. సాధన కోసం ఇచ్చిన గణిత సమస్యలపై గ్రేడ్ చేసిన తన సమాధానాలను, తన బరువు మాతృకలను చదివి తిరగరాయగల ఒక Python వాతావరణాన్ని అది అందుకుంటుంది. అది తనను తాను పరిమిత సంఖ్యలో నడిపించుకోనూ గలదు — 20 ఫార్వర్డ్ పాస్లు (forward passes) — తన సవరణతోనూ, అది లేకుండానూ, అవే యాదృచ్ఛిక సీడ్లను (random seeds) ఉపయోగించి సమస్యలకు సమాధానాలివ్వడానికి, లేదా తన సొంత దాగిన స్థితులను (hidden states) చదవడానికి.
అది చేయలేనిది శిక్షణ. వాతావరణం గ్రేడియంట్ల (gradients) ఏ గణననైనా, ఏ ఆప్టిమైజర్నైనా (optimizer) తిరస్కరిస్తుంది; దానికి GPU లేదు, నెట్వర్క్ యాక్సెస్ లేదు; ఒక మొత్తం మాతృక స్కేల్ను మాత్రమే మార్చే సవరణలను అది అడ్డుకుంటుంది. నమూనా మార్చే ప్రతి విలువా దాని సొంత తర్కం ద్వారానే రాయబడుతుంది. ఆ తర్వాత ఫలితాలను సెషన్లు ఎప్పుడూ చూడని సమస్యలపై తనిఖీ చేస్తారు.
పాడైన మాతృకను కనుగొనడం
మొదటి పరీక్షలో, బృందం 27 బిలియన్ పారామితుల నమూనాకు తన దెబ్బతిన్న నకలును ఇచ్చింది: 64 పొరల్లో 30వ పొరలోని ఒక మాతృకలో ఎనిమిది వరుసలను శబ్దంతో (noise) తిరగరాశారు. కొన్ని విలువలు పాడయ్యాయని మాత్రమే నమూనాకు చెప్పారు. ఆ నకలు ఏ సమస్యనూ పరిష్కరించలేకపోయింది.
దాని సెషన్ డీబగ్గింగ్లా చదువుతుంది. అది మొదట ప్రారంభ పొరలను అనుమానించింది — తప్పు, దాని సొంత పరీక్షలే ఆ మాట చెప్పాయి. తర్వాత అది ప్రతి అవుట్పుట్ మాతృకలోని అతిపెద్ద బరువును సాధారణమైన బరువుతో పోల్చి, దోషిని కనుగొంది: “30వ పొర యొక్క down_proj లో ఒక తీవ్రమైన 1397x అసాధారణ విలువ ఉంది”. దాని సవరణ మృదువైనది: ఆ మాతృకలో, మరో 19 మాతృకల్లో, తన మాతృక మధ్యగతానికి 15 రెట్లు మించిన ఏ బరువునైనా ఆ స్థాయికి పరిమితం చేసింది. తాను ఎప్పుడూ చూడని అసలు విలువలను అది పునరుద్ధరించలేదు; యాదృచ్ఛికమైనవాటిని కత్తిరించింది. రిజర్వ్ చేసిన (held-out) 200 గణిత సమస్యలపై, నకలు 0% నుంచి 33%కు చేరింది. ఇంకా విశేషమేమిటంటే, కేవలం పాఠ్యంపై కనుగొన్న ఈ మరమ్మతు చిత్రాలపై కూడా పనిచేసింది: అది ఎప్పుడూ చూడని ఆరు చిత్ర బెంచ్మార్క్లలో (benchmarks), నకలు 7.3% నుంచి 70.2%కు పెరిగింది — ఇది దెబ్బతినని నమూనా కచ్చితత్వంలో 83%.
ఆపడం తనకు తానే నేర్పుకోవడం
దెబ్బతినని తన సొంత బరువులపై, 27B నమూనా ఒక నిర్ధారణతో మొదలుపెట్టింది: దాని సమాధానాల్లో చాలావరకు టోకెన్లు (tokens) అయిపోయేవరకు సాగాయి, అయినా పూర్తయినవాటిలో దాదాపు అన్నీ సరైనవే. దాని సొంత మాటల్లో: “నా తర్కం సరైనదే, కానీ నేను మరీ ఎక్కువగా మాట్లాడుతున్నాను, లేదా సమర్థవంతంగా నిర్ధారణలకు చేరుకోవడం లేదు.”
కాబట్టి అది పూర్తయ్యే సమాధానాలపై, సాగుతూనే ఉండే సమాధానాలపై తన దాగిన స్థితులను పోల్చి, వాటిని వేరుచేసే దిశను కనుగొని, ఒక పొర నుంచి దానిలో ఒక చిన్న భాగాన్ని తొలగించింది. దాని పరీక్షలు సవరణకు అనుకూలంగా వచ్చాయి. రెండో ప్రోటోకాల్లో, నమూనా ప్రతి సవరణను సమర్పించాలని ఎంచుకునే ముందు, ఫ్రేమ్వర్క్ దాన్ని రిజర్వ్ చేసిన సమస్యలపై ఒకసారి తనిఖీ కూడా చేసింది. అలాంటి మొదటి ఎనిమిది సెషన్లలో — అన్నీ నివేదించబడ్డాయి — నమూనా ఐదింటిలో ఉపసంహరించుకుంది, మూడింటిని సమర్పించింది. వాటిలో రెండు దాన్ని 490 కొత్త సమస్యలపై గణనీయంగా మెరుగుపరిచాయి: +6.6 పాయింట్లు (57.2% నుంచి 63.8%కు), +4.0 పాయింట్లు. పెద్ద లాభం ఆశ్చర్యకరంగా సరళమైన ఒక మార్పు నుంచి వచ్చింది — ప్రతి రేఖీయ-అవధాన పొరలో (linear-attention layer) ఒక సెట్టింగ్ను కొద్దిగా జరపడం — ఆ తర్వాత తక్కువ సమాధానాల్లో టోకెన్లు అయిపోయాయి. ఒక సమస్యపై, అసలు నమూనా సమాధానం ఇవ్వకుండా ఒకే వాక్యాన్ని 549 సార్లు పునరావృతం చేసింది; సవరణ తర్వాత, అది సరిగ్గా సమాధానమిచ్చింది. అతిపెద్ద లాభాల వెనుక ఉన్న ప్రతి సెషన్ ఒకే GPU పై కొన్ని గంటల్లో నడిచింది.
అతిపెద్ద నమూనా మాత్రమే సాధిస్తుంది
అదే పని, అవే సాధనాలు ఉన్నప్పటికీ, పరిమాణమే అన్ని తేడాలనూ తెచ్చింది. 2 బిలియన్ పారామితుల నమూనా ఏ సవరణా చేయలేదు: దాని కోడ్లో చాలావరకు విఫలమైంది. 4, 9 బిలియన్ నమూనాలు తమ బరువులకు యాదృచ్ఛిక శబ్దాన్ని జోడించి తమను తాము పాడుచేసుకున్నాయి; 9 బిలియన్ నమూనా అయితే కొత్త సమస్యలకు సమాధానం ఇవ్వలేని స్థితికి తనను నెట్టిన ఒక సవరణను సమర్పించింది కూడా. 27 బిలియన్ నమూనా మాత్రమే చర్యకు ముందు కొలిచి, తన పరీక్షలు సమర్థించినదాన్నే ఉంచుకుంది. రచయితల దృష్టిలో, తన సొంత బరువులను నిర్ధారించి తిరగరాసే సామర్థ్యం పరిమాణంతో పాటు పెరుగుతుందనడానికి, ఒకే నమూనా కుటుంబంలో, ఇది మొదటి సాక్ష్యం.
వాదనలు దేనిపై ఆధారపడి ఉన్నాయి
ఫలితాలు ఒకే నమూనా కుటుంబం నుంచి, ఎక్కువగా గణిత సమస్యల నుంచి వచ్చాయి. లాభాలు ప్రధానంగా ఎప్పటికీ ముగియని సమాధానాలను సరిచేస్తాయి; సమర్పించిన మూడు సవరణల్లో ఒకటి గణనీయమైన లాభాన్ని తేలేదు. నష్టం తొలగించినదానిలో చాలావరకు మరమ్మతు తిరిగి తెస్తుంది, అంతా కాదు. ఒక నమూనాను మెరుగుపరచడానికి “శిక్షణ కాకుండా ఒక సంభాషణ” అవసరమయ్యే భవిష్యత్తును రచయితలు చూస్తున్నారు — బహుశా తమను తాము మళ్లీ మళ్లీ మెరుగుపరచుకునే నమూనాల వైపు ఒక మార్గాన్ని కూడా. ఆ మార్గాన్ని మనుషులను భాగస్వాములుగా ఉంచుకుని (in the loop) అనుసరించాలని వారు నొక్కి చెబుతారు: ఒక నమూనా తనను తాను మార్చుకుని తయారుచేసే ప్రతి నమూనానూ, పని కోసమే కాక భద్రత కోసం కూడా మూల్యాంకనం చేసి, ఒక మనిషి ధ్రువీకరించాలి.
