FauxPilot là gì? Tại sao nên sử dụng FauxPilot?

FauxPilot là một nền tảng đề xuất mã tự động tự host nhằm giúp các nhà phát triển tạo mã nguồn một cách hiệu quả và nhanh chóng. Khác với các công cụ tương tự như GitHub Copilot, FauxPilot tập trung vào tích hợp mô hình ngôn ngữ tự nhiên để tạo ra mã code chất lượng cao mà không cần gửi dữ liệu người dùng đến máy chủ của bên thứ ba.

FauxPilot là gì?

FauxPilot là một nền tảng gợi ý mã tự lưu trữ mà hỗ trợ nhiều ngôn ngữ lập trình như Java, Python, hoặc Javascript. Brendan Dolan-Gavitt, một giáo sư trợ lý tại Trường Kỹ thuật New York University Tandon, đã tạo ra nó như một phương pháp thay thế cho GitHub Copilot.

FauxPilot dựa vào Salesforce CodeGen, một mô hình ngôn ngữ lập trình trò chuyện tự động quy mô lớn. Sử dụng FauxPilot, bạn có thể loại bỏ mã lặp lại. Thay vào đó, bạn có thể dành thời gian của mình tập trung vào logic kinh doanh mà ứng dụng của bạn cần phải giải quyết.

Tại sao nên sử dụng FauxPilot?

GitHub Copilot là một công cụ thương mại phổ biến giúp tạo mã, giúp các nhà phát triển lập trình hiệu quả hơn. Tuy nhiên, nó gửi các đoạn mã của bạn lại máy chủ của Microsoft để đề xuất mã cho bạn. Điều này gây cản trở vi phạm giấy phép và mang lại mối lo ngại về lỗ hổng có thể khai thác khi mã được chuyển đến nhiều nơi.

Fauxpilot hoạt động chỉ bằng cách sử dụng các mô hình đào tạo của Codegen và không gửi mã của bạn đến bất kỳ đâu. Do đó, nó an toàn hơn GitHub Copilot.

Ngoài ra, vì Fauxpilot là một công cụ tự lưu trữ và mã nguồn mở, bạn không cần phải trả bất kỳ khoản phí nào ngoại trừ việc chạy máy chủ Fauxpilot.

Các loại mô hình của Fauxpilot

Fauxpilot hỗ trợ tám mô hình của collagen.

Mô hình 350M-mono yêu cầu 2GB VRAM (RAM GPU) và chỉ hỗ trợ ngôn ngữ lập trình Python.
Mô hình 350M-multi yêu cầu 2GB VRAM và hỗ trợ nhiều ngôn ngữ lập trình.
Mô hình 2B-mono yêu cầu 7GB VRAM và chỉ hỗ trợ ngôn ngữ lập trình Python.
Mô hình 2B-multi yêu cầu 7GB VRAM và hỗ trợ nhiều ngôn ngữ lập trình.
Mô hình 6B-mono yêu cầu 13GB VRAM và chỉ hỗ trợ ngôn ngữ lập trình Python.
Mô hình 6B-multi yêu cầu 13GB VRAM và hỗ trợ nhiều ngôn ngữ lập trình.
Mô hình 16B-mono yêu cầu 32GB VRAM và chỉ hỗ trợ ngôn ngữ lập trình Python.
Mô hình 16GB-multi yêu cầu 32GB VRAM và hỗ trợ nhiều ngôn ngữ lập trình.

Mô hình càng cao cấp, nó có thể tạo ra mã chính xác hơn.

Cách triển khai Fauxpilot

Bạn có thể triển khai Fauxpilot từ đầu bằng cách sử dụng máy chủ của bạn. Tuy nhiên, việc triển khai không phải là điều dễ dàng và đòi hỏi một khoản tiền đáng kể ngay từ đầu vì bạn phải chuẩn bị một máy chủ mạnh mẽ.

Với Vultr Fauxpilot, bạn có thể bắt đầu sử dụng Fauxpilot ngay lập tức chỉ với vài cú nhấp chuột để tạo ra các máy chủ backend của Fauxpilot. Ngoài ra, chúng tôi cung cấp gói dịch vụ trả tiền theo sử dụng, cho phép bạn tối ưu hóa chi phí chạy các máy chủ Fauxpilot.

Vultr Fauxpilot cung cấp bốn mô hình ngôn ngữ được tạo mã hỗ trợ nhiều ngôn ngữ lập trình.

Fauxpilot (350M), yêu cầu máy chủ của bạn có 2GB VRAM
Fauxpilot (2B), yêu cầu máy chủ của bạn có 7GB VRAM
Fauxpilot (6B), yêu cầu máy chủ của bạn có 13GB VRAM
Fauxpilot (16B), yêu cầu máy chủ của bạn có 32GB VRAM

Để hiểu cách Fauxpilot hoạt động, hãy triển khai một máy chủ Fauxpilot (350M) và thử tương tác với nó.

Triển khai Fauxpilot Server (350M)

Từ trang "Products" của Vultr, nhấp vào nút "+" ở phía bên phải màn hình và chọn "Deploy new server".

Chọn tùy chọn "Cloud GPU" trong phần "Chọn Máy chủ".
Chọn "Virtual Desktop NVIDIA A16" trong phần GPU.
Chọn một vị trí máy chủ gần với bạn. Ví dụ, bạn có thể chọn "Tokyo" cho vị trí của máy chủ.
Chọn "Fauxpilot (350M)" trong phần Hình ảnh Máy chủ.
Chọn kích thước máy chủ với 2GB RAM GPU vì mô hình Fauxpilot (350) yêu cầu máy chủ của bạn có ít nhất 2GB VRAM.
Chọn khóa SSH của máy cục bộ của bạn để sau này bạn có thể truy cập vào máy chủ Fauxpilot
Thiết lập tên máy chủ và nhãn cho máy chủ Fauxpilot của bạn
Nhấp vào Triển khai

Bạn nên có thể truy cập vào máy chủ trong vài phút. Có thể mất khoảng 30 phút cho máy chủ backend Fauxpilot được chuẩn bị sẵn.

Thêm IP vào Fauxpilot Whitelist

Để truy cập dịch vụ backend của Fauxpilot từ máy cục bộ của bạn, hãy thêm địa chỉ IP của máy cục bộ của bạn vào máy chủ Fauxpilot.

Truy cập trang tổng quan máy chủ Fauxpilot để tìm hiểu về địa chỉ IP của máy chủ, tên người dùng mặc định và mật khẩu của nó.

Sau đó, mở terminal và chạy lệnh sau (thay thế your_fauxpilot_server_ip bằng giá trị của bạn):

ssh root@your_fauxpilot_server_ip

Bây giờ bạn nên có thể truy cập vào máy chủ. Thêm địa chỉ IP của máy cục bộ của bạn vào tệp /home/fauxpilot/whitelist.txt. Để làm điều đó, chạy các lệnh sau:

nano /home/fauxpilot/whitelist.txt // Thêm IP của bạn vào dòng mới
regen_whitelist

Bây giờ bạn đã thêm địa chỉ IP của mình vào danh sách trắng của Fauxpilot. Bạn có thể tương tác với máy chủ Fauxpilot từ máy cục bộ của bạn.

Tương tác với Fauxpilot từ máy local

Để tương tác với Fauxpilot từ máy cục bộ của bạn, bạn cần chuẩn bị các điều kiện tiên quyết sau:

Cài đặt Visual Studio Code để bạn có thể xem Fauxpilot đề xuất mã cho bạn khi bạn đang viết mã.
Cài đặt ngôn ngữ lập trình Python phiên bản 3.7 trở lên để sử dụng API OpenAI.
Cài đặt virtualenv để tạo môi trường ảo và sử dụng API OpenAI để tương tác với máy chủ Fauxpilot.
Cài đặt công cụ dòng lệnh curl để thực hiện các yêu cầu HTTP đến máy chủ Fauxpilot.

Tương tác với Fauxpilot bằng OpenAI API

Mở một cửa sổ terminal mới và chạy lệnh sau để tạo một thư mục mới có tên là Projects/openai-fauxpilot để viết mã tương tác với Fauxpilot.

mkdir ~/Projects/openai-fauxpilot -p
cd ~/Projects/openai-fauxpilot

Sau đó, tạo một môi trường ảo Python mới bằng cách chạy mã sau:

virtualenv venv
source venv/bin/activate

Tạo một tập tin Python mới có tên là main.py và sao chép mã sau vào đó:

if __name__ == '__main__':
    import openai
    openai.api_key='1'
    openai.api_base='http://your_fauxpilot_server_ip/v1'
    result = openai.Completion.create(model='fastertransformer', prompt='def add (int a, int b)', max_tokens=16, temperature=0.1, stop=["\n\n"])
    print(result)

Mã trên dùng để gửi yêu cầu API đến máy chủ Fauxpilot, với prompt là “def add (int a, int b)” và mô hình là “fastertransformer”.

Thay thế “your_fauxpilot_server_ip” bằng giá trị của bạn. Thực thi lệnh sau để chạy mã:

venv/bin/python3.* main.py // * là phiên bản của ngôn ngữ lập trình Python của bạn

Bạn nên thấy một kết quả tương tự như sau:

{
"id": "cmpl-XkX0CyWAOKvxgL5ttq2FnNHSOAFkG",
"model": "codegen",
"object": "text_completion",
"created": 1686297110,
"choices": [
{
"text": " {\n return a + b;\n }",
"index": 0,
"finish_reason": "stop",
"logprobs": null
}
],
"usage": {
"completion_tokens": 12,
"prompt_tokens": 9,
"total_tokens": 21
}
}

Bạn có thể tương tác với máy chủ Fauxpilot từ máy cục bộ của mình bằng cách sử dụng OpenAI API. Hãy xem cách bạn có thể tương tác với máy chủ Fauxpilot bằng cách sử dụng API RESTful của nó.

Tướng tác với Fauxpilot bằng API RESTful

Có rất nhiều công cụ để thực hiện các yêu cầu đến các API RESTful, như Postman, Insomnia, hoặc curl. Hãy sử dụng lệnh dòng lệnh curl.

Chạy lệnh sau để gửi một yêu cầu API đến máy chủ Fauxpilot để nhận mã đề xuất với dữ liệu đầu vào là “def add (int a, int b)”.

curl -X POST -H 'Content-Type: application/json' -d '{
"prompt": "def add (int a, int b)",
"max_tokens": 256,
"temperature": 0.1,
"top_p":1,
"stop": [
"\n\n"
],
"model":"fastertransformer"
}' http://your_fauxpilot_server_ip/v1/engines/codegen/completions

Bạn nên thấy phản hồi dưới đây:

{"id": "cmpl-4mE4IP1CFMJVp3ppDhZYWsSzQtHgC", "model": "codegen", "object": "text_completion", "created": 1686297974, "choices": [{"text": " {\n return a
+ b;\n}", "index": 0, "finish_reason": "stop", "logprobs": null}], "usage": {"completion_tokens": 12, "prompt_tokens": 9, "total_tokens": 21}}

Bây giờ bạn có thể tương tác với máy chủ Fauxpilot bằng cách sử dụng API RESTful của nó. Hãy tiếp tục để xem làm cách nào bạn có thể nhận được mã đề xuất trong Visual Studio Code với sự giúp đỡ của Fauxpilot.

Có mã đề xuất trong Visual Studio Code với sự trợ giúp của Fauxpilot

Để tích hợp Fauxpilot với Visual Studio Code, trước tiên bạn phải cài đặt tiện ích mở rộng GitHub Copilot.

Mở Visual Studio Code (VS Code) của bạn và chọn biểu tượng “Extensions” trên bảng điều khiển bên trái của VS Code của bạn.
Tìm kiếm “GitHub Copilot” trong ô tìm kiếm.
Nhấp vào nút “Install” để cài đặt GitHub Copilot.

Sau khi cài đặt GitHub Copilot, bạn cần thêm cấu hình GitHub Copilot với các giá trị máy chủ Fauxpilot vào tệp cài đặt người dùng của Visual Studio Code.

Từ VS Code của bạn, nhấn “Ctrl+Shift+P”.
Tìm kiếm “Open User Settings (JSON)” và nhấp vào.

Thêm nội dung sau vào tệp “settings.json”.

"github.copilot.enable": {
    "*": true,
    "plaintext": true,
    "markdown": true,
    "scminput": true
},
"github.copilot.inlineSuggest.enable": true,
"github.copilot.editor.enableAutoCompletions": true,
"github.copilot.advanced": {
    "model":"fastertransformer",
    "debug.overrideEngine": "codegen",
    "debug.testOverrideProxyUrl": "http://your_fauxpilot_server_ip",
    "debug.overrideProxyUrl": "http://your_fauxpilot_server_ip"
},
"editor.inlineSuggest.enabled": true

Thay thế “your_fauxpilot_server_ip” bằng giá trị của bạn.

Bây giờ mọi thứ đã sẵn sàng, hãy viết mã trong Visual Studio Code.

Tạo một thư mục mới có tên là fauxpilot-code-suggestion-vscode bên trong thư mục ~/Projects.

mkdir ~/Projects/fauxpilot-code-suggestion-vscode
cd ~/Projects/fauxpilot-code-suggestion-vscode

Mở thư mục fauxpilot-code-suggestion-vscode bằng VS Code. Tạo một tệp mới có tên là main.py.

Mở tệp main.py trong VS Code. Thử viết mã sau vào tệp.

# def add (int a, int b):

Sau đó, nhấn phím Enter để chuyển đến dòng mới. Chú ý mã được tạo ra cho hàm def add (int a, int b).

# return a + b

Bạn đã tích hợp Fauxpilot thành công với Visual Studio Code. Hãy thỏa sức tương tác với nó.

Việc sử dụng Fauxpilot sẽ giúp bạn tiết kiệm được một lượng lớn thời gian vì bạn sẽ không phải viết mã lặp đi lặp lại. Thay vào đó, bạn có thể tập trung vào việc viết mã logic kinh doanh ý nghĩa để hoàn thành các nhiệm vụ của mình.

FauxPilot là gì? Tại sao nên sử dụng FauxPilot?