విస్తృతమైన లీడర్‌బోర్డ్‌లపై ఒక మోడల్‌ను బెంచ్‌మార్కింగ్ చేయడం ద్వారా అది ట్రివియా మరియు ప్రామాణిక పరీక్షలను ఎంత బాగా హ్యాండిల్ చేయగలదో మీకు తెలుస్తుంది. మీ ప్రొడక్షన్ సిస్టమ్స్ నిజంగా ఎదుర్కొనే గందరగోళమైన, పరిమితమైన సమస్యల ద్వారా అది ఎలా రీజనింగ్ (reasoning) చేస్తుందో ఇది మీకు దాదాపు ఏమీ చెప్పదు. మీరు ఏదైనా లార్జ్ లాంగ్వేజ్ మోడల్‌ను వినియోగదారులకు పంపే ముందు, మీ అప్లికేషన్‌కు అవసరమైన నిర్దిష్ట కాగ్నిటివ్ ప్యాటర్న్స్‌ను పరీక్షించే ఒక హార్నెస్ (harness) మీకు అవసరం. రీజనింగ్ బెంచ్‌మార్క్‌లే మోడల్స్‌ను చాట్‌బాట్‌ల నుండి వేరు చేస్తాయి.

ఈ గైడ్ మొదటి నుండి ఒక ఫోకస్డ్ రీజనింగ్ బెంచ్‌మార్క్‌ను ఎలా నిర్మించాలో వివరిస్తుంది. మీరు మూడు విభిన్న ఆర్కిటెక్చర్‌లను పోల్చి చూస్తారు: DeepSeek R1 671B MoE, Llama 3.3 70B, మరియు Qwen 3 32B. GPU క్లస్టర్‌లను సమకూర్చుకోవడం కంటే, మీరు ఈ మూడింటిని Oxlo.ai ద్వారా రన్ చేస్తారు. మూల్యాంకనం కోసం, మీరు రీజనింగ్ క్లారిటీ, కరెక్ట్‌నెస్ మరియు కోడ్ క్వాలిటీ ఆధారంగా అవుట్‌పుట్‌లను స్కోర్ చేయడానికి Kimi K2.6ని జడ్జిగా ఉపయోగిస్తారు.

రీజనింగ్ ఎందుకు ముందుగా విఫలమవుతుంది

ప్రొడక్షన్ ఫెయిల్యూర్స్ (failures) అరుదుగా వ్యాకరణ దోషాలు లేదా తిరస్కరణల రూపంలో ఉంటాయి. అవి సూక్ష్మమైన లాజికల్ తప్పుల రూపంలో ఉంటాయి. ఒక మోడల్ ఒక కన్‌స్ట్రైంట్‌ను (constraint) తప్పుగా అర్థం చేసుకుంటూ, ఒక స్టెప్‌ను స్కిప్ చేస్తూ లేదా మధ్యలో ఒక వేరియబుల్‌ను నిశ్శబ్దంగా మారుస్తూ, ఆత్మవిశ్వాసంతో కూడిన వచనాన్ని సృష్టించవచ్చు. పబ్లిక్ బెంచ్‌మార్క్‌లు తరచుగా లోతు కంటే విస్తృతికి (breadth) ఎక్కువ ప్రాధాన్యత ఇస్తాయి, కాబట్టి ఒక మోడల్ కష్టమైన కాంబినేటోరియల్ సమస్యను పరిష్కరించకుండానే మంచి స్కోరు సాధించవచ్చు.

ఒక టార్గెటెడ్ బెంచ్‌మార్క్ ఈ సమస్యను ఎదుర్కొనేలా చేస్తుంది. ఇది ప్రతి మోడల్‌కు ఒకే విధమైన కన్‌స్ట్రైన్డ్ ఆప్టిమైజేషన్ టాస్క్‌ను ఇస్తుంది, ట్రేసబుల్ చైన్ ఆఫ్ థాట్ (chain of thought) ను కోరుతుంది మరియు రూపొందించిన పరిష్కారం నిజంగా నియమాలను పాటిస్తుందో లేదో కొలుస్తుంది. ఒక మోడల్ డిస్క్రీట్ మ్యాథ్ (discrete math) ద్వారా స్థిరంగా రీజనింగ్ చేయలేకపోతే, అది మీ ఇన్వెంటరీ అలోకేషన్, షెడ్యూలింగ్ ఇంజిన్ లేదా రిసోర్స్ రూటర్లను కూడా నమ్మదగిన రీతిలో హ్యాండిల్ చేయలేదు.

మోడల్స్ మరియు ప్లాట్‌ఫారమ్

DeepSeek R1 671B MoE అనేది mixture-of-experts డిజైన్‌ను ఉపయోగిస్తుంది. ఏదైనా ఇచ్చిన టోకెన్ కోసం దాని 671 బిలియన్ పారామీటర్లలో ఒక చిన్న భాగం మాత్రమే యాక్టివేట్ అవుతుంది, ఇది కాస్ట్-టు-పెర్ఫార్మెన్స్ కర్వ్‌ను మరియు కొన్నిసార్లు దాని రీజనింగ్ స్వభావాన్ని మారుస్తుంది. Llama 3.3 70B అనేది ఒక డెన్స్ (dense) మోడల్, మరియు Qwen 3 32B చిన్న స్థాయిలో ఉంటూనే బలమైన మల్టీలింగ్వల్ మరియు కోడింగ్ సామర్థ్యాలను కలిగి ఉంటుంది. ఈ మూడింటిని పోల్చడం ద్వారా రీజనింగ్ క్వాలిటీ అనేది మొత్తం పారామీటర్ కౌంట్, యాక్టివ్ పారామీటర్ కౌంట్ లేదా ట్రైనింగ్ మెథడాలజీపై ఆధారపడి ఉందో లేదో మీకు తెలుస్తుంది.

Oxlo.ai ఈ మోడల్స్‌ను ఒక యూనిఫైడ్ API వెనుక హోస్ట్ చేస్తుంది. మీరు ఇన్ఫరెన్స్ ఇన్‌ఫ్రాస్ట్రక్చర్‌ను నిర్వహించాల్సిన అవసరం లేదు లేదా విడివిడి ప్రొవైడర్ ఒప్పందాలతో పోరాడాల్సిన అవసరం లేదు. ఈ ప్లాట్‌ఫారమ్ పర్-టోకెన్ ధరల కంటే పర్-రిక్వెస్ట్ ధరలను ఉపయోగిస్తుంది. రెండు వేల పదాల సిస్టమ్ ప్రాంప్ట్, ఒక చిన్న వన్-లైనర్‌తో సమానమైన ఖర్చును కలిగి ఉంటుంది. ఆ వివరం విన్నంతకంటే చాలా ముఖ్యమైనది. అంటే మీరు ఇన్‌పుట్ టోకెన్ ఖర్చులు పెరిగిపోవడాన్ని చూసి భయపడకుండా, సమగ్రమైన సూచనలను వ్రాయవచ్చు, వివరణాత్మక ఫార్మాటింగ్ అవసరాలను చేర్చవచ్చు మరియు few-shot ఉదాహరణలను కూడా పొందుపరచవచ్చు. మీరు కాల్‌కి మాత్రమే చెల్లిస్తారు, పదాల సంఖ్యకు కాదు.

మీకు Python 3.10 లేదా అంతకంటే కొత్త వెర్షన్, OpenAI Python లైబ్రరీ మరియు Oxlo.ai API కీ అవసరం.

స్టెప్ 1: ఎండ్‌పాయింట్‌కు కనెక్ట్ చేయండి

Oxlo.ai ఒక OpenAI-అనుకూలమైన APIని అందిస్తుంది కాబట్టి, ఇంటిగ్రేషన్ చాలా సులభం. OpenAI SDKని Oxlo బేస్ URLకి పాయింట్ చేయండి, మీ API కీని ఉపయోగించండి మరియు DeepSeek R1కి ఒక లైట్‌వెయిట్ రిక్వెస్ట్‌తో కనెక్షన్‌ను ధృవీకరించండి. శానిటీ చెక్ (sanity check)ను వదిలివేయకండి. లేటెన్సీని (latency) ధృవీకరించండి, మోడల్ ఐడెంటిఫైయర్ గుర్తించబడిందని నిర్ధారించుకోండి మరియు మీరు నిల్వ చేయాలనుకుంటున్న రెస్పాన్స్ ఫార్మాట్‌ను మీ ఎన్విరాన్మెంట్ స్ట్రీమ్ చేయగలదో లేదా బఫర్ చేయగలదో చూసుకోండి. హ్యాండ్‌షేక్ విజయవంతమైతే, మీరు కేవలం ఒక స్ట్రింగ్‌ను మార్చడం ద్వారా మూడు మోడల్స్‌ను కూడా యాక్సెస్ చేయగల ఒకే ఒక క్లయింట్‌ను కలిగి ఉంటారు.

స్టెప్ 2: టాస్క్‌ను డిజైన్ చేయండి

స్టెప్-బై-స్టెప్ లాజిక్ అవసరమయ్యే మరియు ఆబ్జెక్టివ్‌గా కొలవదగిన సమాధానం ఉన్న సమస్యను ఎంచుకోండి. Bin-packing అద్భుతంగా పనిచేస్తుంది. ఇది NP-hard, అంటే గ్రీడీ హ్యూరిస్టిక్స్ (greedy heuristics) ఊహించదగిన రీతిలో విఫలమవుతాయి మరియు ఇది మోడల్‌ను ఒకేసారి బహుళ కన్‌స్ట్రైంట్‌లను ట్రాక్ చేసేలా చేస్తుంది. వివిధ పరిమాణాల వస్తువులు పరిమితిని మించకుండా నిర్ణీత సామర్థ్యం ఉన్న బిన్‌లలో సరిపోవాలి.

మోడల్ రెండు పనులు చేయాల్సి వచ్చేలా ప్రాంప్ట్‌ను రూపొందించండి: దాని రీజనింగ్ ప్రక్రియను వివరించడం, ఆపై ఆ సమస్యను పరిష్కరించే వర్కింగ్ Python కోడ్‌ను అందించడం. మోడల్ ఏ కోడ్‌ను వ్రాయకముందే దాని chain-of-thought ను చూపాలని స్పష్టంగా కోరే సిస్టమ్ ప్రాంప్ట్‌ను ఉపయోగించండి. ఇది ముఖ్యంగా DeepSeek R1 కోసం చాలా ముఖ్యం, ఎందుకంటే ఇది విస్తరించిన రీజనింగ్ ట్రేస్‌ల కోసం ఆప్టిమైజ్ చేయబడింది. మోడల్ సామర్థ్య తనిఖీల (capacity checks) ద్వారా ఆలోచిస్తుందో లేదా కేవలం ట్రైనింగ్ డేటా ఆధారంగా ప్యాటర్న్-మ్యాచ్ చేస్తోందో మీరు చూడాలనుకుంటారు. ఒక మంచి టాస్క్ టెంప్లేట్ రెస్పాన్స్‌లు విఫలమయ్యేంత కఠినంగా (adversarial) ఉండాలి.

స్టెప్ 3: బెంచ్‌మార్క్‌ను రన్ చేయండి

DeepSeek R1, Llama 3.3 70B, మరియు Qwen 3 32B లకు ఒకే విధమైన ప్రాంప్ట్‌ను అందించండి. కేవలం చివరి కోడ్ బ్లాక్‌లను మాత్రమే కాకుండా, పూర్తి టెక్స్ట్ స్పందనలను క్యాప్చర్ చేయండి. వాటిని టైమ్‌స్టాంప్‌లు మరియు మోడల్ ఐడెంటిఫైయర్‌లతో భద్రపరచండి. Oxlo.ai ప్రతి రిక్వెస్ట్‌కు ఛార్జ్ చేస్తుంది కాబట్టి, డబ్బు ఆదా చేయడానికి మీ ప్రాంప్ట్‌ను తగ్గించాల్సిన లేదా వివరణాత్మక సూచనలను తొలగించాల్సిన అవసరం లేదు. మీరు ఖచ్చితంగా ఉండవచ్చు. ఆ స్థిరత్వం వల్ల ఖర్చు గురించి ఆందోళన చెందకుండా ప్రాంప్ట్ డిజైన్‌పై మీరు పదేపదే ప్రయత్నించవచ్చు, ఇది మరింత స్పష్టమైన ప్రయోగాలు మరియు పునరుత్పత్తి చేయగల ఫలితాలకు దారితీస్తుంది.

మీ బడ్జెట్ అనుమతిస్తే ప్రతి మోడల్‌ను బహుళ సార్లు రన్ చేయండి. రీజనింగ్ మోడల్స్ యాదృచ్ఛిక ఉత్పత్తిలో (stochastic generations) మారవచ్చు, మరియు ఒక అధిక స్కోరు స్థిరమైన సామర్థ్యాన్ని సూచిస్తుందా లేదా కేవలం ఒక అదృష్టవంతమైన శాంపిల్‌నా అనేది మీరు తెలుసుకోవాలి.

Step 4: LLM జడ్జితో గ్రేడింగ్ చేయండి

మాన్యువల్ స్కోరింగ్ పెద్ద ఎత్తున సాధ్యం కాదు, కానీ కేవలం సంఖ్యాపరమైన రూబ్రిక్స్ మాత్రమే సూక్ష్మతను (nuance) గుర్తించలేవు. దీనికి మధ్యే మార్గం LLM జడ్జి. ఇక్కడ, మీరు Kimi K2.6ని ఉపయోగిస్తారు. అసలు సమస్యను, రూబ్రిక్‌ను మరియు ప్రతి అభ్యర్థి స్పందనను దానికి అందించండి. మూడు నిర్దిష్ట అంశాలను అంచనా వేయమని దానిని కోరండి:

  • Reasoning clarity (తార్కిక స్పష్టత): వివరణ నిజంగా లాజిక్‌ను అనుసరిస్తుందా లేదా పైపైన చెబుతుందా?
  • Correctness (ఖచ్చితత్వం): ప్రతిపాదించిన పరిష్కారం పేర్కొన్న అన్ని నిబంధనలను సంతృప్తి పరుస్తుందా?
  • Code quality (కోడ్ నాణ్యత): Python కోడ్ క్లీన్‌గా, రన్ చేయదగినదిగా మరియు స్పష్టమైన బగ్‌లు లేకుండా ఉందా?

ఫలితాలను JSON ఫార్మాట్‌లో తిరిగి ఇవ్వమని జడ్జికి సూచించండి. స్ట్రక్చర్డ్ అవుట్‌పుట్ వల్ల ఫలితాలను పోల్చడం (diff), ట్రెండ్‌లను ప్లాట్ చేయడం మరియు తదుపరి ఆటోమేషన్‌కు ఉపయోగించడం చాలా సులభం అవుతుంది. జడ్జి ప్రాంప్ట్‌ను కఠినంగా ఉంచండి. మీరు "సమాధానాన్ని రేట్ చేయండి" వంటి అస్పష్టమైన సూచన ఇస్తే, మీకు అస్పష్టమైన ఫలితాలే వస్తాయి. బదులుగా, ఒక సరైన bin-packing పరిష్కారం అంటే ఏమిటో నిర్వచించండి. సామర్థ్యాలు (Capacities) మించకూడదు. ప్రతి ఐటెమ్‌ను కేటాయించాలి. కోడ్ సింటాక్టికల్‌గా చెల్లుబాటు కావాలి. మీ ప్రమాణాలు ఎంత స్పష్టంగా ఉంటే, మీ గ్రేడ్‌లు అంత నమ్మదగినవిగా మారుతాయి.

జడ్జిని ఎల్లప్పుడూ స్పాట్-చెక్ చేయండి. Kimi K2.6 కేవలం పైపైన మెరుగుదల (surface-level polish) చూసి ఒక మోడల్‌కు నిరంతరం ఎక్కువ రేటింగ్ ఇస్తుంటే, మీ బెంచ్‌మార్క్ తప్పుగా ఉన్నట్లే. ఒక చిన్న హ్యూమన్ ఆడిట్ లేయర్ "garbage-in-garbage-out" మూల్యాంకనాన్ని నివారిస్తుంది.

Step 5: రిపోర్ట్‌ను రూపొందించండి

JSON స్కోర్‌లను సేకరించి, వాటిని మోడల్ అవుట్‌పుట్‌ల నుండి తీసుకున్న ఉదాహరణలతో జత చేయండి. మీ రిపోజిటరీలో ఉండే ఒకే ఫైల్‌లోకి వాటన్నింటినీ చేర్చండి. మీరు మోడల్ వెర్షన్‌ను అప్‌డేట్ చేసినప్పుడు లేదా ప్రాంప్ట్‌ను మార్చినప్పుడు, మీ pull request లోని diff ప్రవర్తన ఎలా మారిందో ఖచ్చితంగా చూపుతుంది. చక్కగా నిర్వహించబడే బెంచ్‌మార్క్ ఒక సజీవమైన డాక్యుమెంటేషన్‌గా మారుతుంది. మీ ప్రొడక్షన్ పైప్‌లైన్ ఒక మోడల్‌ను మరొక దాని కంటే ఎందుకు ఉపయోగిస్తుందో ఇది సమర్థిస్తుంది మరియు యూజర్లకు చేరకముందే సైలెంట్ రిగ్రెషన్స్‌ను గుర్తిస్తుంది.

మీ టీమ్ మెంబర్ కోడ్‌ను రన్ చేయకుండానే చదవగలిగేలా రిపోర్ట్‌ను రూపొందించండి. అందులో ప్రాబ్లమ్ స్టేట్‌మెంట్, ప్రాంప్ట్ టెంప్లేట్, స్కోర్‌లు మరియు ప్రతి మోడల్ యొక్క రీజనింగ్ ట్రేస్ నుండి ముఖ్యమైన ఉల్లేఖనాలను చేర్చండి. పారదర్శకత ముఖ్యం. DeepSeek R1 అధిక స్కోరు సాధించినప్పటికీ ఏదైనా నిబంధనను (constraint) మర్చిపోతే (hallucinate), అది సగటులో కలిసిపోకుండా టెక్స్ట్ ఉదాహరణలో స్పష్టంగా కనిపించాలి.

పైప్‌లైన్‌ను ఆటోమేట్ చేయడం

మీ లాప్‌టాప్‌లో మాత్రమే ఉండే బెంచ్‌మార్క్ ఒక వారం రోజుల్లో మర్చిపోబడతాయి. దానిని నైట్లీ CI జాబ్‌లోకి మార్చండి. ప్రతి రాత్రి, హార్నెస్ రన్ అవుతుంది, Oxlo.ai లోని ప్రస్తుత మోడల్ వెర్షన్‌లను క్వరీ చేస్తుంది, bin-packing టాస్క్‌ను రన్ చేస్తుంది, అవుట్‌పుట్‌లను గ్రేడ్ చేస్తుంది మరియు ఫలితాలను commit చేస్తుంది. ఒక మోడల్ అప్‌డేట్ వల్ల ఖచ్చితత్వంలో పది పాయింట్ల తగ్గుదల జరిగితే, మీ యూజర్లు తెలుసుకునే ముందే మీకు తెలిసిపోతుంది.

కోర్ హార్నెస్ స్థిరంగా ఉన్న తర్వాత, దానిని విస్తరించండి. ప్రాంప్ట్‌తో అనవసరమైన డాక్యుమెంట్లను నింపి, చివరలో bin-packing ప్రశ్నను ఉంచి, లాంగ్-కాంటెక్స్ట్ వేరియంట్‌లను పరీక్షించండి. రీజనింగ్ అనేది నాయిస్ (noise) వల్ల దెబ్బతింటే, పెద్ద కాంటెక్స్ట్ విండోలు ఉపయోగం లేనివి. సిగ్నల్ అనేది పది వేల టోకెన్ల గందరగోళంలో ఉన్నప్పుడు ఏ మోడల్స్ తార్కిక క్రమశిక్షణను (logical discipline) కాపాడుకుంటాయో చూడండి.

అసలైన సారాంశం

పబ్లిక్ లీడర్‌బోర్డ్‌లు సాధారణ జ్ఞానాన్ని కొలుస్తాయి. మీ అప్లికేషన్ అంతకంటే ఇరుకైన మరియు కష్టమైన అంశాన్ని కొలుస్తుంది. మోడల్స్‌ను కన్‌స్ట్రెయిన్డ్ ఆప్టిమైజేషన్ ద్వారా ఆలోచించేలా చేసే, స్థిరమైన ప్రమాణాలతో గ్రేడ్ చేసే మరియు ఫలితాలను git లో వెర్షన్ చేసే ఒక సరళమైన, పునరావృతమయ్యే హార్నెస్, ఏ అగ్రిగేట్ స్కోర్ కంటే ఎక్కువ ఉపయోగకరమైన అంతర్దృష్టులను (actionable insights) మీకు అందిస్తుంది. మీ సమస్యకు సరిపోయే బెంచ్‌మార్క్‌ను నిర్మించండి, మీకు ముఖ్యమైన ఆర్కిటెక్చర్‌లపై దానిని రన్ చేయండి మరియు ఫలితాల ఆధారంగా మీ ప్రొడక్షన్ ఎంపికను నిర్ణయించుకోండి.

Source: DeepSeek R1 Model Architecture and Benchmarks

Community: GyaanSetu AI on Telegram