Chạy mô hình ngôn ngữ lớn như Llama 3 trên Apple Silicon với MLX Framework của Apple. Người dùng Mac, việc tận dụng MLX Framework của Apple có thể nâng cao đáng kể hiệu quả đào tạo và triển khai các mô hình này trên silicon của Apple. Hướng dẫn này cung cấp hướng dẫn chi tiết về các bước và cân nhắc cần thiết để chạy Llama 3 hoặc bất kỳ LLM nào khác bằng MLX Framework.
Yêu cầu phần cứng:
– Bạn cần ít nhất 8 GB VRAM để thực hiện chính xác hướng dẫn này.
– Sử dụng chip dòng M (chip Apple)
– Sử dụng Python gốc >= 3.9
– macOS >= 13.5 nên sử dụng macOS 14 (Sonoma)
Thử nghiệm với LLM trên máy tính của bạn. Giao diện trò chuyện và API có thể lập trình https://lmstudio.ai/download?os=mac
Để sử dụng MLX với LibreChat https://www.librechat.ai/blog/2024-05-01_mlx
Framework MLX
Lấy cảm hứng từ PyTorch, Jax và ArrayFire, MLX là một khuôn khổ đào tạo và phục vụ mô hình được thiết kế riêng cho silicon của Apple bởi Apple Machine Learning Research. Nó hỗ trợ một loạt các tác vụ học máy, bao gồm tạo văn bản quy mô lớn, tạo hình ảnh và nhận dạng giọng nói. Khuôn khổ này được tích hợp với Hugging Face, cho phép tải và phục vụ mô hình liền mạch.

Các tính năng chính
– API quen thuộc : MLX cung cấp API Python bám sát NumPy, cùng với các API C++, C và Swift có đầy đủ tính năng tương tự như API Python.
– Chuyển đổi hàm có thể cấu hình : Hỗ trợ tính toán phân biệt tự động, vectơ hóa và tối ưu hóa đồ thị tính toán.
– Tính toán Lazy : Tính toán MLX linh động, nghĩa là các mảng chỉ được thực hiện khi cần thiết, giúp tăng hiệu quả.
– Xây dựng đồ thị động : Đồ thị tính toán được xây dựng theo kiểu động, tránh biên dịch chậm và đơn giản hóa việc gỡ lỗi.
– Hỗ trợ nhiều thiết bị : Các hoạt động có thể được thực hiện trên bất kỳ thiết bị được hỗ trợ nào (CPU hoặc GPU) mà không cần truyền dữ liệu.
– Mô hình bộ nhớ hợp nhất : MLX sử dụng mô hình bộ nhớ hợp nhất, cho phép CPU và GPU chia sẻ cùng một nhóm bộ nhớ, loại bỏ nhu cầu truyền dữ liệu giữa chúng và do đó nâng cao hiệu quả và hiệu suất.
Hạn chế
– Dành riêng cho Apple Silicon : MLX được thiết kế dành riêng cho Apple silicon, giới hạn việc sử dụng cho phần cứng tương thích.
– Hỗ trợ cộng đồng hạn chế : Là một khuôn khổ tương đối mới, MLX có cộng đồng nhỏ hơn và ít tài nguyên hơn so với các khuôn khổ đã được thành lập lâu đời hơn.
– Thách thức về tối ưu hóa : Mặc dù khuôn khổ này hiệu quả, nhưng để đạt được hiệu suất tối ưu có thể cần phải điều chỉnh đáng kể và hiểu biết sâu sắc về cả phần cứng và khuôn khổ.
Cài đặt
Tạo một môi trường ảo (khuyến nghị)
Đầu tiên, hãy tạo một môi trường ảo cho dự án của bạn. Bước này là tùy chọn nếu bạn đã thiết lập một môi trường ảo.
1. Điều hướng đến thư mục dự án của bạn và tạo môi trường ảo:
python3 -m venv env_name
2. Kích hoạt môi trường:
source env_name\\bin\\activate
Cài đặt MLX-LM
MLX là một gói độc lập và có một gói phụ gọi là MLX-LM tích hợp Hugging Face cho các Mô hình ngôn ngữ lớn.
1. Cài đặt MLX-LM
pip3 install mlx-lm
Tùy chọn: Cài đặt PyTorch (phiên bản nightly) — ẩn cảnh báo:
pip3 install –pre torch –index-url <https://download.pytorch.org/whl/nightly/cpu>
Tải xuống mô hình
1. Tải xuống mô hình từ kho lưu trữ Hugging Face Hub
Nếu bạn muốn sử dụng mô hình lượng tử (dành cho máy tính có RAM dưới 16):
python3 -m mlx_lm.convert –hf-path meta-llama/Meta-Llama-3-8B-Instruct -q
Thao tác này sẽ lưu mô hình vào thư mục dự án của bạn tại mlx_model.
Nếu không thì:
python3 -m mlx_lm.generate –model meta-llama/Meta-Llama-3-8B-Instruct
2. Kiểm tra mô hình
python3 -m mlx_lm.generate –model model_path –prompt “xin chào”
Thực hiện
Để sử dụng mô hình đã tải xuống trong ứng dụng của bạn, bạn có thể sử dụng triển khai máy chủ do mlx-lm cung cấp. Điều này sẽ khởi động máy chủ cục bộ giống OpenAI trên http://localhost:8080 .
Điểm cuối: http://localhost:8080/v1/chat/completions
Các trường yêu cầu:
– messages tin nhắn : Mảng các đối tượng tin nhắn có vai trò (ví dụ: người dùng, trợ lý) và nội dung (văn bản tin nhắn).
– role_mapping : Từ điển tùy chọn để tùy chỉnh tiền tố vai trò trong lời nhắc.
– stop dừng : Chuỗi mã thông báo tùy chọn mà quá trình tạo sẽ dừng lại.
– max_tokens : Số nguyên tùy chọn cho số lượng mã thông báo tối đa cần tạo (mặc định: 100).
– stream : Boolean tùy chọn để chỉ ra liệu phản hồi có nên được truyền phát hay không (mặc định: false).
– temperature nhiệt độ : Tùy chọn float cho nhiệt độ lấy mẫu (mặc định: 1.0).
– top_p : Giá trị float tùy chọn cho tham số lấy mẫu hạt nhân (mặc định: 1.0).
– repetition_penalty : Tùy chọn float để áp dụng hình phạt cho các mã thông báo lặp lại (mặc định: 1.0).
– repetition_context_size : Kích thước tùy chọn của cửa sổ ngữ cảnh cho hình phạt lặp lại (mặc định: 20).
– logit_bias : Tùy chọn ánh xạ ID mã thông báo từ điển với giá trị độ lệch của chúng.
Khởi động máy chủ
mlx_lm.server –model model_path
Trò chuyện bằng Python
Sau khi máy chủ chạy, bạn có thể gửi yêu cầu POST đến máy chủ. Sau đây là ví dụ về chatbot được tạo bằng Python:
import requests
import json
from typing import List, Dict
def get_response(
server_url: str,
messages: List[Dict[str, str]],
temperature: float = 0.7,
top_p: float = 0.9,
max_tokens: int = 4096,
stream: bool = True,
) -> str:
headers = {“Content-Type”: “application/json”}
data = {
“messages”: messages,
“temperature”: temperature,
“top_p”: top_p,
“max_tokens”: max_tokens,
“stream”: stream,
}
response = requests.post(
f”{server_url}/v1/chat/completions”,
headers=headers,
data=json.dumps(data),
stream=stream,
)
response.raise_for_status()
if stream:
content = “”
for line in response.iter_lines():
if line:
decoded_line = line.decode(“utf-8”).lstrip(“data: “)
try:
json_line = json.loads(decoded_line)
if “choices” in json_line and len(json_line[“choices”]) > 0:
delta = json_line[“choices”][0].get(“delta”, {})
content_piece = delta.get(“content”, “”)
content += content_piece
print(content_piece, end=“”, flush=True)
except json.JSONDecodeError:
continue
print()
return content
else:
result = response.json()
if “choices” in result and len(result[“choices”]) > 0:
return result[“choices”][0][“message”][“content”]else:
return “”
def chatbot(
server_url: str,
system_instructions: str = “”,
temperature: float = 0.7,
top_p: float = 0.9,
max_tokens: int = 4096,
stream: bool = True,
):
messages = [{“role”: “system”, “content”: system_instructions}]while True:
prompt = input(“User: “)
if prompt.lower() in [“exit”, “quit”]:
break
messages.append({“role”: “user”, “content”: prompt})
print(“Assistant: “, end=“”)
response = get_response(
server_url, messages, temperature, top_p, max_tokens, stream
)
messages.append({“role”: “assistant”, “content”: response})
if __name__ == “__main__”:
server_url = “http://localhost:8080”
chatbot(server_url=server_url)
Kết luận
framework MLX cung cấp giải pháp mạnh mẽ và hiệu quả để chạy các mô hình ngôn ngữ lớn trên silicon của Apple. Thiết kế thân thiện với người dùng, lấy cảm hứng từ các framework như NumPy và PyTorch, giúp các nhà nghiên cứu và nhà phát triển dễ tiếp cận. Bất chấp những hạn chế của nó, khả năng đào tạo và suy luận mô hình quy mô lớn của MLX khiến nó trở thành một công cụ có giá trị trong bối cảnh học máy.
Tài liệu tham khảo
https://github.com/ml-explore/mlx-examples/blob/main/llms/mlx_lm
https://github.com/ml-explore/mlx-examples/blob/main/llms/mlx_lm/SERVER.md
https://github.com/ml-explore/mlx?tab=readme-ov-file
https://huggingface.co/docs/hub/en/mlx
https://medium.com/@manuelescobar-dev/running-large-language-models-llama-3-on-apple-silicon-with-apples-mlx-framework-4f4ee6e15f31
Khung Nexa suy luận cục bộ trên thiết bị
Nexa SDK là một khuôn khổ suy luận cục bộ trên thiết bị cho các mô hình ONNX và GGML, hỗ trợ tạo văn bản, tạo hình ảnh, mô hình ngôn ngữ thị giác (VLM), mô hình ngôn ngữ âm thanh, khả năng chuyển giọng nói thành văn bản (ASR) và chuyển văn bản thành giọng nói (TTS). Có thể cài đặt thông qua Python Package hoặc Executable Installer.
Running Local LLMs and VLMs on the Raspberry Pi
https://github.com/NexaAI/nexa-sdk
Thiết lập máy chủ LLM của riêng bạn bằng MLX Server, Chainlit và Llama 3.1
Sau đây là bản demo về máy chủ LLM cục bộ chạy thành công trên MacBook Pro M2 2022 với RAM 16 GB và Python 3.12.4. Để chạy MLX Server trơn tru, thiết bị của bạn phải đáp ứng các yêu cầu sau:
Chip silicon của Apple (dòng M)
Phiên bản Python gốc >= 3.8
Phiên bản macOS >= 13.3 (Ventura)
https://github.com/flaviodelgrosso/mlx-chainlit-llama3
https://anakin.ai/blog/how-to-run-llama-3-3-70b-locally-mac-windows-linux/
Cài đặt
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
Máy chủ đang chạy
python -m mlx_lm.server –model mlx-community/Meta-Llama-3.1-8B-Instruct-4bit –log-level DEBUG
Thao tác này sẽ khởi động máy chủ MLX và sẽ tải xuống LLM nếu nó chưa được tải xuống từ Hugging Face. Kiểm tra liên kết này để biết thêm thông tin về MLX.
Ứng dụng đang chạy
chainlit run app.py
Thao tác này sẽ khởi động ứng dụng Chainlit.
llamafile cho phép bạn phân phối và chạy LLM bằng một tệp duy nhất
Cách dễ nhất để tự mình thử là tải xuống llamafile mẫu của chúng tôi cho mô hình LLaVA (giấy phép: LLaMA 2 , OpenAI ). LLaVA là một LLM mới có thể làm nhiều việc hơn là chỉ trò chuyện; bạn cũng có thể tải hình ảnh lên và hỏi nó các câu hỏi về chúng. Với llamafile, tất cả những điều này đều diễn ra cục bộ; không có dữ liệu nào rời khỏi máy tính của bạn.
Tải xuống llava-v1.5-7b-q4.llamafile (4,29 GB).
Mở terminal của máy tính.
Nếu bạn đang sử dụng macOS, Linux hoặc BSD, bạn sẽ cần cấp quyền cho máy tính của mình để thực thi tệp mới này. (Bạn chỉ cần thực hiện việc này một lần.)
chmod +x llava-v1.5-7b-q4.llamafile
Nếu bạn sử dụng Windows, hãy đổi tên tệp bằng cách thêm “.exe” vào cuối.
Chạy llamafile. Ví dụ:
./llava-v1.5-7b-q4.llamafile
Trình duyệt của bạn sẽ tự động mở và hiển thị giao diện trò chuyện. (Nếu không, chỉ cần mở trình duyệt và trỏ tới http://localhost:8080 )
Khi bạn trò chuyện xong, hãy quay lại thiết bị đầu cuối và nhấn Control-C để tắt llamafile.
chạy Ollama và thư viện Swift SwiftOpenAI
Tôi không ngờ việc có thể chạy các mô hình mã nguồn mở cục bộ trong ứng dụng Mac OS lại dễ dàng đến vậy, đây sẽ là hướng dẫn ngắn về cách thực hiện việc này bằng Ollama và thư viện Swift SwiftOpenAI.
Năm nay, Ollama đã xây dựng khả năng tương thích cho OpenAI Chat Completions API . Điều này cho phép bạn sử dụng các mô hình cục bộ với cùng API mà bạn sẽ sử dụng để tương tác với các mô hình OpenAI.
Bạn có thể sử dụng các mô hình mạnh mẽ nhưllama3hoặcMistraltrong ứng dụng của mình bằng cách làm theo các bước đơn giản sau!
Bước 1:
Để sử dụngOllama,trước tiên bạn cần tải xuống từ trang web chính thức của họtại đây.
Bước 2:
Bây giờ bạn cần tải xuống mô hình bạn muốn sử dụng. Ví dụ, điều này sẽ tải xuống Llama 3:ollama pull llama3
Bước 3:
Bây giờ bạn có thể sử dụng terminal của mình nếu bạn muốn tương tác với LLM. Bạn chỉ cần làm như sau:ollama run llama3
Bước 4:
Nếu bạn muốn sử dụng điều này trong một ứng dụng, bạn có thể sử dụngSwiftOpenAItrong máy khách của mình. Tất cả những gì bạn cần làm là thêm gói dưới dạng phụ thuộc vào dự án của bạn và sau đó…
import SwiftOpenAI
let service = OpenAIServiceFactory .service(baseURL: "http://localhost:11434" )
Sau đó, bạn có thể sử dụng API hoàn thành như sau:
cho lời nhắc = "Kể cho tôi một câu chuyện cười"
let prompt = "Tell me a joke"
let parameters = ChatCompletionParameters(messages: [.init(role: .user, content: .text(prompt))], model: .custom("llama3"))
let chatCompletionObject = service.startStreamedChat(parameters: parameters)
Đó là tất cả những gì bạn cần để chạy các mô hình cục bộ bên trong ứng dụng của riêng bạn! Để biết bản demo về cách sử dụng nó trong iOS, hãy kiểm tradự án ví dụ trong kho lưu trữ này.
https://www.llama.com/docs/llama-everywhere/running-meta-llama-on-mac/
https://github.com/huggingface/transformers.js-examples/tree/main/llama-3.2-webgpu
Chạy cục bộ LM Studio và Anything LLM Desktop
LM Studio: Công cụ đa năng này cho phép bạn khám phá và chạy các LLM khác nhau cục bộ trên máy của mình.
Anything LLM: Một ứng dụng máy tính để bàn giúp nâng cao khả năng của LM Studio, cung cấp một bộ toàn diện để tương tác với các tài liệu, trang web, v.v.
Cả hai công cụ LM Studio và Anything LLM đều là mã nguồn mở, cho phép bạn tự do sử dụng và thậm chí đóng góp vào sự phát triển của chúng.
Thiết lập LM Studio
LM Studio cực kỳ dễ để bắt đầu: Chỉ cần cài đặt, tải xuống một mô hình và chạy nó. Có rất nhiều hướng dẫn trực tuyến. Ngoài ra, nó sử dụng llama.cpp, về cơ bản có nghĩa là bạn phải sử dụng các mô hình có định dạng tệp .gguf. Đây là định dạng phổ biến nhất hiện nay và có hỗ trợ rất tốt. Đối với mô hình nào để chạy, nó phụ thuộc vào bộ nhớ GPU của bạn. Về cơ bản:
4GB VRAM -> Chạy Gemma 2B, Phi 3 Mini ở Q8 hoặc Llama 3 8B/ Gemma 9B ở Q4
8GB VRAM -> Chạy Llama 3 8B/ Gemma 9B ở Q8
16GB VRAM -> Chạy Gemma 27B/ Command R 35B ở Q4
24GB VRAM -> Chạy Gemma 27B ở Q6 hoặc Llama 3 70B ở Q2 (Số lượng thấp, không khuyến khích để mã hóa)
Lượng tử hóa Quantizations (Q2, Q4, v.v.) giống như phiên bản nén của một mô hình. Q8 có chất lượng rất cao (bạn sẽ không nhận thấy nhiều sự khác biệt). Q6 cũng khá cao, gần bằng Q8. Q4 ở mức trung bình nhưng vẫn khá tốt. Q2 ổn đối với các mô hình lớn cho các tác vụ không phải mã hóa nhưng nó khá tàn bạo và làm giảm trí thông minh của chúng. (Đối với các mô hình nhỏ, chúng bị ‘nén’ quá nhiều và mất đi rất nhiều trí thông minh)
Đối với vector hóa, LM studio cung cấp một số hỗ trợ cho việc nhúng mô hình: họ đề xuất Nomic Embed v1.5, nhẹ và khá tốt. Thêm vào đó, bạn có thể dễ dàng sử dụng vì nó cung cấp API cục bộ giống OpenAI.
Bước 1: Tải xuống và cài đặt
Đầu tiên, hãy tải xuống LM Studio cho hệ điều hành của bạn. Sau khi quá trình tải xuống hoàn tất, hãy cài đặt nó theo các bước thông thường.
Bước 2: Khám phá các mô hình
Sau khi cài đặt, hãy mở LM Studio. Bạn sẽ đến một trang khám phá giới thiệu các mô hình phổ biến khác nhau. Đối với hướng dẫn này, hãy tải xuống mô hình Mistal 7B Instruct, một phiên bản lượng tử 4 bit.
Việc tải xuống các mô hình có thể tốn thời gian, vì vậy hãy bắt đầu quá trình này sớm. Sau khi tải xuống, bạn có thể tìm thấy các mô hình của mình trong tab “Mô hình”.
Bước 3: Chạy mô hình
Để kiểm tra mô hình của bạn, hãy chuyển đến biểu tượng bong bóng trò chuyện và chọn mô hình bạn đã tải xuống. Bạn có thể đặt trước lời nhắc hệ thống và bật tính năng giảm tải GPU nếu máy của bạn hỗ trợ nó.
Tăng cường với Anything LLM
Nếu bạn biết LLM nào bạn muốn và tất cả các tùy chọn liên quan đến việc điều chỉnh hiệu suất mô hình, như chuyển tải GPU và các tùy chọn tương tự, thì bạn có thể sử dụng LMStudio + AnythingLLM cùng lúc. AnythingLLM dành cho RAG, Agents và tooling, và LMStudio chỉ để chạy mô hình bạn muốn với các thiết lập đã xác định của bạn. Nó tiên tiến hơn một bước so với AnythingLLM độc lập.
AnythingLLM hoạt động như thế nào
Một không gian làm việc được tạo. LLM chỉ có thể “xem” các tài liệu được nhúng trong không gian làm việc này. Nếu một tài liệu không được nhúng thì LLM không có cách nào có thể xem hoặc truy cập nội dung của tài liệu đó.
Bạn tải lên một tài liệu, điều này giúp bạn có thể “Chuyển vào không gian làm việc” hoặc “nhúng” tài liệu. Tải lên sẽ lấy tài liệu của bạn và biến nó thành văn bản – thế là xong.
Bạn “Di chuyển tài liệu đến không gian làm việc”. Thao tác này sẽ lấy văn bản từ bước 2 và chia thành các phần dễ tiêu hóa hơn. Sau đó, các khối này sẽ được gửi đến mô hình nhúng của bạn và chuyển thành một danh sách các số, được gọi là chuỗi số này được lưu. vào cơ sở dữ liệu vectơ của bạn và về cơ bản là cách RAG hoạt động. Không có gì đảm bảo rằng văn bản có liên quan sẽ ở cùng nhau trong bước này!
Bạn nhập câu hỏi vào hộp trò chuyện và nhấn gửi.
Câu hỏi của bạn sau đó sẽ được nhúng giống như văn bản tài liệu của bạn.
Sau đó, cơ sở dữ liệu vectơ sẽ tính toán vectơ đoạn “gần nhất”. AnythingLLM lọc bất kỳ đoạn văn bản “có điểm thấp” nào (bạn có thể sửa đổi phần này). Mỗi vectơ có văn bản gốc được lấy từ đó. Đây không phải là một ngữ nghĩa thuần túy. quá trình để cơ sở dữ liệu vectơ không “hiểu ý bạn”. Đây là một quá trình toán học sử dụng công thức “Khoảng cách Cosine”. Tuy nhiên, đây là nơi mô hình nhúng được sử dụng và các cài đặt AnythingLLM khác có thể tạo ra sự khác biệt lớn nhất. phần tiếp theo.
Bất kỳ đoạn nào được coi là hợp lệ sẽ được chuyển đến LLM dưới dạng văn bản gốc. Những văn bản đó sau đó sẽ được thêm vào LLM là “Thông báo hệ thống” của nó. Ngữ cảnh này được chèn bên dưới lời nhắc hệ thống của bạn cho không gian làm việc đó.
LLM sử dụng lời nhắc hệ thống + ngữ cảnh, truy vấn và lịch sử của bạn để trả lời câu hỏi một cách tốt nhất có thể.
Bước 1: Tải xuống và cài đặt
Tiếp theo, tải xuống Anything LLM cho hệ điều hành của bạn từ trang web chính thức. Cài đặt nó như bạn làm với bất kỳ phần mềm nào khác.
Bước 2: Cấu hình ban đầu
Khi bạn mở Anything LLM lần đầu tiên, bạn sẽ được nhắc cấu hình phiên bản. Chọn LM Studio làm LLM của bạn và nhập URL cơ sở cho máy chủ cục bộ của LM Studio.
Để tìm URL này, hãy chuyển đến tab Máy chủ cục bộ trong LM Studio. Khởi động máy chủ và sao chép URL được cung cấp.
Bước 3: Thêm tài liệu và trang web
Với Anything LLM, bạn có thể tương tác với nhiều tài liệu và trang web khác nhau. Tải lên tệp PDF, tài liệu văn bản hoặc quét trang web trực tiếp từ giao diện.
Cấu hình nâng cao
Nhúng vào cơ sở dữ liệu vector: Bất cứ điều gì LLM bao gồm mô hình nhúng và cơ sở dữ liệu vector của riêng nó, đảm bảo tất cả dữ liệu của bạn vẫn ở chế độ cục bộ và riêng tư. Trong quá trình thiết lập, bạn có thể chọn sử dụng các tính năng tích hợp sẵn này hoặc kết nối với các dịch vụ bên ngoài.
Không gian làm việc tùy chỉnh: Tạo không gian làm việc tùy chỉnh cho các dự án khác nhau. Ví dụ: tạo một không gian làm việc có tên là “Dự án X” và tải lên tất cả các tài liệu và dữ liệu web có liên quan. LLM sẽ sử dụng ngữ cảnh này để đưa ra câu trả lời chính xác hơn.
Ứng dụng trong thế giới thực: Ví dụ: Quét một trang web
Để thu thập thông tin từ một trang web cụ thể, hãy sử dụng tính năng cạo trong Anything LLM. Sau khi cạo, nhúng dữ liệu vào mô hình. Bây giờ, khi bạn đặt câu hỏi LLM liên quan đến nội dung của trang web đó, nó sẽ cung cấp các câu trả lời sáng suốt.
Cân nhắc về hiệu suất
Yêu cầu phần cứng
Mặc dù hướng dẫn này trình bày các mô hình đang chạy trên CPU, nhưng việc có GPU sẽ cải thiện đáng kể hiệu suất. Ví dụ, các mô hình như Llama 2 sẽ chạy nhanh hơn nhiều trên các máy được trang bị GPU.
Lựa chọn mô hình
Việc lựa chọn mô hình ảnh hưởng đến hiệu suất. Các mô hình nhỏ hơn như phiên bản 7 tỷ tham số của Llama 2 dễ quản lý hơn trên phần cứng kém mạnh mẽ hơn nhưng có thể cung cấp các phản hồi ít phức tạp hơn so với các mô hình lớn hơn.
https://pyimagesearch.com/2024/06/24/integrating-local-llm-frameworks-a-deep-dive-into-lm-studio-and-anythingllm/
Thêm tiện ích cho lập trình
Vô Extention của Visual Studio code thêm Cline (prev. Claude). Thêm model code, rồi xong.
Những Model
DeepSeek của Trung Quốc đã phát hành mô hình mã nguồn mở DeepSeek-v3, mô hình này đã vượt trội hơn tất cả các tên tuổi lớn như Claude3.5 Sonnet, GPT-4o, Qwen2.5 Coder và các tên tuổi khác. có kích thước ấn tượng là 685 tỷ tham số, 60 token/giây. Nếu bạn chỉ muốn trò chuyện, mô hình được lưu trữ miễn phí trên kênh trò chuyện chính thức của deepseek:https://www.deepseek.com/
Jan
Jan là một ứng dụng điện tử có các tính năng tương tự như LM Studio. Nó làm cho AI trở nên mở và dễ tiếp cận với tất cả mọi người bằng cách biến máy móc của người tiêu dùng thành máy tính AI. Vì đây là một dự án nguồn mở, hỗ trợ các kiến trúc phổ quát GPUs (fast), Apple M-series (fast), Apple Intel, Linux Debian và Windows x64. Sau đây là phân tích các tính năng chính của Jan.
Cục bộ : Bạn có thể chạy các mô hình AI ưa thích trên các thiết bị mà không cần kết nối chúng với Internet.
Các mô hình sẵn sàng sử dụng : Sau khi tải xuống Jan, bạn sẽ nhận được một bộ các mô hình đã cài đặt để bắt đầu. Ngoài ra còn có khả năng tìm kiếm các mô hình cụ thể.
Nhập mô hình : Hỗ trợ nhập mô hình từ các nguồn như Hugging Face.
Miễn phí, đa nền tảng và mã nguồn mở : Jan hoàn toàn miễn phí, mã nguồn mở và hoạt động trên Mac, Windows và Linux.
Tùy chỉnh tham số suy luận : Điều chỉnh các tham số mô hình như Mã thông báo tối đa, nhiệt độ, luồng, hình phạt tần suất, v.v. Tất cả các tùy chọn, cách sử dụng mô hình và cài đặt đều được lưu cục bộ trên máy tính của bạn.
Tiện ích mở rộng : Jan hỗ trợ các tiện ích mở rộng như TensortRT và Inference Nitro để tùy chỉnh và nâng cao mô hình AI của bạn.
Lợi ích của việc sử dụng Jan
Jan cung cấp một giao diện sạch sẽ và đơn giản để tương tác với LLM và nó lưu trữ tất cả dữ liệu và thông tin xử lý của bạn cục bộ. Nó có hơn bảy mươi mô hình ngôn ngữ lớn đã được cài đặt sẵn để bạn sử dụng. Tính khả dụng của các mô hình sẵn sàng sử dụng này giúp bạn dễ dàng kết nối và tương tác với các API từ xa như OpenAI và Mistral. Jan cũng có một cộng đồng GitHub , Discord và Hugging Face tuyệt vời để theo dõi và yêu cầu trợ giúp. Tuy nhiên, giống như tất cả các công cụ LLM, các mô hình hoạt động nhanh hơn trên máy Mac Apple Silicon so với trên máy Intel.
GPT4All
GPT4All có thể chạy LLM trên phần cứng tiêu dùng chính như chip Mac M-Series, GPU AMD và NVIDIA. Sau đây là các tính năng chính của nó.
Quyền riêng tư là trên hết : Chỉ lưu trữ thông tin trò chuyện riêng tư và nhạy cảm cũng như lời nhắc trên máy của bạn.
Không cần Internet : Hoạt động hoàn toàn ngoại tuyến.
Khám phá mô hình : Tính năng này cho phép các nhà phát triển duyệt và tải xuống các loại LLM khác nhau để thử nghiệm. Bạn có thể chọn khoảng 1000 mô hình ngôn ngữ nguồn mở từ các tùy chọn phổ biến như LLama, Mistral, v.v.
Tài liệu cục bộ : Bạn có thể cho phép LLM cục bộ của mình truy cập dữ liệu nhạy cảm bằng các tài liệu cục bộ như .pdfvà .txtkhông cần dữ liệu rời khỏi thiết bị của bạn cũng như không cần mạng.
Tùy chọn tùy chỉnh : Cung cấp một số tùy chọn điều chỉnh chatbot như nhiệt độ, kích thước lô, độ dài ngữ cảnh, v.v.
Phiên bản doanh nghiệp : GPT4ALL cung cấp gói doanh nghiệp với tính năng bảo mật, hỗ trợ và giấy phép theo từng thiết bị để mang AI cục bộ đến với doanh nghiệp.
Ứng dụng thu thập dữ liệu người dùng ẩn danh về phân tích sử dụng và chia sẻ trò chuyện. Tuy nhiên, người dùng có tùy chọn tham gia hoặc không tham gia. Sử dụng GPT4ALL, các nhà phát triển được hưởng lợi từ lượng người dùng lớn, cộng đồng GitHub và Discord.
Qwen2.5-Coder chạy cục bộ
Qwen2.5-Coder xây dựng dựa trên nền tảng của các phiên bản trước đó đồng thời giới thiệu những cải tiến đáng kể về hiệu quả và hiệu suất của mô hình. Chuỗi mô hình có nhiều kích cỡ, mỗi kích cỡ được tối ưu hóa cho các trường hợp sử dụng và ràng buộc tính toán khác nhau. Kiến trúc sử dụng thiết kế máy biến áp đã sửa đổi với các cơ chế chú ý nâng cao và sử dụng tham số được tối ưu hóa.

Ollama cung cấp một phương pháp hợp lý để chạy Qwen2.5-Coder cục bộ. Sau đây là quy trình thiết lập chi tiết:
# Cài đặt Ollama
curl – fsSL < https: / / ollama.com / install.sh > | sh
# Kéo Qwen2 .5 – Mô hình Coder
ollama pull qwen2 .5 – coder
# Tạo một Modelfile tùy chỉnh cho các cấu hình cụ thể
cat << EOF > Modelfile
FROM qwen2.5–coder
# Cấu hình các tham số mô hình
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.1
PARAMETER context_length 32768
# Đặt thông báo hệ thống You are an expert programming assistant.
SYSTEM “Bạn là trợ lý lập trình chuyên gia.”
EOF
# Tạo mô hình tùy chỉnh
ollama create qwen2 .5 – coder – custom – f Modelfile
Phân tích hiệu suất Coder Qwen2.5
Đánh giá hiệu suất cho thấy khả năng ấn tượng trên nhiều tác vụ mã hóa khác nhau. Mô hình này chứng minh sức mạnh đặc biệt trong việc hoàn thành mã, phát hiện lỗi và tạo tài liệu. Khi chạy trên phần cứng tiêu dùng với NVIDIA RTX 3090, mô hình 7B đạt thời gian suy luận trung bình là 150ms cho các tác vụ hoàn thành mã, đồng thời duy trì độ chính xác cao trên nhiều ngôn ngữ lập trình.
Triển khai Qwen2.5-Coder bằng Python
Sau đây là một ví dụ triển khai toàn diện sử dụng Python và API HTTP của Ollama:
import requests
import json
class Qwen25Coder :
def __init__ ( self, base_url= “<http://localhost:11434>” ):
self.base_url = base_url
self.api_generate = f” {base_url} /api/generate”
def generate_code ( self, prompt, model= “qwen2.5-coder-custom” ):
payload = {
“model” : model,
“prompt” : prompt,
“stream” : False ,
“options” : {
“temperature” : 0.7 ,
“top_p” : 0.9 ,
“repeat_penalty” : 1.1
}
}
response = requests.post(self.api_generate, json=payload)
return response.json()[ “response” ]
def code_review ( self, code ):
prompt = f”””Xem lại mã sau và cung cấp phản hồi chi tiết:
“`
{code}
“`
Vui lòng phân tích:
1. Chất lượng mã
2. Lỗi tiềm ẩn
3. Ý nghĩa về hiệu suất
4. Cân nhắc về bảo mật”””
return self.generate_code(prompt)
coder = Qwen25Coder()
code_snippet = “””
def calculate_fibonacci(n):
if n <= 0:
return []
elif n == 1:
return [0]
“””
completion = coder.generate_code( f”Hoàn thành hàm chuỗi Fibonacci này: {code_snippet} “ )
Việc triển khai ở trên cung cấp một giao diện mạnh mẽ để tương tác với Qwen2.5-Coder thông qua Ollama. Qwen25Coder Lớp này đóng gói các hoạt động chung và cung cấp một API sạch cho các tác vụ tạo và xem xét mã. Mã này bao gồm các tùy chọn xử lý lỗi và cấu hình phù hợp, giúp nó phù hợp với môi trường sản xuất.
Cấu hình và tối ưu hóa nâng cao
Khi triển khai Qwen2.5-Coder trong môi trường sản xuất, một số chiến lược tối ưu hóa có thể cải thiện đáng kể hiệu suất. Sau đây là ví dụ cấu hình chi tiết sử dụng các tính năng nâng cao của Ollama:
models:
qwen2.5-coder:
type: llama
parameters:
context_length: 32768
num_gpu: 1
num_thread: 8
batch_size: 32
quantization:
mode: ‘int8’
cache:
type: ‘redis’
capacity: ’10gb’
runtime:
compute_type: ‘float16’
tensor_parallel: true
Cấu hình này cho phép thực hiện một số tối ưu hóa quan trọng:
- Song song hóa tenxơ tự động cho hệ thống đa GPU
- Lượng tử hóa Int8 để giảm thiểu dấu chân bộ nhớ
- Bộ nhớ đệm phản hồi dựa trên Redis
- Float16 tính toán để cải thiện hiệu suất
- Tối ưu hóa cài đặt kích thước luồng và lô
Tích hợp với quy trình phát triển: Qwen2.5-Coder có thể được tích hợp liền mạch vào quy trình phát triển hiện có thông qua nhiều tiện ích mở rộng IDE và công cụ dòng lệnh.
Giám sát và tối ưu hóa hiệu suất
Để đảm bảo hiệu suất tối ưu trong môi trường sản xuất, việc triển khai giám sát phù hợp là rất quan trọng. Sau đây là ví dụ về thiết lập giám sát:import time
import psutil
import logging
from dataclasses import dataclass
from typing import Optional
@dataclass
class PerformanceMetrics:
inference_time: float
memory_usage: float
token_count: int
success: bool
error: Optional[str] = None
class Qwen25CoderMonitored(Qwen25Coder):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.logger = logging.getLogger(“qwen2.5-coder”)
def generate_code_with_metrics(self, prompt: str) -> tuple[str, PerformanceMetrics]:
start_time = time.time()
initial_memory = psutil.Process().memory_info().rss / 1024 / 1024
try:
response = self.generate_code(prompt)
success = True
error = None
except Exception as e:
response = “”
success = False
error = str(e)
end_time = time.time()
final_memory = psutil.Process().memory_info().rss / 1024 / 1024
metrics = PerformanceMetrics(
inference_time=end_time – start_time,
memory_usage=final_memory – initial_memory,
token_count=len(response.split()),
success=success,
error=error
)
self.logger.info(f“Performance metrics: {metrics}”)
return response, metrics
Việc triển khai giám sát này cung cấp thông tin chi tiết về các đặc điểm hiệu suất của mô hình, bao gồm thời gian suy luận, mức sử dụng bộ nhớ và tỷ lệ thành công. Các số liệu có thể được sử dụng để tối ưu hóa tài nguyên hệ thống và xác định các điểm nghẽn tiềm ẩn.
Hệ sinh thái Qwen2.5-Coder tiếp tục phát triển với những cải tiến được lên kế hoạch trong một số lĩnh vực chính. Mô hình tham số 32B sắp tới hứa hẹn khả năng nâng cao trong khi vẫn duy trì các yêu cầu về tài nguyên thực tế. Cộng đồng phát triển đang tích cực làm việc trên các phương pháp tinh chỉnh chuyên biệt cho các ngôn ngữ lập trình và khuôn khổ cụ thể.
Kiến trúc của mô hình được thiết kế để đáp ứng những cải tiến trong tương lai về xử lý độ dài ngữ cảnh và hiệu quả bộ nhớ. Nghiên cứu đang diễn ra về các cơ chế chú ý hiệu quả hơn và các kỹ thuật tối ưu hóa tham số cho thấy các phiên bản trong tương lai có thể đạt hiệu suất thậm chí còn tốt hơn với yêu cầu tài nguyên thấp hơn.
Thông qua bộ tính năng toàn diện và các đặc điểm hiệu suất mạnh mẽ, Qwen2.5-Coder đại diện cho một bước tiến đáng kể trong các mô hình ngôn ngữ tập trung vào mã. Cho dù được triển khai cho các tác vụ phát triển riêng lẻ hay được tích hợp vào các hệ thống quy mô doanh nghiệp, mô hình này cung cấp các khả năng mạnh mẽ để tạo, phân tích và tối ưu hóa mã. Sự kết hợp với Ollama làm cho nó đặc biệt dễ tiếp cận để triển khai cục bộ trong khi vẫn duy trì hiệu suất cấp độ chuyên nghiệp.
https://sebastian-petrus.medium.com/how-to-run-qwen2-5-coder-locally-a-comprehensive-guide-a3bc0284714a
Ví dụ: xây dựng huấn luyện viên thể hình
Trong thời đại công nghệ thông tin này, tại sao phải trả tiền cho một huấn luyện viên thể hình khi bạn có thể tự xây dựng huấn luyện viên AI của riêng mình? Hãy tưởng tượng bạn có một kế hoạch tập luyện tùy chỉnh được thiết kế riêng cho mục tiêu, tình trạng sức khỏe và lối sống của bạn. Sử dụng sức mạnh của AI, chúng tôi có thể tạo ra một thói quen tập thể dục được cá nhân hóa, phù hợp với tiến trình của bạn và giúp bạn luôn có động lực!
Xây dựng một huấn luyện viên thể hình AI có khả năng:
- Thu thập dữ liệu người dùng như tuổi, cân nặng và mục tiêu thể dục.
- Tạo thói quen tập thể dục được cá nhân hóa.
- Thu thập phản hồi của người dùng sau mỗi phiên và cập nhật kế hoạch cho phù hợp.
- Theo dõi tiến trình của bạn theo thời gian.
- Động viên bạn bằng sự khích lệ và lời khuyên.
LangGraph giống như bộ não đằng sau nhiều tác nhân AI làm việc cùng nhau để hoàn thành công việc. LangGraph được thiết kế để tạo ra các quy trình làm việc có trạng thái cho các tác nhân. Điều đó có nghĩa là, thay vì thực hiện mọi thứ theo cách tuyến tính, như thực thi mã đơn giản, nó xử lý từng bước của ứng dụng của bạn như một trạng thái trong biểu đồ . Các trạng thái này giao tiếp với nhau theo một luồng logic, giống như một loạt các phòng được kết nối trong một tòa nhà.
Mỗi “phòng” hoặc trạng thái này có thể thực hiện một chức năng chuyên biệt và LangGraph đảm bảo chúng hợp tác nhịp nhàng. Nếu bạn nghĩ về điều đó, việc tạo thói quen tập thể dục không chỉ là liệt kê các bài tập. Mà là về:
Hiểu được mục tiêu và hạn chế cá nhân của bạn.
Thiết kế kế hoạch tập luyện dựa trên loại cơ thể, sở thích và mục tiêu thể dục của bạn.
Điều chỉnh kế hoạch đó khi bạn đưa ra phản hồi hoặc tiến triển theo thời gian.
Thúc đẩy bạn bằng cách theo dõi tiến độ thực hiện của bạn.
Mỗi trạng thái này là một trạng thái riêng biệt và LangGraph cho phép tôi xử lý chúng một cách độc lập trong khi vẫn duy trì được bức tranh toàn cảnh.
Bước 1: Thiết lập Huấn luyện viên thể hình AI
AI Fitness Coach sẽ hoạt động như một loạt các tác nhân, mỗi tác nhân chịu trách nhiệm cho một nhiệm vụ khác nhau, chẳng hạn như thu thập thông tin đầu vào của người dùng, tạo thói quen tập thể dục, phân tích phản hồi và theo dõi tiến trình. Các tác nhân này hợp tác để tạo ra một huấn luyện viên thể dục tương tác và thích ứng.
from typing import Annotated, TypedDict, List
from langgraph.graph import StateGraph, END
from langchain_community.chat_models import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langgraph.graph.message import add_messages
from langchain_core.messages import HumanMessage, AIMessage
import json
class State(TypedDict):
user_data: dict
fitness_plan: str
feedback: str
progress: List[str]
messages: Annotated[list, add_messages]
def get_ollama_llm(model_name=“tinyllama”):
return ChatOllama(model=model_name)
Ở đây, chúng tôi định nghĩa lớp State lưu trữ dữ liệu người dùng, kế hoạch thể dục, phản hồi và tiến trình. Chúng tôi cũng tạo một hàm tiện ích để lấy mô hình Ollama để tạo văn bản.
Bước 2: Tác nhân nhập liệu của người dùng
Bước đầu tiên là thu thập dữ liệu người dùng, chẳng hạn như tuổi, cân nặng và mục tiêu thể dục, để tạo hồ sơ người dùng. Hồ sơ này được cấu trúc dưới dạng JSON để dễ xử lý.
def user_input_agent(state: State, llm):
prompt = ChatPromptTemplate.from_template(
“””You are an AI fitness coach assistant. Process the following user information:
{user_input}
Create a structured user profile based on this information. Include all relevant details for creating a personalized fitness plan.
Return the profile as a valid JSON string.”””
)
chain = prompt | llm | StrOutputParser()
user_profile = chain.invoke({“user_input”: json.dumps(state[“user_data”])})
try:
state[“user_data”] = json.loads(user_profile)
except json.JSONDecodeError:
pass
return state
Tác nhân này xử lý thông tin đầu vào của người dùng (như tuổi, cân nặng và sở thích tập luyện) và tạo ra hồ sơ có cấu trúc mà huấn luyện viên thể hình sẽ sử dụng để xây dựng kế hoạch tập luyện.
Bước 3: Tác nhân tạo ra thói quen
Sau khi có hồ sơ người dùng, đã đến lúc tạo một kế hoạch thể dục được cá nhân hóa. Tác nhân này sẽ tạo ra một kế hoạch bao gồm các loại bài tập, thời lượng, cường độ và thậm chí cả ngày nghỉ.
def routine_generation_agent(state: State, llm):
prompt = ChatPromptTemplate.from_template(
“””You are an AI fitness coach. Create a personalized fitness routine based on the following user data:
{user_data}
Create a detailed weekly fitness plan that includes:
1. Types of exercises
2. Duration and frequency of workouts
3. Intensity levels
4. Rest days
5. Any dietary recommendations”””
)
chain = prompt | llm | StrOutputParser()
plan = chain.invoke({“user_data”: json.dumps(state[“user_data”])})
state[“fitness_plan”] = plan
return state
Tác nhân này cung cấp một kế hoạch tập thể dục hàng tuần có cấu trúc phù hợp với hồ sơ của người dùng. Chương trình tập luyện sẽ bao gồm tim mạch, rèn luyện sức mạnh hoặc bất kỳ sở thích nào mà người dùng lựa chọn.
Bước 4: Phản hồi và điều chỉnh
Sau mỗi buổi tập, người dùng có thể đưa ra phản hồi. Dựa trên phản hồi này, huấn luyện viên AI có thể điều chỉnh thói quen tập luyện để phù hợp hơn với nhu cầu của người dùng.
def feedback_collection_agent(state: State, llm):
prompt = ChatPromptTemplate.from_template(
“””Analyze the following user feedback on their recent workout session:
Current fitness plan: {current_plan}
User feedback: {user_feedback}
Suggest any immediate adjustments.”””
)
chain = prompt | llm | StrOutputParser()
feedback_summary = chain.invoke({“current_plan”: state[“fitness_plan”], “user_feedback”: state[“feedback”]})
return state
Tác nhân này thu thập phản hồi, phân tích và đề xuất thay đổi thói quen tập thể dục hiện tại nếu cần thiết.
Bước 5: Tác nhân thúc đẩy
Cuối cùng, một huấn luyện viên không có động lực thì sẽ thế nào? Người thúc đẩy động lực sẽ gửi những thông điệp khích lệ để giúp người dùng đi đúng hướng.
def motivational_agent(state: State, llm):
prompt = ChatPromptTemplate.from_template(
“””Provide encouragement, tips, or reminders to the user:
User Data: {user_data}
Current Plan: {current_plan}
Recent Progress: {recent_progress}”””
)
chain = prompt | llm | StrOutputParser()
motivation = chain.invoke(
{“user_data”: str(state[“user_data”]), “current_plan”: state[“fitness_plan”], “recent_progress”: state[“progress”][-1] if state[“progress”] else “”}
)
return state
Tác nhân này gửi tin nhắn động viên, đưa ra lời khuyên hữu ích và nhắc nhở người dùng về tiến trình của họ để họ luôn có động lực.
Bước 6: Xây dựng giao diện người dùng với Gradio
Để giúp huấn luyện viên thể hình AI này dễ tiếp cận hơn, chúng tôi sử dụng Gradio để xây dựng giao diện web trực quan nơi người dùng có thể nhập dữ liệu, lập kế hoạch và đưa ra phản hồi.
import gradio as gr
# Gradio UI
with gr.Blocks() as demo:
gr.Markdown(“# AI Fitness Coach”)
# Tab for creating the initial fitness plan
with gr.Tab(“Create Fitness Plan”):
age = gr.Number(label=“Age”)
weight = gr.Number(label=“Weight (kg)”)
height = gr.Number(label=“Height (cm)”)
gender = gr.Radio([“Male”, “Female”, “Other”], label=“Gender”)
primary_goal = gr.Dropdown([“Weight loss”, “Muscle gain”, “Endurance improvement”, “General fitness”], label=“Primary Goal”)
target_timeframe = gr.Dropdown([“3 months”, “6 months”, “1 year”], label=“Target Timeframe”)
workout_preferences = gr.CheckboxGroup([“Cardio”, “Strength training”, “Yoga”, “HIIT”], label=“Workout Preferences”)
workout_duration = gr.Slider(15, 120, step=15, label=“Workout Duration (minutes)”)
workout_days = gr.CheckboxGroup([“Monday”, “Wednesday”, “Friday”], label=“Workout Days”)
activity_level = gr.Radio([“Sedentary”, “Lightly active”, “Moderately active”, “Highly active”], label=“Activity Level”)
health_conditions = gr.Textbox(label=“Health Conditions”)
dietary_preferences = gr.Textbox(label=“Dietary Preferences (Optional)”)
create_button = gr.Button(“Create Fitness Plan”)
plan_output = gr.Textbox(label=“Your Fitness Plan”)
create_button.click(
process_user_input,
inputs=[age, weight, height, gender, primary_goal, target_timeframe, workout_preferences,
workout_duration, workout_days, activity_level, health_conditions, dietary_preferences],
outputs=plan_output
)
# Tab for updating the fitness plan based on feedback
with gr.Tab(“Update Fitness Plan”):
feedback = gr.Textbox(label=“Feedback”)
update_button = gr.Button(“Update Fitness Plan”)
updated_plan_output = gr.Textbox(label=“Updated Fitness Plan”)
update_button.click(update_plan, inputs=[feedback], outputs=updated_plan_output)
# Launch Gradio demo
demo.launch()
Giao diện người dùng Gradio cho phép người dùng dễ dàng tương tác với huấn luyện viên AI và quản lý hành trình rèn luyện thể chất của mình.
Phần kết luận
Chỉ với một vài dòng mã và các công cụ phù hợp, bạn có thể xây dựng huấn luyện viên thể dục hỗ trợ AI của riêng mình. Bằng cách tích hợp các mô hình ngôn ngữ như Ollama với giao diện tương tác bằng Gradio , bạn có thể cá nhân hóa các kế hoạch thể dục và cung cấp phản hồi theo thời gian thực. Cho dù bạn đang muốn giảm cân, tăng cơ hay cải thiện sức bền, huấn luyện viên thể dục AI này sẽ giúp bạn luôn có động lực và đi đúng hướng.
https://pub.towardsai.net/how-to-build-your-own-ai-fitness-coach-using-open-source-llms-and-gradio-3151e429692f