ChatGPT vs Copilot vs Lập trình viên: Ai sẽ đứng đầu?

Với sự sẵn có ngày càng tăng của các môi trường không có mã/mã thấp và sự ra đời của AI được áp dụng cho lập trình, đã có một số bài báo được đăng nói rằng ngày tàn đối với các lập trình viên đã gần kề vì người dùng cuối sẽ tạo ứng dụng của riêng họ hoặc AI sẽ viết ứng dụng từ mô tả. Có lẽ… nhưng chưa.

Trong bài viết này, tôi khám phá trạng thái mã hóa được hỗ trợ bởi AI hiện tại bằng cách so sánh các đề xuất của OpenAI ChatGPT và Codex với Microsoft Copilot với mã viết tay. AI tạo ra mã trung bình hoặc mã thiếu sót.

Do ngày nay có quá nhiều trọng tâm được đặt vào việc xử lý khối lượng dữ liệu lớn (bao gồm cả các mô hình ngôn ngữ lớn được sử dụng cho ChatGPT và Copilot), nên tôi tập trung vào các thuật toán là chìa khóa để xử lý dữ liệu hiệu quả. Hy vọng rằng các AI “hiểu” bản chất của chúng hơn là mã nói chung!

Các thuật toán này là:

• ngã tư

• sản phẩm chéo

• ghi nhớ

  
  

Tôi đã cung cấp cho ChatGPT các hướng dẫn cho biểu mẫu:

Chỉ cho tôi <một số mô tả chức năng>

Tôi đã cung cấp Codex với đầu vào:

<một số mô tả chức năng>

Tôi đã cung cấp cho Copilot các nhận xét trong WebStorm IDE

// <mô tả một số chức năng>

Các mô tả chức năng là giống nhau cho mỗi.

Phương pháp kiểm tra

Tôi đã sử dụng Jasmine làm công cụ kiểm tra đơn vị được bổ sung bằng mã tương tự như mã được tìm thấy trong Benchtest để có được tốc độ cộng với mức sử dụng bộ nhớ và CPU.

Ngã tư

Chỉ cho tôi một hàm JavaScript nhận vào một số lượng mảng khác nhau và trả về giao điểm của chúng.

OpenAI 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]; }

OpenAI Codex

 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); }

Microsoft Copilot

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

ChatGPT giả định rằng việc cung cấp ít hơn một mảng là không hợp lệ. Tôi có thể hình dung các tình huống trong đó việc cung cấp một đối số có thể hợp lệ.

Bằng cách sử dụng Set , ChatGPT đảm bảo rằng không có kết quả trùng lặp nào tồn tại trong kết quả. Giao lộ được coi là một hoạt động đã đặt và các bản sao phải được xóa. Mã Copilot sẽ trả về một mảng có thể chứa các bản sao.

Cả ChatGPT và Copilot đều không sắp xếp các đối số ban đầu tăng dần theo độ dài. Đây là một tối ưu hóa tầm thường có thể tạo ra sự khác biệt lớn!

Nếu bất kỳ đối số nào có độ dài bằng 0, thì không có giao điểm; bất kể, nó rút ngắn các vòng lặp vì giao điểm tối đa giống như đối số mảng ngắn nhất.

Codex cung cấp mã phức tạp, dựa trên hiểu biết của tôi, trông khá hiệu quả. Tuy nhiên, việc sử dụng các đối số của nó không rõ ràng và liên quan đến một phong cách lập trình hơi cổ xưa.

Lưu ý, một lệnh gọi lại phải được cung cấp làm đối số cuối cùng để trả lại giao điểm cho mã gọi, nhưng đối số không được hiển thị.

Sau đó, tôi đã yêu cầu ChatGPT và Copilot cung cấp cho tôi một chức năng hiệu quả.

Chỉ cho tôi một hàm JavaScript hiệu quả nhận vào một số mảng có thể thay đổi và trả về giao điểm của chúng.

Trò chuyệnGPT

 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]; }

Phi công phụ đã tạo mã giống như yêu cầu đầu tiên.

ChatGPT cũng đã thêm bình luận nói rằng chức năng này sẽ không hoạt động như mong đợi đối với các đối tượng, mặc dù có thể cho rằng nó sẽ hoạt động. Vì vậy, tôi đã yêu cầu một chức năng hỗ trợ các đối tượng:

Chỉ cho tôi một hàm JavaScript hiệu quả lấy một số lượng mảng khác nhau chứa các đối tượng hoặc nguyên hàm và trả về giao điểm của chúng.

 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 xâu chuỗi các đối tượng để so sánh chúng. Có một số vấn đề với điều này:

1. Hai đối tượng có cùng biểu diễn chuỗi có thể hợp pháp là các đối tượng riêng biệt.

   
   

2. Ngay cả khi việc xâu chuỗi hợp lệ, các thứ tự thuộc tính khác nhau sẽ dẫn đến các chuỗi khác nhau và các đối tượng có thể đại diện cho cùng một thực thể.

   
   

3. JSON.stringify theo sau là so sánh chuỗi là một thao tác chậm.

   
   

Và bây giờ, bài kiểm tra thực sự! Dưới đây là kết quả điểm chuẩn cho tốc độ và bộ nhớ sử dụng mã được tạo bởi ChatGPT, Codex, Copilot và hai thư viện giao lộ nhanh nhất hiện có thông qua NPM, fastArrayIntersect và giao lộ .

Điểm chuẩn giao nhau giữa 3 mảng giống hệt nhau gồm 10.000 số nguyên, mỗi mảng và một mảng cuối cùng gồm 5.000 số nguyên với kích thước mẫu là 100. Một thử nghiệm cũng được chạy để xác nhận các hàm trả về tập hợp khi tồn tại các mục nhập trùng lặp trong các mảng nguồn.

Copilot sử dụng ít heap nhất nhưng cũng chậm nhất và tốn nhiều CPU nhất.

ChatGPT ít tốn CPU nhất nhưng cũng chậm.

Fast Array Intersect nhanh gấp 3 đến 5 lần so với Copilot và Chat GPT và nhanh hơn 20% so với Codex trong khi ít sử dụng CPU hơn.

Intersector nhanh hơn 15 lần so với ChatGPT và Copilot, nhanh hơn 4 lần so với Codex và nhanh hơn 3 lần so với Fast Array Intersect trong khi cũng có mức sử dụng CPU thấp nhất.

Tóm tắt:

1. Cả ChatGPT và Copilot đều không tạo mã hiệu quả.

   
   

2. ChatGPT đưa ra các giả định có thể không hợp lệ.

   
   

3. Copilot tạo mã không tạo tập hợp khi các đối số của nó chứa các giá trị trùng lặp.

   
   

4. Codex tạo ra hiệu suất hợp lý, mặc dù mã tối nghĩa.

   
   

5. Các lập trình viên giành chiến thắng.

   
   

Cả ChatGPT và Copilot đều có thể được cải thiện bằng cách áp dụng “trí thông minh” của chúng để hỏi người dùng một số câu hỏi làm rõ, ví dụ: bạn đang tìm kiếm tốc độ hoặc hiệu quả bộ nhớ, bạn có muốn yêu cầu ít nhất hai đối số không?

sản phẩm chéo

Để rõ ràng về mục tiêu của phần này, tôi đang tìm kiếm tất cả các kết hợp có thể có của các phần tử trong mảng, không phải tích chéo số học của vectơ.

Chỉ cho tôi một hàm JavaScript cho sản phẩm chéo Descartes.

OpenAI ChatGPT

 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}; }

OpenAI Codex

 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); }

Microsoft Copilot

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

Thật không may, ChatGPT đã cung cấp một chức năng cho tích chéo số học. Theo tôi, nó nên cung cấp cả hai loại chức năng hoặc yêu cầu làm rõ.

Sau nhiều lần thực hiện các truy vấn khác nhau, tôi đã có thể yêu cầu ChatGPT tạo cả ba truy vấn dưới đâ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; }

Phi công phụ

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

Đối với giao lộ, Codex đã cung cấp một chức năng sử dụng kiểu lập trình cũ với cách xử lý đối số khó hiểu.

Những người quen thuộc với các sản phẩm Descartes sẽ biết rằng chúng có thể bùng nổ từ cả khía cạnh sử dụng bộ nhớ và hiệu suất.

Việc triển khai ngây thơ sẽ tiêu tốn đủ RAM để lưu trữ tất cả các hoán vị và không trả về kết quả cho đến khi tất cả các hoán vị đã được tạo (có thể mất nhiều thời gian). Các chức năng ChatGPT và Copilot đều mắc phải những thiếu sót này.

Vì vậy, sau đó tôi đã yêu cầu một chức năng JavaScript hiệu quả về bộ nhớ cho sản phẩm Descartes .

Trò chuyệnGPT

 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 }) }; }

Copilot cung cấp kết quả tương tự như nó đã làm trước đây.

Tôi cho rằng phiên bản “tiết kiệm bộ nhớ” từ ChatGPT sử dụng ít RAM hơn phiên bản đầu tiên. Tuy nhiên, tôi biết nó không phải là tối ưu. Sau nhiều lần thử, tôi đã nghĩ ra một hàm JavaScript hiệu quả về bộ nhớ cho sản phẩm Cartesian bằng cách sử dụng trình tạo .

Trò chuyệnGPT

 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); }

Thành thật mà nói, tôi rất ngạc nhiên với phản hồi này từ ChatGPT. Tuy nhiên, các nỗ lực chạy mã này không thành công vì yield [item,...result] không nằm trong trình tạo, nó nằm trong một hàm lồng nhau có tên là recursion .

Tôi cũng nhận được một biến thể nhỏ khiến tôi bị mất truy vấn:

 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]]); }

Một lần nữa, ChatGPT dường như đang đưa ra một số giả định về lập luận.

Phi công phụ trả lại mã giống như trước đây. Nó hoàn toàn phớt lờ yêu cầu của tôi về máy phát điện.

Và bây giờ, bài kiểm tra thực sự! Dưới đây là kết quả điểm chuẩn cho tốc độ và bộ nhớ sử dụng mã được tạo bởi ChatGPT, Copilot và các sản phẩm Cartesian nhanh nhất, hiệu quả nhất về bộ nhớ mà tôi biết CXProduct và Lazy Cartesian Product .

Ngoài ra còn có chức năng một dòng mà có lẽ ChatGPT hoặc Copilot nên trả về (bạn sẽ thấy lý do tại sao tôi đưa vào chức năng này khi bạn xem lại kết quả).

 //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())));

Phép thử lấy tích Descartes của 4 mảng với mỗi mảng 10 phần tử. Do đó, các hàm sẽ tạo ra tích Descartes gồm 10 * 10 * 10 * 10 phần tử, tức là 10.000.

Tóm tắt:

1. ChatGPT, Codex và Copilot không có khả năng tạo mã tạo ra kết quả chính xác cho sản phẩm Cartesian.

   
   

2. ChatGPT đôi khi đưa ra các giả định có thể không hợp lệ, ví dụ: yêu cầu 2 đối số.

   
   

3. ChatGPT đã tạo mã được cho là tiết kiệm bộ nhớ hơn nhưng nó thậm chí không chạy.

   
   

4. Các lập trình viên giành chiến thắng!

Một lần nữa, ChatGPT có thể được cải thiện bằng cách áp dụng “trí thông minh” của nó để hỏi người dùng một số câu hỏi làm rõ, ví dụ: bạn đang tìm kiếm tốc độ hoặc hiệu quả bộ nhớ, bạn có muốn yêu cầu ít nhất hai đối số không? Tuy nhiên, trước đó, nó phải tạo mã chính xác!

ghi nhớ

Sau khi học được bài học về giao tuyến và tích Descartes, tôi ngay lập tức hỏi một câu hỏi tinh tế để ghi nhớ.

Chỉ cho tôi một hàm JavaScript hiệu quả giúp ghi nhớ đối tượng và đối số nguyên thủy.

OpenAI ChatGPT

 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 đã tạo mã không hợp lệ; một WeakMap phải sử dụng một đối tượng làm khóa. Mã đã được sửa đổi như sau để thử nghiệm.

 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; } }

Mở AI Codex

 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; } } }

Microsoft Copilot

 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; } } }

Codex và Copilot đã tạo ra cùng một chức năng, điều này không có gì đáng ngạc nhiên khi Copilot dựa trên Codex. Mặc dù, trong các ví dụ trước đó, chúng khác nhau.

ChatGPT, Codex và Copilot đã tạo các hàm kém hiệu quả, JSON.stringify, theo sau là so sánh chuỗi chậm và tiêu tốn bộ nhớ trên quy mô lớn.

Ngoài ra còn có các giá trị JavaScript không xâu chuỗi, ví dụ: Infinity và NaN. (Thật không may, thông số kỹ thuật JSON của JavaScript đã được xác định trước thời đại của khoa học dữ liệu và dịch vụ vi mô và người ta cho rằng Infinity và NaN ngụ ý các lỗi trong mã không hợp pháp hoặc không cần phải chuyển từ nơi này sang nơi khác .)

Vì vậy, bây giờ, để chứng minh tính hiệu quả bằng cách so sánh mã ChatGPT và Copilot với ghi nhớ nano và ghi nhớ vi mô bằng cách tạo số Fibonacci thứ 12 bằng mã này:

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

Nano-memoize là nhanh nhất và nhanh gần gấp đôi so với mã ChatGPT, Codex và Copilot. Nó cũng sử dụng ít bộ nhớ hơn. Micro-memoize đã đến gần.

Mặc dù mức sử dụng CPU cho ghi nhớ nano-memoize và ghi nhớ micro-memoize cao hơn một chút so với Code và Copilot, nhưng hiệu suất rất xứng đáng và các lập trình viên lại một lần nữa giành chiến thắng!

Tóm tắt & Giả thuyết

Mặc dù chắc chắn có giá trị trong việc sử dụng cả Copilot và ChatGPT để tạo mã, nhưng việc này nên được thực hiện cẩn thận. Cả hai sẽ không tạo ra mã tối ưu và trong một số trường hợp, nó sẽ đơn giản là không hợp lệ hoặc tệ hơn là không chính xác. Ngoài ra, khi sử dụng ChatGPT, các truy vấn phải khá cụ thể.

ChatGPT và Copilot đều có thể được cải thiện bằng cách bổ sung một tính năng sẽ đặt câu hỏi làm rõ.

ChatGPT, nếu nó thực sự thông minh, sẽ yêu cầu người dùng sử dụng Codex anh chị em của nó để tạo mã hoặc đơn giản là sử dụng Codex trong nền.

Nếu nó đang sử dụng Codex trong nền, thì tôi không chắc điều gì đang xảy ra khi tôi cung cấp cùng một mô tả chức năng cho cả hai và nhận được các kết quả khác nhau.

Mặc dù tôi không quen thuộc với hoạt động bên trong của một trong hai công cụ, ngoài việc biết chúng dựa trên mô hình ngôn ngữ, tôi cho rằng không có khả năng chúng sẽ đạt đến điểm mà chúng có thể tạo mã tối ưu mà không khắc phục được thiếu sót này:

Một hệ thống được đào tạo trên khối lượng lớn mã chưa được kiểm duyệt công khai sẽ tạo ra kết quả trung bình cho mã, nghĩa là mã có hiệu suất trung bình và mã có số lượng lỗi trung bình.

Để cung cấp kết quả chính xác nhất quán, hệ thống sẽ cần:

1. Khả năng tiêu thụ và sử dụng các đoạn dữ liệu “mẫu truy cập”, ví dụ: JSON.stringify, có thể không hiệu quả. Hệ thống có thể đạt được khả năng này bằng cách phân tích kết quả kiểm tra cũng như mã hoặc được cung cấp mã tối ưu đã biết với một số loại trọng số hoặc đơn giản thông qua việc phê bình kết quả của các chuyên gia đã biết. Thật không may, mã tối ưu thường không phải là mã phổ biến nhất hoặc được sử dụng nhiều nhất và việc chỉ cung cấp thêm các ví dụ cho các mô hình sẽ không giúp ích được gì. Trong trường hợp lý tưởng, một hệ thống thực sự thông minh sẽ có thể tạo ra các trường hợp thử nghiệm của riêng nó.

   
   

2. “Hiểu” về lập trình sâu hơn, nguyên tắc đầu tiên hơn để phân tích mã mà nó tạo ra để tìm các lỗi hiệu quả, ví dụ: thường ưu tiên phép lặp hơn đệ quy để đạt hiệu quả thời gian chạy, thường ưu tiên đệ quy cho kích thước mã và khả năng đọc.

   
   

3. Ở mức tối thiểu, một AI tạo mã nên cố gắng phân tích mã mà nó đã tạo và đánh giá tính hợp lệ về mặt cú pháp của nó. Đây phải là một cải tiến đơn giản cho ChatGPT.

   
   

4. Lý tưởng nhất là AI cũng sẽ chạy ít nhất một hoặc hai trường hợp thử nghiệm đơn giản để đảm bảo tính hợp lệ của loại. Trong khi tôi đang tạo các bài kiểm tra đơn vị, Copilot đã đề xuất một số cách hoàn thiện mã nâng cao hữu ích có thể được sử dụng cho mục đích này, ví dụ: đối số cho lệnh gọi hàm và tra cứu mảng. Tôi cho rằng ChatGPT và Codex có thể được tăng cường để làm điều đó.

Tài nguyên

• OpenAI ChatGPT: https://chat.openai.com/chat
• OpenAI Codex: https://beta.openai.com/codex-javascript-sandbox
• Phi công phụ của Microsoft: https://github.com/features/copilot
• Giao lộ: https://github.com/anywhatway/intersector
• Giao nhau mảng nhanh: https://github.com/lovasoa/fast_array_intersect
• Một lớp lót sản phẩm Descartes: https://stackoverflow.com/questions/12303989/cartesian-product-of-multiple-arrays-in-javascript
• CXSản phẩm: https://github.com/anywhereway/cxproduct
• Sản phẩm lười biếng: http://phrogz.net/lazy-cartesian-product
• Ghi nhớ Nano: https://github.com/anywhatway/nano-memoize
• Ghi nhớ vi mô: https://github.com/planttheidea/micro-memoize

Tôi hy vọng bạn đã thích bài viết này. Chúc một ngày tốt lành và làm cho ngày hôm qua ghen tị với những gì bạn học được ngày hôm nay (ở đây hoặc ở nơi khác)!

Cũng được xuất bản ở đây