લક્ષ્ય પ્રેક્ષકો: AI પ્રોગ્રામિંગ ટૂલ્સ (જેમ કે કર્સર, વિન્ડસર્ફ, ટ્રે...) નો ઉપયોગ કરતા વિકાસકર્તાઓ અને AI ખર્ચ વિશે જાગૃતિનો અભાવ ધરાવતા ટેકનિકલ મેનેજરો.

મુખ્ય દૃષ્ટિકોણ: ટોકન માત્ર એક સરળ બિલિંગ એકમ નથી, પરંતુ એક "ધ્યાન સંસાધન" અને "ગણતરી ચલણ" છે. એજન્ટ મોડનો દુરુપયોગ કરવો અને સંદર્ભ વ્યવસ્થાપનને અવગણવું એ વાસ્તવમાં વ્યૂહાત્મક આળસ (પોતે વિચાર્યા વિના) ને છુપાવવા માટે યુક્તિપૂર્ણ ખંત (AI ને આડેધડ રીતે ફેંકવું) નો ઉપયોગ કરી રહ્યા છે.

તમારો "AI ખર્ચ" તમારા પગાર કરતાં પણ વધારે હોઈ શકે છે

થોડા દિવસો પહેલા, મેં મારું ટોકન બિલ તપાસ્યું. જ્યારે મેં તે નંબર જોયો, ત્યારે હું થોડો આશ્ચર્યચકિત થઈ ગયો: 10 મિલિયન ટોકન્સ. નોંધ કરો કે આ એક મહિનાનો વપરાશ નથી, આ એક દિવસનો છે.

મને લાગ્યું કે આ ખૂબ જ વિચિત્ર છે. બાદમાં, મેં ટોકન ગણતરી સંબંધિત એક ટૂંકી વિડિઓ પોસ્ટ કરી.

પરિણામે, ટિપ્પણી વિભાગે મને બતાવ્યું કે "આકાશની ઉપર પણ આકાશ હોય છે."

નીચેનું ચિત્ર નેટીઝન "ઓલ્ડ કે ડેઇલી" દ્વારા એક દિવસમાં બે કરોડ ટોકન વપરાશના રેકોર્ડનો સ્ક્રીનશોટ છે:

શરૂઆતમાં, મને લાગ્યું કે તે એક અલગ કેસ હોઈ શકે છે, પરંતુ જ્યારે ઘણા નેટીઝન્સે ટિપ્પણી કરી કે તેઓ દરરોજ 100 મિલિયનનો વપરાશ કરે છે, ત્યારે મને સમજાયું કે આ એક ખૂબ જ સામાન્ય ઘટના છે.

એકસો મિલિયન ટોકન્સ શું છે? જો આપણે "કેટલાક મુખ્ય પ્રવાહના વ્યાપારી મોડેલો" ના સામાન્ય બિલિંગ સ્કેલ (ઇનપુટ/આઉટપુટ અલગથી બિલ કરવામાં આવે છે, અને એકસાથે આશરે $10 પ્રતિ મિલિયન ટોકન્સ ના સ્કેલ પર અંદાજવામાં આવે છે) અનુસાર ગણતરી કરીએ, તો આ એક દિવસમાં $1000 બળી જાય છે. એક દિવસમાં 7000 યુઆન બળી જાય છે. ઘણા જુનિયર પ્રોગ્રામરોનો એક મહિનાનો પગાર પણ AI ને આ એક દિવસ માટે "વિચારવા" માટે પૂરતો નથી.

(નોંધ: વિવિધ મોડેલો/વિક્રેતાઓ વચ્ચે કિંમતમાં મોટો તફાવત છે, અને ઇનપુટ અને આઉટપુટની એકમ કિંમત પણ ઘણીવાર અલગ હોય છે. અહીંનો હેતુ દશાંશ સ્થળ પછી બે અંકો સુધી ચોક્કસ ગણતરી કરવાનો નથી, પરંતુ પ્રથમ "પરિમાણની ભાવના" સ્થાપિત કરવાનો છે.)

જો તમે જાતે ફરીથી ગણતરી કરવા માંગતા હો, તો અહીં એક સામાન્ય સૂત્ર છે (કેશ/ડિસ્કાઉન્ટ જેવા વિશેષ નિયમોને અવગણીને): ખર્ચ ≈ (ઇનપુટ ટોકન્સ / 1,000,000) × કિંમત_ઇન + (આઉટપુટ ટોકન્સ / 1,000,000) × કિંમત_આઉટ

આ બાબત ખૂબ જ અસ્વાભાવિક છે. આપણે હંમેશાં વિચારીએ છીએ કે AI સસ્તું છે, અને OpenAI કિંમતો પણ ઘટાડી રહી છે. પરંતુ વાસ્તવિક એન્જિનિયરિંગમાં, ટોકનનો વપરાશ ઘાતાંકીય રીતે કેમ વધી રહ્યો છે?

આજે, ચાલો આપણે આ "ટોકન બ્લેક હોલ" પાછળના તર્કને ઊંડાણપૂર્વક સમજીએ અને આપણે નુકસાનને કેવી રીતે અટકાવી શકીએ.

1. ટોકન્સ "ઘાતાંકીય રીતે" કેમ વધે છે?

ઘણા ભાઈઓને ટોકન્સના કદનો ખ્યાલ નથી. તેઓ વિચારે છે: "અરે, તે માત્ર થોડા કોડના ટુકડા મોકલવા જેટલું જ છે, તેમાં કેટલું હોઈ શકે?"

1. એક સ્પષ્ટ ગણતરી કરો

ચાલો આપણે પહેલા એન્જિનિયરિંગ માટે પૂરતી માત્રાત્મક સમજણ સ્થાપિત કરીએ. ચાલો આપણે તેને થોડું સ્પષ્ટ કરીએ: ટોકન એ શબ્દોની સંખ્યા નથી, કે અક્ષરોની સંખ્યા પણ નથી. તે મોડેલ દ્વારા ટેક્સ્ટને વિભાજિત કર્યા પછી "એન્કોડિંગ ટુકડો" છે. વિવિધ મોડેલો વિવિધ ટોકનાઇઝરનો ઉપયોગ કરે છે, તેથી આપણે ફક્ત રેન્જ આપી શકીએ છીએ, "સાર્વત્રિક રીતે લાગુ" સ્થિર સંખ્યા આપી શકતા નથી.

નીચેના નંબરોને ફક્ત "અંદાજિત સ્કેલ" તરીકે ગણો (હેતુ પરિમાણનો નિર્ણય કરવો, ખર્ચનો અંદાજ કાઢવો અને નુકસાનને રોકવાનો નિર્ણય લેવાનો છે):

• 1 ચાઇનીઝ અક્ષર: સામાન્ય રીતે 1-2 ટોકન્સ (ઉચ્ચ આવર્તનવાળા અક્ષરો 1 ની નજીક હોય છે, અને દુર્લભ અક્ષરો/સંયોજનો 2-3 સુધી પહોંચી શકે છે)

• 1 અંગ્રેજી શબ્દ: સામાન્ય રીતે આશરે 1.2-1.5 ટોકન્સ (આશરે અંદાજ માટે 1.3 નો ઉપયોગ કરવો પણ શક્ય છે)

• કોડની 1 લાઇન ≈ 10-50 ટોકન્સ (ઇન્ડેન્ટેશન, ટિપ્પણીઓ અને પ્રકાર ઘોષણાઓ સહિત)

• સંક્ષિપ્ત વ્યવસાય તર્ક ≈ 12-20 ટોકન્સ

• પ્રકાર એનોટેશન, ઇન્ટરફેસ, JSDoc, 4-સ્પેસ ઇન્ડેન્ટેશન સાથે ≈ 20-35 ટોકન્સ

• મોટી સંખ્યામાં આયાત / ડેકોરેટર / ટિપ્પણીઓ સાથે ≈ 30-50+ ટોકન્સ

• 1 સ્રોત ફાઇલ (400-600 લીટીઓ, આધુનિક TS/Java પ્રોજેક્ટ) ≈ 4,000-24,000 ટોકન્સ ખૂબ સામાન્ય છે (મધ્યક ≈ 12,000-18,000)

• 1 મધ્યમ કદનો પ્રોજેક્ટ (100-200 સ્રોત ફાઇલો, ફક્ત src/ ની ગણતરી કરો, node_modules/ / જનરેટેડ કોડ સિવાય)

• મુખ્ય સ્રોત કોડને "વાંચવા" માટે ઘણીવાર લાખો ટોકન્સ થી શરૂ થાય છે

• જો તમે પરીક્ષણો, રૂપરેખાંકનો, સ્ક્રિપ્ટો, અવલંબન ઘોષણાઓ અને લોગ્સને એકસાથે મૂકો છો, તો દસ મિલિયન ટોકન્સ પણ આશ્ચર્યજનક નથી

આજના ફ્રન્ટ-એન્ડ પ્રોજેક્ટ્સ TypeScript છે, જે જટિલ ઇન્ટરફેસ વ્યાખ્યાઓથી ભરેલા છે; અથવા Java, જે સરળતાથી ડઝનેક લીટીઓની આયાત ધરાવે છે. આ "બોઈલરપ્લેટ કોડ" વાસ્તવમાં ટોકન હત્યારા છે. મધ્યમ કદના પ્રોજેક્ટમાં, જો 100 ફાઇલો હોય, તો AI ને "કોડ વાંચવા" દેવાથી સીધા 1 મિલિયન ટોકન્સ નો નાશ થઈ શકે છે.

2. ટોકન્સની "સ્નોબોલ" અસર

ટોકન વપરાશનો સૌથી ભયાનક ભાગ એ એક જ વાતચીત નથી, પરંતુ બહુવિધ રાઉન્ડની વાતચીતમાં સંદર્ભ સંચય છે.

LLM ની પદ્ધતિ સ્ટેટલેસ છે. AI ને યાદ રાખવા માટે કે તમે અગાઉ શું કહ્યું હતું, સિસ્ટમ સામાન્ય રીતે "સિસ્ટમ પ્રોમ્પ્ટ + ભૂતકાળની વાતચીતો + તમે ટાંકેલી ફાઇલો/કોડ સ્નિપેટ્સ + ટૂલ કૉલ આઉટપુટ (જેમ કે શોધ પરિણામો, ભૂલ લોગ્સ)" ને એકસાથે પેક કરીને મોડેલને મોકલે છે. તમને લાગે છે કે તમે માત્ર એક જ પ્રશ્ન પૂછ્યો છે, પરંતુ વાસ્તવમાં તમે વારંવાર "સમગ્ર સંદર્ભ પેકેજ" માટે ચૂકવણી કરી રહ્યા છો.

• રાઉન્ડ 1: 10,000 ટોકન્સ મોકલો, AI 1,000 નો જવાબ આપે છે.

• રાઉન્ડ 2: (10,000 + 1,000 + નવો પ્રશ્ન) મોકલો, AI જવાબ આપે છે...

• રાઉન્ડ 10: તમારો સંદર્ભ કદાચ 200,000 ટોકન્સ સુધી વધી ગયો છે.

આ સમયે, જો તમે ફક્ત "મને ચલનું નામ બદલવામાં મદદ કરો" એવો પ્રશ્ન પૂછો છો, તો પણ 200,000 ટોકન્સ નો ખર્ચ થશે. આ જ કારણ છે કે તમને લાગે છે કે તમે કંઈ કર્યું નથી, પરંતુ બિલ આસમાને આંબી રહ્યું છે.

વધુ ખરાબ બાબત એ છે કે: એજન્ટ મોડ "સક્રિયપણે ફાઇલો વાંચે છે." તમે "મને વપરાશકર્તા મોડ્યુલને ઑપ્ટિમાઇઝ કરવામાં મદદ કરો" એમ કહો છો, તો તે પહેલા સંબંધિત ડિરેક્ટરીને સ્કેન કરી શકે છે, પછી અવલંબનોને ટ્રેસ કરી શકે છે, પછી રૂપરેખાંકનોને ટ્રેસ કરી શકે છે અને પછી પરીક્ષણોને ટ્રેસ કરી શકે છે... તે આળસુ નથી, તે "ડિફૉલ્ટ વ્યૂહરચના અનુસાર તેની ફરજ બજાવી રહ્યું છે," અને ડિફૉલ્ટ વ્યૂહરચના ઘણીવાર આ હોય છે: વધુ વાંચો, વધુ પ્રયાસ કરો અને વધુ પુનરાવર્તન કરો.

2. બે પ્રકારની "આળસ" તમારી એન્જિનિયરિંગ ક્ષમતાનો નાશ કરી રહી છે

ટિપ્પણી વિભાગમાંના તે "100 મિલિયન ભાઈઓ" ની સમીક્ષા કર્યા પછી, મને જાણવા મળ્યું કે ટોકન્સમાં વધારો થવાનું મૂળ કારણ માત્ર AI ના વપરાશ મિકેનિઝમની સમસ્યા નથી, પરંતુ લોકોની આળસ સાથે પણ ગાઢ રીતે સંબંધિત છે.

નીચે બે લાક્ષણિક "વિચાર આળસ" છે.

આળસ 1: હેન્ડ્સ-ઑફ મેનેજર પ્રકાર

શું તમારી પાસે પણ આ પ્રકારની માનસિકતા છે:

• "આ જૂનો પ્રોજેક્ટ ખૂબ જ અવ્યવસ્થિત છે, હું તર્ક જોવા માટે પરેશાન થતો નથી, ચાલો તેને સીધો AI ને સોંપીએ."

• "કર્સર એજન્ટ મોડ સાથે બહાર આવ્યું છે, તે ખૂબ જ સરસ છે, ચાલો તેને જાતે જ ભૂલો સુધારવા દો."

તેથી, તમે સમગ્ર src ફોલ્ડરને એજન્ટને સોંપી દો અને એક અસ્પષ્ટ સૂચના આપો: "મને વપરાશકર્તા મોડ્યુલને ઑપ્ટિમાઇઝ કરવામાં મદદ કરો." એજન્ટ કામ કરવાનું શરૂ કરે છે:

• તે 50 ફાઇલો વાંચે છે (500,000 નો વપરાશ).

• તે શોધે છે કે utils નો ઉલ્લેખ કરવામાં આવ્યો છે, તેથી તે ટૂલ ક્લાસ વાંચવા જાય છે (200,000 નો વપરાશ).

• તે સંશોધિત કરવાનો પ્રયાસ કરે છે, ભૂલ આવે છે અને ભૂલ લોગ વાંચે છે (100,000 નો વપરાશ).

• તે સુધારવાનો પ્રયાસ કરે છે, અને ફરીથી ભૂલ આવે છે...

તે ઉન્મત્ત રીતે પ્રયાસ કરી રહ્યું છે અને ભૂલો કરી રહ્યું છે, અને ઉન્મત્ત રીતે ટોકન્સનો વપરાશ કરી રહ્યું છે. અને તમે? તમે તમારો ફોન બ્રાઉઝ કરી રહ્યા છો, એવું વિચારી રહ્યા છો કે તમે કેટલા કાર્યક્ષમ છો. હકીકત એ છે કે: તમે પૈસા માટે "ખોટી કાર્યક્ષમતા" નો વેપાર કરી રહ્યા છો, અને કોડનો ઢગલો ઉત્પન્ન કરી રહ્યા છો જેની તમે પછીથી જાળવણી કરી શકતા નથી.

વધુ વ્યવસાયિક રીતે કહીએ તો, અહીં બે સ્તરોનું નુકસાન છે:

• ખર્ચ સ્તર: ઇનપુટ ટોકન્સ મોટા થાય છે, પુનરાવર્તનોની સંખ્યા વધે છે અને ખર્ચ રેખીય રીતે ઉમેરાય છે

• એન્જિનિયરિંગ સ્તર: તમે સંદર્ભ અને નિર્ણય લેવાનો અધિકાર ગુમાવો છો, અને અંતે તમારી પાસે ફક્ત અનિયંત્રિત સિસ્ટમ બાકી છે "જ્યાં સુધી તે ચાલે ત્યાં સુધી."

આળસ 2: બધું એકસાથે ફેંકી દેવાનો પ્રકાર

જ્યારે તમને કોઈ ભૂલ આવે છે, ત્યારે તમે તેને AI ને કેવી રીતે સોંપો છો? શું તમે સીધા જ સમગ્ર ભૂલ કન્સોલને Ctrl+A થી કૉપિ કરો છો, અથવા AI ને જાતે શોધવા માટે સીધા @Codebase નો ઉપયોગ કરો છો?

આને "બધું એકસાથે ફેંકી દેવું" કહેવાય છે. તમે સમસ્યાના મૂળને શોધવા માટે પરેશાન થતા નથી, અને તમે મુખ્ય કોડ સ્નિપેટ્સને ફિલ્ટર કરવા માટે પરેશાન થતા નથી. તમે 99% અમાન્ય માહિતી (ઘોંઘાટ) અને 1% માન્ય માહિતી (સંકેત) ને AI માં એકસાથે ફેંકી દો છો.

AI એક એમ્પ્લીફાયર જેવું છે.

• તમે તેને સ્પષ્ટ તર્ક (સંકેત) આપો છો, તે તમારી બુદ્ધિને વધારે છે, ઓછા ટોકન્સનો ઉપયોગ થાય છે અને અસર સારી હોય છે.

• તમે તેને મૂંઝવણ અને અસ્પષ્ટતા આપો છો, તે તમારી મૂંઝવણને વધારે છે, ટોકન્સ આસમાને આંબી જાય છે અને કચરો ઉત્પન્ન થાય છે.

3. ઉકેલ: AI નો અસરકારક રીતે ઉપયોગ કેવી રીતે કરવો અને ટોકન વપરાશ કેવી રીતે ઘટાડવો

તમારા વૉલેટને સુરક્ષિત રાખવા માટે, તમારા એન્જિનિયરિંગ નિયંત્રણ ને સુરક્ષિત રાખવું વધુ મહત્વપૂર્ણ છે. આપણે AI સાથેના સહયોગના મોડને બદલવો જોઈએ.

1. ન્યૂનતમ સંદર્ભ સિદ્ધાંત

આ AI પ્રોગ્રામિંગનો પ્રથમ સિદ્ધાંત છે. હંમેશા AI ને ફક્ત વર્તમાન સમસ્યાને ઉકેલવા માટેના ન્યૂનતમ કોડ સેટ આપો.

કર્સર માં, આ ઓપરેટરોનો સારી રીતે ઉપયોગ કરો:

• @File: સમગ્ર ફોલ્ડરને બદલે ફક્ત સંબંધિત ફાઇલોનો ઉલ્લેખ કરો.

• Ctrl+L કોડ પસંદ કરો: સમગ્ર ફાઇલને બદલે ફક્ત કર્સર દ્વારા પસંદ કરેલી 50 લીટીઓનો કોડ ચેટ પર મોકલો.

• @Docs: તૃતીય-પક્ષ લાઇબ્રેરીઓ માટે, અનુમાન લગાવવા દેવાને બદલે દસ્તાવેજોનો ઉલ્લેખ કરો.

આ હું વારંવાર ઉપયોગ કરું છું તે માળખાગત, ફરીથી વાપરી શકાય તેવું SOP છે (તમે તેનું પાલન કરો છો, અને ટોકન્સ દૃશ્યમાન રીતે ઘટશે):

આ વાક્યનો અર્થ એ છે કે: AI સાથે સહયોગ કરતી વખતે, કાર્યક્ષમ અને સચોટ બનવા પર ધ્યાન આપો. ચોક્કસ અભિગમો નીચે મુજબ છે:

• પ્રથમ ધ્યેયને સ્પષ્ટ કરો: AI ને વર્તમાન સમસ્યા અને ઇચ્છિત પરિણામ વિશે સંક્ષિપ્તમાં જણાવો, તેને જાતે અનુમાન લગાવવા દો નહીં.

• સમસ્યાના પુનઃઉત્પાદનને સુવ્યવસ્થિત કરો: જો તમે સૌથી સરળ પદ્ધતિથી સમસ્યાને ફરીથી ઉત્પન્ન કરી શકો છો, તો જટિલ પદ્ધતિનો ઉપયોગ કરશો નહીં, અને ઓછામાં ઓછો અને મહત્વપૂર્ણ કોડ પેસ્ટ કરો, સંબંધિત ન હોય તેવી સામગ્રીનો ઢગલો કરશો નહીં.

• ન્યૂનતમ જરૂરી માહિતી પ્રદાન કરો: ફક્ત 1-3 સંબંધિત ફાઇલો, મુખ્ય કાર્યો અને ભૂલ સ્ટેકના પ્રથમ થોડી લીટીઓ આપો, સંપૂર્ણ માહિતી આપશો નહીં.

• ફેરફારના મુદ્દાઓ પરત કરવા માટે કહો: AI ને ફક્ત તમને જણાવવા દો કે ક્યાં બદલવું, શા માટે બદલવું, તેને સમગ્ર કોડને મોટા પ્રમાણમાં ફરીથી લખવા દો નહીં.

• છેલ્લે, જાતે તપાસ કરો: ખાતરી કરવા માટે સૌથી સરળ ચકાસણી કરો કે ફેરફારોથી અન્ય સ્થળોએ અસર થતી નથી.

ટૂંકમાં, AI ને ઓછામાં ઓછી અને સૌથી મહત્વપૂર્ણ માહિતી સાથે કામ કરવા દો અને અંતિમ નિયંત્રણ અને નિર્ણય જાળવી રાખો.

2. સૌથી મહત્વપૂર્ણ પણ: પ્રોમ્પ્ટ કરતા પહેલા વિચારો, કાર્ય કરતા પહેલા યોજના બનાવો

એન્ટર કી દબાવતા પહેલા, તમારી જાતને 10 સેકન્ડ માટે થોભાવવા માટે દબાણ કરો અને તમારી જાતને ત્રણ પ્રશ્નો પૂછો:

• હું કઈ સમસ્યાનું નિરાકરણ લાવી રહ્યો છું? (સીમાઓ વ્યાખ્યાયિત કરો)

• આ સમસ્યામાં કયા મુખ્ય મોડ્યુલો સામેલ છે? (સંદર્ભને ફિલ્ટર કરો)

• જો હું તે જાતે લખું, તો હું તે કેવી રીતે લખીશ? (વિચારો પ્રદાન કરો)

તમે 1 છો, અને AI પાછળનું 0 છે. જો 1 ઊભું ન રહી શકે, તો પાછળના ગમે તેટલા 0 હોય, તે માત્ર અર્થહીન વપરાશ છે.

થોડા નિષ્ઠાવાન શબ્દો

"એક દિવસમાં એક કરોડ ટોકન્સ" ની વાર્તા દરેક સાથે ન પણ બને. પરંતુ ટોકન્સનો બગાડ કરવાની વર્તણૂકનો અનુભવ લગભગ દરેક પ્રોગ્રામર કરે છે જે AI પ્રોગ્રામિંગનો ઉપયોગ કરે છે.

AI એ પ્રોગ્રામિંગને સરળ બનાવ્યું છે, પરંતુ હજુ પણ એક થ્રેશોલ્ડ છે. જે લોકો તેનો ખરેખર ઉપયોગ કરવાનું જાણે છે તેઓ જ વધુ શક્તિશાળી બનશે.

અગાઉ, તમે લખેલો ખરાબ કોડ ફક્ત સાથીદારોને "અણગમો" આપતો હતો. હવે, તમે જે આળસ કરો છો તે સીધી બિલ પરના આંકડામાં ફેરવાઈ જશે અને વધતા ખર્ચથી તમારી જાતને સજા આપશે.તેથી, 'હેન્ડ્સ-ઓફ મેનેજર' ન બનો. એક ઊંડાણપૂર્વક વિચારનાર, ચોક્કસ અભિવ્યક્તિ કરનાર, આયોજન પછી કાર્ય કરનાર AI આર્કિટેક્ટ બનો. આ યુગમાં આપણી સૌથી મોટી બદલી ન શકાય તેવી બાબત પણ આ જ છે.