ChatGPT बनाम कोपिलॉट बनाम प्रोग्रामर्स: शीर्ष पर कौन आ रहा है?

नो-कोड/लो-कोड वातावरण की बढ़ती उपलब्धता और प्रोग्रामिंग पर लागू एआई के आगमन के साथ, ऐसे कई लेख पोस्ट किए गए हैं जिनमें कहा गया है कि प्रोग्रामर के लिए अंत निकट है क्योंकि या तो अंतिम उपयोगकर्ता अपने स्वयं के ऐप बनाएंगे या एआई करेंगे विवरण से ऐप्स लिखें। शायद... लेकिन अभी नहीं।

इस लेख में, मैं OpenAI ChatGPT और कोडेक्स के Microsoft Copilot के हाथ से लिखे कोड के सुझावों की तुलना करके AI-सहायता कोडिंग की वर्तमान स्थिति का पता लगाता हूं। एआई या तो औसत या त्रुटिपूर्ण कोड उत्पन्न करते हैं।

चूँकि आज बहुत अधिक मात्रा में डेटा (चैटजीपीटी और कोपिलॉट के लिए उपयोग किए जाने वाले बड़े भाषा मॉडल सहित) को संसाधित करने पर ध्यान केंद्रित किया जाता है, मैं उन एल्गोरिदम पर ध्यान केंद्रित करता हूं जो डेटा को कुशलतापूर्वक संसाधित करने के लिए महत्वपूर्ण हैं। उम्मीद है, एआई सामान्य रूप से कोड की तुलना में अपनी प्रकृति को "समझ" लेते हैं!

ये एल्गोरिदम हैं:

• चौराहा

• पार उत्पाद

• memoizing

  
  

मैंने ChatGPT को फ़ॉर्म के लिए दिशा-निर्देश प्रदान किए:

मुझे <कुछ फ़ंक्शन विवरण> दिखाएं

मैंने इनपुट के साथ कोडेक्स प्रदान किया:

<कुछ फ़ंक्शन विवरण>

मैंने वेबस्टॉर्म आईडीई में टिप्पणियों के साथ कोपिलॉट प्रदान किया

// <कुछ फ़ंक्शन विवरण>

फ़ंक्शन विवरण प्रत्येक के लिए समान थे।

परीक्षण पद्धति

मैंने जैस्मीन को यूनिट टेस्ट हार्नेस के रूप में इस्तेमाल किया, जो कि बेंचटेस्ट में पाए गए कोड के समान है, जो स्पीड प्लस मेमोरी और सीपीयू उपयोग प्राप्त करने के लिए है।

चौराहा

मुझे एक जावास्क्रिप्ट फ़ंक्शन दिखाएं जो सरणियों की एक चर संख्या लेता है और उनका प्रतिच्छेदन लौटाता है।

ओपनएआई चैटजीपीटी

 function intersection(...arrays) { if (arrays.length < 2) { throw new Error("At least 2 arrays are required!"); } let result = new Set(arrays.shift()); for (let arr of arrays) { result = new Set([...result].filter(x => arr.includes(x))); } return [...result]; }

ओपनएआई कोडेक्स

 function intersection(arrays) { var result = []; var args = Array.prototype.slice.call(arguments); var arrays = args.slice(0, args.length - 1); var callback = args[args.length - 1]; var minLength = Math.min.apply(null, arrays.map(function(arr) { return arr.length; })); for (var i = 0; i < minLength; i++) { var item = arrays[0][i]; var isInAll = arrays.every(function(arr) { return arr.indexOf(item) !== -1; }); if (isInAll) { result.push(item); } } return callback(result); }

माइक्रोसॉफ्ट सह पायलट

 const intersection = (...arrays) => { const [first, ...rest] = arrays; return first.filter(x => rest.every(y => y.includes(x))); }

ChatGPT ने माना कि एक से कम सरणी प्रदान करना मान्य नहीं है। मैं उन परिस्थितियों की कल्पना कर सकता हूं जिनमें एक तर्क प्रदान करना मान्य हो सकता है।

सेट का उपयोग करके, चैटजीपीटी सुनिश्चित करता है कि परिणामों में कोई डुप्लिकेट मौजूद नहीं है। चौराहा एक सेट ऑपरेशन माना जाता है, और डुप्लिकेट को हटा दिया जाना चाहिए। सह-पायलट कोड एक सरणी लौटाएगा जिसमें डुप्लिकेट हो सकते हैं।

न तो चैटजीपीटी और न ही कोपिलॉट मूल तर्कों को लंबाई के आधार पर क्रमबद्ध करते हैं। यह एक तुच्छ अनुकूलन है जो एक बड़ा अंतर ला सकता है!

यदि किसी तर्क की लंबाई शून्य है, तो कोई प्रतिच्छेदन नहीं है; परवाह किए बिना, यह लूप को छोटा करता है क्योंकि अधिकतम चौराहा सबसे छोटा सरणी तर्क के समान होता है।

कोडेक्स ने जटिल कोड प्रदान किया, जो कि मेरी जानकारी के आधार पर, काफी कुशल दिखता था। हालाँकि, इसके तर्कों का उपयोग अस्पष्ट है और इसमें कुछ पुरातन प्रोग्रामिंग शैली शामिल है।

ध्यान दें, कॉलिंग कोड के चौराहे को वापस करने के लिए अंतिम तर्क के रूप में एक कॉलबैक प्रदान किया जाना चाहिए, लेकिन तर्क नहीं दिखाया गया है।

मैंने तब चैटजीपीटी और कोपिलॉट से मुझे एक कुशल कार्य देने के लिए कहा।

मुझे एक कुशल जावास्क्रिप्ट फ़ंक्शन दिखाएं जो सरणियों की एक चर संख्या लेता है और उनका प्रतिच्छेदन लौटाता है।

चैटजीपीटी

 function intersection(...arrays) { if (arrays.length < 2) { throw new Error("At least 2 arrays are required!"); } let result = new Set(); for (let item of arrays[0]) { let include = true; for (let i = 1; i < arrays.length; i++) { if(!arrays[i].includes(item)){ include = false; break; } } if(include){ result.add(item); } } return [...result]; }

कोपिलॉट ने पहले अनुरोध के समान कोड उत्पन्न किया।

ChatGPT ने यह कहते हुए टिप्पणी भी जोड़ी कि फ़ंक्शन वस्तुओं के लिए अपेक्षित रूप से काम नहीं करेगा, हालाँकि यकीनन यह होगा। इसलिए, मैंने एक ऐसे कार्य के लिए कहा जो वस्तुओं का समर्थन करेगा:

मुझे एक कुशल जावास्क्रिप्ट फ़ंक्शन दिखाएं जो वस्तुओं या आदिम युक्त सरणियों की एक चर संख्या लेता है और उनका प्रतिच्छेदन देता है।

 function intersection(...arrays) { if (arrays.length < 2) { throw new Error("At least 2 arrays are required!"); } let result = new Set(); for (let item of arrays[0]) { let include = true; for (let i = 1; i < arrays.length; i++) { if(!arrays[i].find(x => JSON.stringify(x) === JSON.stringify(item))){ include = false; break; } } if(include){ result.add(item); } } return [...result]; } This function takes an arbitrary number of arrays as arguments and first checks if at least 2 arrays are passed. Then it uses a nested loop. The outer loop iterates over the first array and the inner loop iterates over the remaining arrays. It compares each item of the first array with each item of the remaining arrays using Array.prototype.find() method and JSON.stringify() to check if the objects are the same. If an item is found in all arrays, it is added to

ChatGPT वस्तुओं की तुलना करने के लिए उन्हें सख्त बनाता है। इसके साथ कई मुद्दे हैं:

1. एक ही स्ट्रिंग प्रतिनिधित्व वाली दो वस्तुएं वैध रूप से अलग-अलग वस्तुएं हो सकती हैं।

   
   

2. यहां तक कि अगर स्ट्रिंग करना वैध है, तो अलग-अलग संपत्ति के आदेश अलग-अलग स्ट्रिंग्स में परिणामित होंगे, और ऑब्जेक्ट एक ही इकाई का प्रतिनिधित्व कर सकते हैं।

   
   

3. JSON.stringify के बाद एक स्ट्रिंग तुलना एक धीमी प्रक्रिया है।

   
   

और अब, असली परीक्षा! नीचे, ChatGPT, Codex, Copilot, और NPM, fastArrayIntersect और intersector के माध्यम से उपलब्ध दो सबसे तेज़ इंटरसेक्शन लाइब्रेरी द्वारा उत्पन्न कोड का उपयोग करके गति और मेमोरी के लिए बेंचमार्क परिणाम हैं।

बेंचमार्क ने 10,000 पूर्णांकों के 3 समान सरणियों को प्रतिच्छेद किया और 100 के नमूने के आकार के साथ 5,000 पूर्णांकों की अंतिम सरणी। स्रोत सरणियों में डुप्लिकेट प्रविष्टियाँ मौजूद होने पर सेट किए गए फ़ंक्शन की पुष्टि करने के लिए एक परीक्षण भी चलाया गया था।

सहपायलट कम से कम हीप का उपयोग करता है लेकिन यह सबसे धीमा और सबसे अधिक CPU-गहन भी है।

ChatGPT कम से कम CPU-गहन है, लेकिन धीमा भी है।

फास्ट एरे इंटरसेक्ट कोपिलॉट और चैट जीपीटी से 3 से 5 गुना तेज है और कम सीपीयू-इंटेंसिव होने के साथ कोडेक्स से 20% तेज है।

चैटजीपीटी और कोपिलॉट की तुलना में इंटरसेक्टर 15 गुना तेज है, कोडेक्स की तुलना में 4 गुना तेज है, और फास्ट एरे इंटरसेक्ट की तुलना में 3 गुना तेज है, जबकि सबसे कम सीपीयू उपयोग भी है।

संक्षेप में:

1. न तो चैटजीपीटी और न ही सहपायलट कुशल कोड उत्पन्न करते हैं।

   
   

2. ChatGPT ऐसी मान्यताएँ बनाता है जो मान्य नहीं हो सकती हैं।

   
   

3. सहपायलट कोड उत्पन्न करता है जो एक सेट का उत्पादन नहीं करता है जब उसके तर्कों में डुप्लिकेट मान होते हैं।

   
   

4. कोडेक्स उचित निष्पादक पैदा करता है, हालांकि अस्पष्ट कोड।

   
   

5. प्रोग्रामर जीतते हैं।

   
   

उपयोगकर्ता से कुछ स्पष्ट प्रश्न पूछने के लिए चैटजीपीटी और कोपिलॉट दोनों को उनकी "बुद्धिमत्ता" को लागू करके बेहतर बनाया जा सकता है, उदाहरण के लिए, क्या आप गति या स्मृति दक्षता की तलाश कर रहे हैं, क्या आप कम से कम दो तर्कों की आवश्यकता चाहते हैं?

पार उत्पाद

इस खंड के उद्देश्य पर स्पष्ट होने के लिए, मैं सरणी में वस्तुओं के सभी संभावित संयोजनों की तलाश कर रहा था, न कि वैक्टरों के अंकगणितीय क्रॉस-उत्पाद।

कार्टेशियन क्रॉस-प्रोडक्ट के लिए मुझे जावास्क्रिप्ट फ़ंक्शन दिखाएं।

ओपनएआई चैटजीपीटी

 function cartesianCrossProduct(v1, v2) { var x = v1.y*v2.z - v1.z*v2.y; var y = v1.z*v2.x - v1.x*v2.z; var z = v1.x*v2.y - v1.y*v2.x; return {x: x, y: y, z: z}; }

ओपनएआई कोडेक्स

 function crossProduct(arrays) { var result = []; var args = Array.prototype.slice.call(arguments); var arrays = args.slice(0, args.length - 1); var callback = args[args.length - 1]; var maxLength = Math.max.apply(null, arrays.map(function(arr) { return arr.length; })); for (var i = 0; i < maxLength; i++) { var item = arrays[0][i]; var isInAll = arrays.every(function(arr) { return arr.indexOf(item) !== -1; }); if (isInAll) { result.push(item); } } return callback(result); }

माइक्रोसॉफ्ट सह पायलट

 const crossProduct = (...arrays) => { const [first, ...rest] = arrays; return first.flatMap(x => rest.map(y => [x, y])); }

दुर्भाग्य से, चैटजीपीटी ने अंकगणितीय क्रॉस-उत्पाद के लिए एक फ़ंक्शन प्रदान किया। मेरी राय में, इसे दोनों प्रकार के कार्य प्रदान करने चाहिए थे या स्पष्टीकरण मांगा जाना चाहिए था।

विभिन्न प्रश्नों पर कई प्रयासों के बाद, मैं नीचे दिए गए तीनों को उत्पन्न करने के लिए चैटजीपीटी प्राप्त करने में सक्षम था:

 function crossProduct(...arrays) { if (arrays.length < 2) { throw new Error("At least 2 arrays are required!"); } let result = arrays[0].reduce((acc, x) => { return acc.concat(arrays.slice(1).reduce((acc, y) => { return acc.concat(y.map(z => [x].concat(z))); }, [])) }, []); return result; }

 function allCombinations(...args) { var result = []; var f = function(prefix, arr) { for (var i = 0; i < arr.length; i++) { var newPrefix = prefix.concat(arr[i]); result.push(newPrefix); if (args.length > 0) { f(newPrefix, args.shift()); } } } f([], args[0]); return result; }

 function crossProduct(...args) { var result = []; for(let i = 0; i < args.length; i++){ for(let j = i + 1; j < args.length; j++){ for(let ii = 0; ii < args[i].length; ii++){ for(let jj = 0; jj < args[j].length; jj++){ result.push([args[i][ii], args[j][jj]]); } } } } return result; }

सह पायलट

 const crossProduct = (...arrays) => { const [first, ...rest] = arrays; return first.flatMap(x => rest.map(y => [x, y])); }

प्रतिच्छेदन के साथ, कोडेक्स ने एक पुरानी प्रोग्रामिंग शैली का उपयोग करके अस्पष्ट तर्क प्रबंधन के साथ एक फ़ंक्शन प्रदान किया।

कार्टेशियन उत्पादों से परिचित लोगों को पता चल जाएगा कि वे स्मृति उपयोग और प्रदर्शन के दृष्टिकोण से विस्फोटक हो सकते हैं।

सरल कार्यान्वयन सभी क्रमपरिवर्तनों को संग्रहीत करने के लिए पर्याप्त रैम का उपभोग करेगा और सभी क्रमपरिवर्तन उत्पन्न होने तक परिणाम वापस नहीं करेगा (जो कि एक लंबा समय हो सकता है)। ChatGPT और Copilot दोनों कार्य इन कमियों से ग्रस्त हैं।

इसलिए, मैंने बाद में कार्टेशियन उत्पाद के लिए मेमोरी कुशल जावास्क्रिप्ट फ़ंक्शन के लिए कहा।

चैटजीपीटी

 function cartesianProduct(...args) { const iterators = args.map(arg => arg[Symbol.iterator]()); const next = () => { const values = iterators.map(iterator => iterator.next().value); return values.length > 1 ? values : null; }; return { [Symbol.iterator]: () => ({ next }) }; }

कोपिलॉट ने वही परिणाम प्रदान किए जो उसने पहले किए थे।

मैंने मान लिया कि चैटजीपीटी से "मेमोरी कुशल" संस्करण पहले वाले की तुलना में कम रैम का उपयोग करता है। हालाँकि, मुझे पता था कि यह इष्टतम नहीं था। कई प्रयासों के बाद, मैं जनरेटर का उपयोग करके कार्टेशियन उत्पाद के लिए मेमोरी कुशल जावास्क्रिप्ट फ़ंक्शन के साथ आया।

चैटजीपीटी

 function* cartesianProduct(...args) { const recursion = (arrays, i = 0) => { if (i === arrays.length - 1) { yield* arrays[i]; } else { for (let item of arrays[i]) { for (let result of recursion(arrays, i + 1)) { yield [item, ...result]; } } } } yield* recursion(args); }

सच कहूं तो, चैटजीपीटी की इस प्रतिक्रिया से मुझे सुखद आश्चर्य हुआ। हालाँकि, इस कोड को चलाने के प्रयास विफल रहे क्योंकि yield [item,...result] एक जनरेटर के अंदर नहीं है, यह एक नेस्टेड फ़ंक्शन के अंदर है जिसे recursion कहा जाता है।

मुझे थोड़ी भिन्नता भी मिली जिसमें मैंने क्वेरी खो दी:

 function* crossProduct(...arrays) { if (arrays.length < 2) { throw new Error("At least 2 arrays are required!"); } function* recurse(depth, current) { if (depth === arrays.length) { yield current; } else { for (let item of arrays[depth]) { yield* recurse(depth + 1, current.concat(item)); } } } yield* recurse(1, [arrays[0]]); }

एक बार फिर, ChatGPT तर्कों के बारे में कुछ धारणाएँ बनाता हुआ प्रतीत हुआ।

कोपिलॉट ने वही कोड लौटाया जैसा उसने पहले किया था। इसने जनरेटर के लिए मेरे अनुरोध को पूरी तरह से नजरअंदाज कर दिया।

और अब, असली परीक्षा! नीचे ChatGPT, Copilot, और सबसे तेज़, सबसे मेमोरी कुशल कार्टेशियन उत्पादों द्वारा उत्पन्न कोड का उपयोग करके गति और मेमोरी के लिए बेंचमार्क परिणाम दिए गए हैं, जिनमें से मैं CXProduct और Lazy Cartesian Product से अवगत हूं।

इसमें एक-पंक्ति फ़ंक्शन भी शामिल है जो शायद या तो ChatGPT या Copilot को वापस आ जाना चाहिए था (जब आप परिणामों की समीक्षा करेंगे तो आप देखेंगे कि मैंने इसे क्यों शामिल किया)।

 //https://stackoverflow.com/questions/12303989/cartesian-product-of-multiple-arrays-in-javascript const cartesian = (...a) => a.reduce((a, b) => a.flatMap(d => b.map(e => [d, e].flat())));

परीक्षण 4 सरणियों के कार्टेशियन उत्पाद को 10 वस्तुओं के साथ लेता है। इसलिए, कार्यों को 10 * 10 * 10 * 10 वस्तुओं, यानी 10,000 के कार्टेशियन उत्पाद का उत्पादन करना चाहिए।

संक्षेप में:

1. चैटजीपीटी, कोडेक्स और कोपिलॉट कोड उत्पन्न करने में असमर्थ हैं जो कार्टेशियन उत्पाद के लिए सही परिणाम उत्पन्न करता है।

   
   

2. ChatGPT कभी-कभी ऐसी धारणाएँ बनाता है जो मान्य नहीं हो सकती हैं, उदाहरण के लिए, 2 तर्कों की आवश्यकता होती है।

   
   

3. चैटजीपीटी जनरेट किया गया कोड जो यह कहता है कि अधिक मेमोरी कुशल था लेकिन यह चलेगा भी नहीं।

   
   

4. प्रोग्रामर जीत गए!

एक बार फिर, उपयोगकर्ता से कुछ स्पष्ट प्रश्न पूछने के लिए अपनी "बुद्धिमत्ता" को लागू करके चैटजीपीटी में सुधार किया जा सकता है, उदाहरण के लिए, क्या आप गति या स्मृति दक्षता की तलाश कर रहे हैं, क्या आप कम से कम दो तर्कों की आवश्यकता चाहते हैं? हालाँकि, इससे पहले, इसे सही कोड जनरेट करना होगा!

संस्मरण

चौराहे और कार्टेशियन उत्पादों के साथ अपना सबक सीखने के बाद, मैंने तुरंत मेमोइज़ेशन के लिए एक परिष्कृत प्रश्न पूछा।

मुझे एक कुशल जावास्क्रिप्ट फ़ंक्शन दिखाएं जो वस्तु और आदिम तर्कों को याद करता है।

ओपनएआई चैटजीपीटी

 function memoize(fn) { let cache = new WeakMap(); return function(obj, ...args) { let key; if (obj) { if (!cache.has(obj)) { cache.set(obj, {}); } key = JSON.stringify([obj, ...args]); } else { key = JSON.stringify(args); } if (cache.has(key)) { return cache.get(key); } let result = fn.apply(this, [obj, ...args]); cache.set(key, result); return result; } }

ChatCPT ने अमान्य कोड जनरेट किया; WeakMap को किसी ऑब्जेक्ट को कुंजी के रूप में उपयोग करना चाहिए। परीक्षण के लिए कोड को निम्नानुसार संशोधित किया गया था।

 function memoize(fn) { let cache = new Map(); return function(obj, ...args) { let key; if (obj!=null) { if (!cache.has(obj)) { cache.set(obj, {}); } key = JSON.stringify([obj, ...args]); } else { key = JSON.stringify(args); } if (cache.has(key)) { return cache.get(key); } let result = fn.apply(this, [obj, ...args]); cache.set(key, result); return result; } }

एआई कोडेक्स खोलें

 function memoize(func) { var cache = {}; return function() { var args = Array.prototype.slice.call(arguments); var key = JSON.stringify(args); if (cache[key]) { return cache[key]; } else { var result = func.apply(null, args); cache[key] = result; return result; } } }

माइक्रोसॉफ्ट सह पायलट

 const memoize = (fn, cache = new Map()) => { return (...args) => { const key = JSON.stringify(args); if (cache.has(key)) { return cache.get(key); } else { const result = fn(...args); cache.set(key, result); return result; } } }

कोडेक्स और कोपिलॉट ने एक ही फ़ंक्शन उत्पन्न किया जो आश्चर्यजनक नहीं होना चाहिए क्योंकि कोपिलॉट कोडेक्स पर आधारित है। हालाँकि, पहले के उदाहरणों में, वे भिन्न थे।

ChatGPT, कोडेक्स, और Copilot अक्षम कार्य, JSON.stringify उत्पन्न करते हैं, इसके बाद एक स्ट्रिंग तुलना धीमी और स्मृति-खपत पैमाने पर होती है।

ऐसे जावास्क्रिप्ट मान भी हैं जो कड़े नहीं होते हैं, उदाहरण के लिए, इन्फिनिटी और NaN। (दुर्भाग्य से, JavaScript JSON कल्पना को डेटा विज्ञान और सूक्ष्म सेवाओं की उम्र से पहले परिभाषित किया गया था, और यह माना गया था कि अनंतता और NaN कोड में निहित त्रुटियां हैं जो या तो वैध नहीं थीं या उन्हें एक स्थान से दूसरे स्थान पर ले जाने की आवश्यकता नहीं थी। .)

तो अब, इस कोड का उपयोग करके 12 वीं फाइबोनैचि संख्या उत्पन्न करके चैटजीपीटी और कोपिलॉट कोड की नैनो-मेमोइज़ और माइक्रो-मेमोइज़ की तुलना करके दक्षता के प्रमाण के लिए:

 const fibonacci = (number) => { return number < 2 ? number : fibonacci(number - 1) + fibonacci(number - 2); };

नैनो-मेमोइज़ सबसे तेज़ और चैटजीपीटी, कोडेक्स और कोपिलॉट कोड से लगभग दोगुना तेज़ है। यह कम मेमोरी का भी उपयोग करता है। माइक्रो-मेमोइज़ अपने ऊँची एड़ी के जूते के करीब है।

हालाँकि nano-memoize और micro-memoize के लिए CPU उपयोग कोड और कोपिलॉट की तुलना में थोड़ा अधिक है, प्रदर्शन इसके लायक है, और प्रोग्रामर एक बार फिर जीत जाते हैं!

सारांश और परिकल्पना

हालाँकि कोड जनरेशन के लिए Copilot और ChatGPT दोनों के उपयोग में निश्चित रूप से मूल्य है, इसे सावधानी से किया जाना चाहिए। न तो इष्टतम कोड का उत्पादन होगा और कुछ मामलों में, यह केवल अमान्य या खराब, गलत होगा। इसके अतिरिक्त, चैटजीपीटी का उपयोग करते समय, प्रश्न काफी विशिष्ट होने चाहिए।

ChatGPT और Copilot दोनों को एक ऐसी सुविधा के अतिरिक्त सुधारा जा सकता है जो स्पष्ट प्रश्न पूछेगा।

चैटजीपीटी, अगर यह वास्तव में बुद्धिमान था, या तो उपयोगकर्ताओं को कोड जनरेशन के लिए अपने सहोदर कोडेक्स को नियोजित करने के लिए कहेगा या पृष्ठभूमि में कोडेक्स का उपयोग करेगा।

यदि यह पृष्ठभूमि में कोडेक्स का उपयोग कर रहा है, तो मुझे यकीन नहीं है कि क्या हो रहा है जब मैं दोनों को समान फ़ंक्शन विवरण प्रदान करता हूं और अलग-अलग परिणाम प्राप्त करता हूं।

हालाँकि, मैं किसी भी उपकरण के आंतरिक कामकाज से परिचित नहीं हूँ, यह जानने के अलावा कि वे भाषा मॉडल आधारित हैं, मुझे लगता है कि यह संभावना नहीं है कि वे उस बिंदु पर पहुँचेंगे जहाँ वे इस कमी को दूर किए बिना इष्टतम कोड उत्पन्न कर सकते हैं:

सार्वजनिक रूप से बिना जाँचे गए कोड की बड़ी मात्रा पर प्रशिक्षित प्रणाली कोड के लिए औसत परिणाम देने जा रही है, यानी औसत प्रदर्शन का कोड और बग की औसत संख्या वाला कोड।

लगातार सटीक परिणाम प्रदान करने के लिए, सिस्टम की आवश्यकता होगी:

1. "काउंटर सैंपल" डेटा के अंशों का उपभोग और उपयोग करने की क्षमता, उदाहरण के लिए, JSON.stringify, अक्षम हो सकती है। सिस्टम इस क्षमता को परीक्षण के परिणामों के साथ-साथ कोड का विश्लेषण करके या कुछ प्रकार के भार के साथ ज्ञात इष्टतम कोड या केवल ज्ञात विशेषज्ञों द्वारा परिणामों की आलोचना के माध्यम से प्राप्त कर सकता है। दुर्भाग्य से, इष्टतम कोड अक्सर सबसे अधिक प्रचलित या सबसे अधिक उपयोग नहीं किया जाता है, और केवल मॉडल को खिलाने से अधिक उदाहरण मदद नहीं करेंगे। आदर्श मामले में, वास्तव में एक बुद्धिमान प्रणाली अपने स्वयं के परीक्षण मामलों को उत्पन्न करने में सक्षम होगी।

   
   

2. दक्षता की खामियों के लिए उत्पन्न कोड का विश्लेषण करने के लिए प्रोग्रामिंग का एक गहरा, अधिक पहला सिद्धांत "समझ", उदाहरण के लिए, आमतौर पर रनटाइम दक्षता के लिए पुनरावर्तन पर पुनरावृत्ति का पक्ष लेते हैं, आमतौर पर कोड आकार और पठनीयता के लिए पुनरावर्तन का पक्ष लेते हैं।

   
   

3. कम से कम, एक कोड-जनरेटिंग एआई को उस कोड को पार्स करने का प्रयास करना चाहिए जो उसने उत्पन्न किया है और इसकी सिंटैक्टिक वैधता का मूल्यांकन करता है। यह चैटजीपीटी के लिए एक साधारण वृद्धि होनी चाहिए।

   
   

4. आदर्श रूप से, एआई प्रकार की वैधता सुनिश्चित करने के लिए कम से कम एक या दो सरल परीक्षण मामले चलाएगा। जब मैं इकाई परीक्षण बना रहा था, कोपिलॉट ने कई उपयोगी संवर्धित कोड पूर्णता का प्रस्ताव दिया, जिनका उपयोग इस उद्देश्य के लिए किया जा सकता है, उदाहरण के लिए, फ़ंक्शन कॉल और सरणी लुकअप के लिए तर्क। मुझे लगता है कि ऐसा करने के लिए चैटजीपीटी और कोडेक्स को बढ़ाया जा सकता है।

संसाधन

• ओपनएआई चैटजीपीटी: https://chat.openai.com/chat
• ओपनएआई कोडेक्स: https://beta.openai.com/codex-javascript-sandbox
• माइक्रोसॉफ्ट सह पायलट: https://github.com/features/copilot
• इंटरसेक्टर: https://github.com/anywhichway/intersector
• फास्ट ऐरे इंटरसेक्ट: https://github.com/lovasoa/fast_array_intersect
• कार्तीय उत्पाद एक लाइनर: https://stackoverflow.com/questions/12303989/cartesian-product-of-multiple-arrays-in-javascript
• सीएक्सप्रोडक्ट: https://github.com/anywhichway/cxproduct
• आलसी उत्पाद: http://phrogz.net/lazy-cartesian-product
• नैनो मेमोइज़: https://github.com/anywhichway/nano-memoize
• माइक्रो मेमोइज़: https://github.com/planttheidea/micro-memoize

मुझे आशा है कि आपको यह लेख अच्छा लगा होगा। एक अच्छा दिन है, और कल जो आपने आज (यहाँ या कहीं और) सीखा है उससे ईर्ष्या करें!

यहाँ भी प्रकाशित हुआ