మీరు ప్రాంప్ట్లో వందల పేజీల డాక్యుమెంటేషన్ను పేస్ట్ చేసి ఒక సాధారణ ప్రశ్న అడుగుతారు. కానీ వచ్చే సమాధానం తప్పుగా ఉంటుంది. లేదా మీరు పైన ఇచ్చిన ఫార్మాటింగ్ రూల్ను అది పట్టించుకోదు. మీరు దానికి అన్ని వివరాలు ఇచ్చారు. అది ఖచ్చితంగా పనిచేయాలి. కానీ పనిచేయలేదు.
ఇదే 'కాంటెక్స్ట్ ట్రాప్' (context trap). AIకి ఎక్కువ సమాచారాన్ని అందిస్తే ఆటోమేటిక్గా మెరుగైన ఫలితాలు వస్తాయని చాలా మంది డెవలపర్లు అనుకుంటారు. కానీ వాస్తవానికి దీనికి విరుద్ధంగా జరుగుతుంది. నమ్మదగిన AI అప్లికేషన్లను రూపొందించడానికి మూడు ప్రధాన అంశాలను అర్థం చేసుకోవడం అవసరం: మోడల్స్ టెక్స్ట్ను ఎలా లెక్కిస్తాయి, అవి ఒకేసారి ఎంత సమాచారాన్ని నిల్వ చేయగలవు, మరియు సంభాషణ ముగిసిన తర్వాత సమాచారానికి ఏమవుతుంది.
టోకెన్లు (Tokens): అసలైన కరెన్సీ
లాంగ్వేజ్ మోడల్ ప్రాసెస్ చేసే అతి చిన్న యూనిట్ను 'టోకెన్' అంటారు. ఇది ఒకే ఒక అక్షరం కావచ్చు, ఒక పదం యొక్క భాగం కావచ్చు, లేదా ఒక పూర్తి పదం కావచ్చు. "purchase" అనే పదాన్ని తరచుగా రెండు టోకెన్లుగా విభజిస్తారు, కానీ "cat" వంటి చిన్న పదం అలాగే ఉంటుంది. విరామ చిహ్నాలు (punctuation) మరియు ఖాళీలు (spaces) కూడా టోకెన్లను వినియోగిస్తాయి. కోడ్ విషయంలో ఇది ఇంకా ఎక్కువగా ఉంటుంది. నెస్టెడ్ ఇండెంటేషన్ (nested indentation) మరియు ప్రత్యేక చిహ్నాలతో కూడిన పైథాన్ (Python) కోడ్ బ్లాక్, మీరు ఊహించిన దానికంటే మూడు లేదా నాలుగు రెట్లు ఎక్కువ టోకెన్లను తీసుకోవచ్చు.
డెవలపర్లు దీని గురించి ఎందుకు శ్రద్ధ వహించాలి? API ధర టోకెన్ల ఆధారంగానే ఉంటుంది. ప్రాసెసింగ్ సమయం కూడా అలాగే ఉంటుంది. రెండు పేజీల టెక్స్ట్ లాగా కనిపించే ప్రాంప్ట్, అందులో ఉన్న సమాచారాన్ని బట్టి కొన్ని పైసల నుండి కొన్ని డాలర్ల వరకు ఖర్చు చేయవచ్చు. అంతకంటే దారుణమైన విషయం ఏమిటంటే, టోకెన్లు ఇరువైపులా పెరుగుతాయి. మీ ప్రాంప్ట్లోని ప్రతి టోకెన్కు మీరు చెల్లించాలి, అలాగే మోడల్ ఇచ్చే ప్రతి టోకెన్కు కూడా మీరు చెల్లించాలి. నియంత్రణ లేని కాంటెక్స్ట్ పెరుగుదల మీ లాభాలను (margins) నిశ్శబ్దంగా తగ్గిస్తుంది.
కాంటెక్స్ట్ విండో (Context Window) అనేది ఒక వైట్బోర్డ్ వంటిది
ఒక మోడల్ ఒకేసారి ఎంత సమాచారాన్ని చూడగలదో కాంటెక్స్ట్ విండో నిర్ణయిస్తుంది. ఒక చిన్న గదిలో వేలాడుతున్న వైట్బోర్డ్ను ఊహించుకోండి. మీరు దానిని సిస్టమ్ ఇన్స్ట్రక్షన్స్, యూజర్ ప్రశ్నలు, రిట్రీవ్ చేసిన డాక్యుమెంట్లు మరియు మునుపటి సంభాషణలతో నింపవచ్చు. కానీ ఆ బోర్డు పరిమాణం పెరగదు. కొత్త టెక్స్ట్ వచ్చినప్పుడు, పాత టెక్స్ట్ బోర్డు అంచు నుండి పడిపోతుంది.
ఇది ఎందుకు ముఖ్యమంటే, మోడల్ సమాచారాన్ని వదిలేయడం (dropping content) ప్రారంభించినప్పుడు అది మీకు హెచ్చరిక ఇవ్వదు. మీ సిస్టమ్ ఇన్స్ట్రక్షన్ ఒక సుదీర్ఘమైన సంభాషణలో పైన ఉండి, మీరు నిరంతరం మెసేజ్లను జోడిస్తూ పోతే, ఆ ఇన్స్ట్రక్షన్ క్రమంగా పరిధి దాటి వెళ్ళిపోతుంది. అప్పుడు మోడల్ తన డిఫాల్ట్ ప్రవర్తనకు మారవచ్చు, మీ ఫార్మాటింగ్ రూల్స్ను విస్మరించవచ్చు లేదా మునుపటి సూచనలకు విరుద్ధంగా వ్యవహరించవచ్చు. వేర్వేరు మోడల్స్ వేర్వేరు పరిమితులను కలిగి ఉంటాయి; కొన్ని వేల టోకెన్లను, మరికొన్ని లక్షల టోకెన్లను హ్యాండిల్ చేయగలవు, కానీ వాటి పనితీరు మాత్రం ఒకేలా ఉంటుంది. ఇన్పుట్ మరియు అవుట్పుట్ రెండూ ఒకే బడ్జెట్ను పంచుకుంటాయి. ఒక మోడల్ రెండు వేల టోకెన్ల సమాధానాన్ని ఇస్తుంటే, మీరు చెప్పిన విషయాలను గుర్తుంచుకోవడానికి దాని వద్ద రెండు వేల టోకెన్లు తక్కువగా అందుబాటులో ఉంటాయి.
మెమరీ అనేది ఒక హ్యాక్ (Hack), ఫీచర్ కాదు
ఇన్ఫరెన్స్ (inference) సమయంలో మోడల్ వెయిట్స్ (model weights) లో ఎటువంటి శాశ్వత మెమరీ ఉండదు. అస్సలు ఉండదు. మీరు ట్యాబ్ను మూసివేసి రేపు తిరిగి వచ్చినప్పుడు, మోడల్ మిమ్మల్ని గుర్తుపట్టదు. ప్రతి API కాల్ ఒక 'కోల్డ్ స్టార్ట్' (cold start) వంటిది.
మెమరీలా అనిపించేది కేవలం అప్లికేషన్ లేయర్ చేసే తెలివైన బుక్ కీపింగ్ మాత్రమే. ఫ్రంటెండ్ మీ మెసేజ్లను ఒక డేటాబేస్లో నిల్వ చేస్తుంది. మీరు కొత్త క్వెరీని పంపినప్పుడు, సాఫ్ట్వేర్ సంబంధిత హిస్టరీని తీసుకుని, దానిని ఒక కొత్త ప్రాంప్ట్గా కలిపి, మొత్తం ప్యాకేజీని మోడల్కు పంపిస్తుంది. మోడల్కు దీని గురించి ఏమీ తెలియదు.
ప్రొడక్ట్ టీమ్స్కు ఈ తేడా తెలియడం చాలా ముఖ్యం. యూజర్ ప్రాధాన్యతలను (user preferences) "గుర్తుంచుకోవడానికి" మీరు మోడల్పై ఆధారపడితే, మీరు బలహీనమైన పునాదిపై అప్లికేషన్ను నిర్మిస్తున్నట్లే. మీరు స్వయంగా స్టేట్ మేనేజ్మెంట్ (state management) నిర్మించుకోవాలి. దేనిని క్యాష్ (cache) చేయాలో నిర్ణయించుకోవాలి. దానిని ఎలా రిఫ్రెష్ చేయాలో నిర్ణయించుకోవాలి. అలాగే, మీరు తిరిగి పంపే ప్రతి హిస్టరీ బైట్ మీ వైట్బోర్డ్ స్థలాన్ని తగ్గిస్తుందని గుర్తించాలి.
కాంటెక్స్ట్ ఎప్పుడు నాయిస్గా (Noise) మారుతుంది
ప్రాంప్ట్ను సమాచారంతో నింపేయడం (Flooding) ఊహించిన విధంగానే ప్రతికూల ఫలితాలను ఇస్తుంది.
నాయిస్ సిగ్నల్ను దెబ్బతీస్తుంది (Noise kills signal). మీరు ఒక చిన్న బగ్ గురించి అడగడానికి మొత్తం కోడ్బేస్ను ఇస్తే, మోడల్ 'నీడిల్-ఇన్-ఏ-హేస్టాక్' (needle-in-a-haystack) సమస్యను ఎదుర్కొంటుంది. అది తప్పు ఫైల్ను సూచించవచ్చు, పనికిరాని కోడ్లో (dead code) మార్పులను సూచించవచ్చు, లేదా సరైన సమాధానం ఇవ్వలేక సాధారణ సమాధానాన్ని (generic answer) ఇవ్వవచ్చు ఎందుకంటే అది చేయలేక...