మీ AI భ్రమలకు లోనవ్వడం లేదు. అది కేవలం ఊహిస్తోంది.
AI మోడల్స్కు అవి ఎప్పుడు తప్పు చేస్తున్నాయో తెలియదు. అనిశ్చితిని (uncertainty) గుర్తించడానికి వాటి వద్ద ఎటువంటి సంకేతం ఉండదు. మీ ఇన్పుట్ ఆధారంగా అత్యంత సంభావ్యత కలిగిన తదుపరి పదాన్ని అవి ఉత్పత్తి చేస్తాయి. అవి సరైనప్పుడు ఎంత నమ్మకంతో ఉంటాయో, తప్పు చేసినప్పుడు కూడా అంతే నమ్మకంతో ఉంటాయి.
ఇది వ్యవస్థలోని లోపం కాదు. ఆర్కిటెక్చర్ పనిచేసే విధానం ఇదే.
LLMలు అనేవి నెక్స్ట్-టోకెన్ ప్రిడిక్టర్లు (next-token predictors). అవి వాస్తవాల డేటాబేస్ను తనిఖీ చేయవు. అవి భారీ స్థాయిలో ప్యాటర్న్ కంప్లీషన్ (pattern completion) చేస్తాయి. ఒకవేళ మోడల్ తప్పు సమాధానం ఇస్తే, దానికి కారణం మీ ప్రాంప్ట్ ఆ ఫలితం వైపు సంభావ్యతను (probability) నడిపించడమే.
ఈ వ్యత్యాసం మీరు సమస్యలను పరిష్కరించే విధానాన్ని మారుస్తుంది. మోడల్ భ్రమలకు (hallucinating) లోనవుతుంటే, మీరు దానిని సరిదిద్దలేరు. మీ ప్రాంప్ట్ అస్పష్టంగా ఉన్నందున మోడల్ ఊహిస్తుంటే (guessing), మీరు దానిని ఇప్పుడే సరిదిద్దవచ్చు.
Datawiseలో, మేము AI మోడల్స్ను బెంచ్మార్క్ చేస్తాము. మేము ఒక నిరంతర నమూనాను గమనిస్తున్నాము. ఇన్పుట్లలో వివరాలు లేనప్పుడు మోడల్స్ తప్పు సమాధానాలు ఇస్తాయి. మీరు అడగాలనుకున్న ప్రశ్నను కాకుండా, మీరు నిజంగా అడిగిన ప్రశ్నకే మోడల్ సమాధానం ఇస్తుంది.
ఈ రెండు ప్రాంప్ట్లను పోల్చి చూడండి:
- "How do I connect to Postgres in Python?"
- "How do I connect to Postgres in Python using psycopg3, a connection pool of 10, on Ubuntu 24.04, behind a Cloudflare Tunnel, with a 30-second timeout?"
మొదటి ప్రాంప్ట్ మోడల్ను ఆరు సార్లు ఊహించేలా చేస్తుంది. రెండవ ప్రాంప్ట్ పరిమితులను (constraints) అందిస్తుంది.
ఒక నిర్దిష్టమైన ప్రాంప్ట్ను రాయడంలో ఉండే కష్టం, మీ అవసరాలను మీరు తెలుసుకోవడంలో ఉండే కష్టంతో సమానం. మీరు ఒక నిర్దిష్టమైన ప్రాంప్ట్ను రాయలేకపోతుంటే, మీకు ఇంకా ఏమి కావాలో మీకు తెలియదని అర్థం. ప్రాంప్టింగ్ చేయడం ఆపి, ఆలోచించడం ప్రారంభించండి.
AI తప్పు అవుట్పుట్లను కూడా సరైన వాటిలాగే అంతే స్పష్టతతో ఉత్పత్తి చేస్తుంది. ఆ వచనం అధికారికంగా అనిపిస్తుంది. కోడ్ చూడటానికి శుభ్రంగా ఉంటుంది. మోడల్ ఏదైనా ఖాళీని పూరిస్తుందనే సంకేతం ఏదీ ఉండదు.
సీనియర్ ఇంజనీర్లు కేవలం అవుట్పుట్ను నమ్మరు. వారు ఇలా అడుగుతారు: "నేను ఎక్కడ వివరణలకు (interpretation) అవకాశం వదిలేశాను?" ప్రతి అస్పష్టమైన పదం అనేది మోడల్ మీ కోసం తీసుకున్న ఒక నిర్ణయం.
కేవలం కొంచెం భిన్నమైన పదజాలంతో ప్రాంప్ట్ను మళ్ళీ సబ్మిట్ చేయకండి. అది లాగ్లను (logs) తనిఖీ చేయకుండా ఒక సర్వీస్ను రీస్టార్ట్ చేసినట్లు అవుతుంది. మీరు మూల కారణాన్ని (root cause) పరిష్కరించడం లేదు.
అవుట్పుట్ తప్పుగా ఉన్నప్పుడు, మొదట మీ ప్రాంప్ట్ను చదవండి. మీరు ఎక్కడ వివరణలకు అవకాశం వదిలేశారో కనుగొనండి. ఈ క్రింది వాటి కోసం పరిమితులను (constraints) జోడించండి:
- ఇన్పుట్లు మరియు అవుట్పుట్లు (Inputs and outputs)
- ఎర్రర్ హ్యాండ్లింగ్ (Error handling)
- డిపెండెన్సీలు (Dependencies)
- ఎడ్జ్ కేసులు (Edge cases)
మీరు ఎంటర్ నొక్కే ముందు, మీకు ఎటువంటి సందర్భం (context) తెలియని ఒక కొత్త ఇంజనీర్లా మీ ప్రాంప్ట్ను చదవండి. మీరు దేనినైనా ఊహించాల్సి వస్తే, మోడల్ కూడా అక్కడే ఊహించాల్సి వస్తుంది.
మీ సూచనలలోని లోపాలను ఈ మోడల్ మీకు చూపిస్తుంది. ఆ లోపాలను సరిచేయండి. మరింత కచ్చితమైన ప్రాంప్ట్లను రాయండి.
ఐచ్ఛిక అభ్యాస సమూహం: https://t.me/GyaanSetuAi