TRỰC TIẾP: Tin tức AI cập nhật 24/7
Tuesday, 21/07/2026
SaoAI NEWS
Hugging Face Blog

Các mô hình LLM tiếng Ả Rập

The ecosystem of Arabic LLM models is quickly expanding, presenting a challenge in keeping up with the latest developments. This article aims to address this issue by serving as a comprehensive resour

7 giờ trước · 🇻🇳 Đã dịch

Mới nhất

23 bài
Hugging

## Sẵn Sàng Trước Khi Bị Tấn Công: Hướng Dẫn Thực Tế Tự Lưu Trữ Mô Hình Mở Cho Phòng Thủ Mạng Trong bối cảnh các mối đe dọa mạng ngày càng tinh vi, việc chủ động phòng thủ là yếu tố sống còn. Hướng dẫn này cung cấp các bước thực tế để tự lưu trữ (self-host) một mô hình AI mã nguồn mở nhằm tăng cường khả năng phòng thủ mạng, giúp bạn sẵn sàng trước khi cuộc tấn công xảy ra. **1. Tại sao cần tự lưu trữ mô hình mở?** - **Kiểm soát dữ liệu:** Dữ liệu nhạy cảm không rời khỏi hệ thống của bạn. - **Tùy chỉnh linh hoạt:** Fine-tune mô hình theo nhu cầu phòng thủ cụ thể. - **Chi phí thấp hơn:** Tránh phí API đám mây về lâu dài. - **Bảo mật cao:** Giảm nguy cơ rò rỉ qua bên thứ ba. **2. Lựa chọn mô hình phù hợp** - **Mô hình ngôn ngữ lớn (LLM):** Llama 2, Mistral, Falcon (dùng cho phân tích log, tạo báo cáo). - **Mô hình phát hiện bất thường:** Các biến thể của transformer được huấn luyện trên dữ liệu mạng. - **Mô hình phân tích mã độc:** Các mô hình diffusion hoặc RAG kết hợp cơ sở tri thức. **3. Chuẩn bị hạ tầng** - **Phần cứng:** GPU (tối thiểu 16GB VRAM cho LLM 7B), RAM 32GB+, SSD 500GB+. - **Phần mềm:** Docker, Kubernetes (tùy chọn), thư viện như Hugging Face Transformers, vLLM, Ollama. - **Mạng:** Cách ly mạng inference với mạng sản xuất, sử dụng firewall và VPN. **4. Triển khai từng bước** - **Bước 1:** Cài đặt môi trường (Python 3.10+, CUDA, PyTorch). - **Bước 2:** Tải mô hình từ Hugging Face hoặc nguồn tin cậy. - **Bước 3:** Tối ưu hóa inference (quantization, batching, caching). - **Bước 4:** Xây dựng API endpoint với FastAPI hoặc Flask. - **Bước 5:** Tích hợp với SIEM (Security Information and Event Management) hiện có. **5. Các trường hợp sử dụng thực tế** - **Phân tích log thời gian thực:** Mô hình LLM phát hiện bất thường trong log hệ thống. - **Tự động phản hồi:** Agent AI chặn IP độc hại dựa trên phân tích. - **Tạo báo cáo tình báo m treat:** RAG kết hợp cơ sở dữ liệu CVE và mô hình ngôn ngữ. **6. Bảo mật cho mô hình tự lưu trữ** - Mã hóa mô hình khi lưu trữ. - Giới hạn quyền truy cập API bằng JWT hoặc API key. - Giám sát hiệu suất và phát hiện tấn công vào mô hình (adversarial attacks). **7. Duy trì và cập nhật** - Cập nhật mô hình định kỳ với dữ liệu m treat mới. - Fine-tune mô hình hàng tháng dựa trên dữ liệu nội bộ. - Sao lưu checkpoint và cấu hình. **Kết luận:** Tự lưu trữ mô hình mở không chỉ giúp bạn chủ động phòng thủ mà còn tiết kiệm chi phí và tăng cường bảo mật dữ liệu. Hãy bắt đầu với một mô hình nhỏ, mở rộng dần khi đã thành thạo. Sự chuẩn bị kỹ lưỡng hôm nay sẽ là lá chắn vững chắc trước các cuộc tấn công ngày mai.

On July 16, 2026, Hugging Facedisclosed a security incidentthat was different from anything the team had handled before: the intrusion was driven end

7 giờ trước 🇻🇳 VI
Hugging

# Fine-tune mô hình video và hình ảnh ở quy mô lớn với NVIDIA NeMo Automodel và 🤗 Diffusers

Diffusion models power some of the most exciting open-source releases of the last two years — such asFLUX.1-devfor text-to-image andWan 2.1andHunyuanV

1 ngày trước 🇻🇳 VI
Hugging

# Hướng Dẫn Về Huấn Luyện Hậu Kỳ Bằng Học Tăng Cường Cho LLM: PPO, DPO, GRPO Và Hơn Thế Nữa

Statests_tst​: The current context which is the original user prompt and all tokens generated so far Example: Prompt: "The sky is..."→\rightarrow→Sta

1 ngày trước 🇻🇳 VI
Hugging

# Cách Tôi Huấn Luyện Action Chunking Transformer (ACT) trên SO-101: Hành Trình, Những Cạm Bẫy và Bài Học Kinh Nghiệm --- ## Mở Đầu Vài tháng trước, tôi quyết định thử sức với việc huấn luyện một policy robot từ đầu bằng cách sử dụng **Action Chunking Transformer (ACT)** trên cánh tay robot **SO-101**. Đây là câu chuyện thực tế — không phải bản demo được đánh bóng — bao gồm cả những lần thất bại, những đêm thức khuya debug, và cuối cùng là khoảnh khắc robot thực sự hoàn thành nhiệm vụ. --- ## ACT Là Gì và Tại Sao Tôi Chọn Nó? **Action Chunking Transformer (ACT)** là một kiến trúc học模仿 (imitation learning) được giới thiệu trong bài báo *"Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware"* (Chi et al., 2023). Ý tưởng cốt lõi: - Thay vì dự đoán **từng hành động một**, ACT dự đoán một **"chunk" (khối) hành động** — một chuỗi các hành động trong tương lai ngắn hạn - Sử dụng kiến trúc **Transformer encoder-decoder** với **CVAE (Conditional Variational Autoencoder)** để xử lý tính đa dạng trong dữ liệu biểu diễn - Giảm thiểu hiện tượng **compounding errors** (lỗi tích lũy) vốn là vấn đề kinh điển của behavioral cloning Tôi chọn ACT vì: 1. Nó hoạt động tốt với **dữ liệu ít** (50–200 demo) 2. Phù hợp với phần cứng giá rẻ như SO-101 3. Cộng đồng **LeRobot (HuggingFace)** đã tích hợp sẵn --- ## Thiết Lập Phần Cứng ### Robot SO-101 - 6 bậc tự do (6-DOF) - Servo Feetech STS3215 - Camera góc nhìn từ cổ tay + camera quan sát từ trên - Tổng chi phí: ~$300 ### Máy Tính Huấn Luyện - GPU: RTX 3090 (24GB VRAM) - RAM: 64GB - Hệ điều hành: Ubuntu 22.04 > **Lưu ý quan trọng:** Bạn *có thể* huấn Luyện trên RTX 3060 (12GB), nhưng phải giảm batch size và sẽ mất nhiều thời gian hơn đáng kể. --- ## Quy Trình Thu Thập Dữ Liệu ### Nhiệm Vụ Tôi Chọn Tôi bắt đầu với nhiệm vụ **"nhặt khối lego và đặt vào hộp"** — đơn giản nhưng đủ thách thức để kiểm tra policy. ### Số Lượng Demo | Lần thử | Số demo | Kết quả | |---------|---------|---------| | 1 | 30 | Thất bại hoàn toàn | | 2 | 80 | Robot di chuyển nhưng không nhặt được | | 3 | 150 | Thành công ~40% | | 4 | 200 | Thành công ~75% | ### Những Cạm Bẫy Khi Thu Thập Dữ Liệu **❌ Cạm bẫy #1: Demo không nhất quán** ``` Vấn đề: Tôi đặt khối lego ở các vị trí khác nhau mỗi lần nhưng không đủ đa dạng — tạo ra "vùng chết" mà robot không bao giờ học được. Giải pháp: Chia không gian làm việc thành grid 3x3, thu thập đều ở mỗi ô. ``` **❌ Cạm bẫy #2: Tốc độ demo không đồng đều** ``` Vấn đề: Đôi khi tôi thao tác nhanh, đôi khi chậm. ACT rất nhạy cảm với timing. Giải pháp: Đặt metronome 1Hz, thao tác theo nhịp. ``` **❌ Cạm bẫy #3: Ánh sáng thay đổi** ``` Vấn đề: Thu thập demo vào buổi sáng và chiều tối — điều kiện ánh sáng khác nhau hoàn toàn. Giải pháp: Dùng đèn LED cố định, che cửa sổ. ``` --- ## Cài Đặt và Cấu Hình ### Cài Đặt LeRobot ```bash # Clone repository git clone https://github.com/huggingface/lerobot.git cd lerobot # Tạo môi trường conda conda create -n lerobot python=3.10 conda activate lerobot # Cài đặt dependencies pip install -e ".[feetech]" ``` ### Cấu Hình ACT cho SO-101 File cấu hình `configs/policy/act_so101.yaml`: ```yaml policy: name: act # Kiến trúc chunk_size: 100 # Số bước hành động trong mỗi chunk n_obs_steps: 1 # Số frame quan sát đầu vào # Encoder dim_model: 512 n_heads: 8 n_encoder_layers: 4 n_decoder_layers: 7 # CVAE latent_dim: 32 kl_weight: 10.0 # Quan trọng! Xem phần bên dưới # Camera camera_names: ["top", "wrist"] image_size: [480, 640] # Backbone vision vision_backbone: resnet18 pretrained_backbone: true training: batch_size: 8 lr: 1e-5 num_epochs: 2000 grad_clip_norm: 10.0 ``` --- ## Quá Trình Huấn Luyện ### Lệnh Huấn Luyện ```bash python lerobot/scripts/train.py \ policy=act_so101 \ env=so101_real \ dataset_repo_id=your_username/so101_lego_task \ hydra.run.dir=outputs/act_so101_run1 \ training.num_epochs=2000 \ wandb.enable=true ``` ### Monitoring Với W&B Tôi theo dõi các metrics sau: - **`train/loss`**: Loss tổng thể - **`train/l1_loss`**: Reconstruction loss của hành động - **`train/kl_loss`**: KL divergence của CVAE ### Đường Cong Loss Điển Hình ``` Epoch 0: loss=2.847 Epoch 100: loss=1.203 Epoch 500: loss=0.412 Epoch 1000: loss=0.187 Epoch 1500: loss=0.134 Epoch 2000: loss=0.098 ``` --- ## Những Cạm Bẫy Khi Huấn Luyện ### 🔥 Cạm Bẫy Lớn Nhất: `kl_weight` Đây là thứ khiến tôi mất **3 ngày** để debug. ``` Vấn đề: Robot học được cách di chuyển nhưng hành động rất "run rẩy" và không mượt mà. Nguyên nhân: kl_weight quá thấp (tôi đặt = 1.0) → CVAE không học được latent space có cấu trúc tốt → Policy không ổn định Giải pháp: Tăng kl_weight lên 10.0 (giá trị mặc định trong paper gốc). Đừng thay đổi giá trị này trừ khi bạn hiểu rõ lý do. ``` ### ⚠️ Cạm Bẫy #2: Chunk Size Không Phù Hợp ``` chunk_size=50: Robot dừng và "suy nghĩ" quá thường xuyên → Hành động bị ngắt quãng chunk_size=100: Hoạt động tốt cho nhiệm vụ ~3 giây chunk_size=200: Robot "cam kết" quá lâu với một kế hoạch → Không thể phục hồi khi có sai lệch nhỏ ``` ### ⚠️ Cạm Bẫy #3: Learning Rate ```python # ❌ Sai - LR quá cao lr = 1e-4 # Loss giảm nhanh nhưng policy không ổn định # ✅ Đúng - LR thấp hơn, ổn định hơn lr = 1e-5 # Huấn luyện chậm hơn nhưng kết quả tốt hơn nhiều ``` ### ⚠️ Cạm Bẫy #4: Normalization Dữ Liệu ```bash # LUÔN kiểm tra stats normalization trước khi train python lerobot/scripts/compute_stats.py \ --dataset-repo-id your_username/so101_lego_task # Output mẫu: # action mean: [0.023, -0.156, 0.891, ...] # action std: [0.234, 0.445, 0.123, ...] ``` Nếu std của một joint gần bằng 0 → joint đó hầu như không di chuyển trong demo → **xem lại dữ liệu của bạn**. --- ## Triển Khai và Đánh Giá ### Script Inference ```python from lerobot.common.policies.act.modeling_act import ACTPolicy import torch # Load policy policy = ACTPolicy.from_pretrained("outputs/act_so101_run1/checkpoints/last") policy.eval() policy.to("cuda") # Inference loop with torch.inference_mode(): while True: # Lấy observation từ robot obs = get_robot_observation() # Dự đoán action chunk action_chunk = policy.select_action(obs) # Thực thi từng action trong chunk for action in action_chunk: robot.send_action(action) time.sleep(1/50) # 50Hz control ``` ### Kết Quả Đánh Giá Tôi đánh giá trên **50 lần thử** với vị trí khối lego ngẫu nhiên: | Metric | Giá trị | |--------|---------| | Tỷ lệ thành công tổng thể | 74% | | Thành công khi khối ở trung tâm | 92% | | Thành công khi khối ở góc | 58% | | Thời gian hoàn thành trung bình | 4.2 giây | | Tỷ lệ va chạm | 3% | --- ## Phân Tích Thất Bại ### Tại Sao 26% Còn Lại Thất Bại? **Phân tích bằng cách record video:** 1. **~12%**: Khối lego ở vị trí chưa từng thấy trong training 2. **~8%**: Ánh sáng phản chiếu bất thường trên bề mặt khối 3. **~4%**: Robot nhặt được nhưng thả trước khi đến hộp 4. **~2%**: Lỗi servo (vấn đề phần cứng) ### Cải Thiện Tiếp Theo ``` TODO: [ ] Thêm data augmentation (color jitter, random crop) [ ] Thu thập thêm demo ở các góc cạnh [ ] Thử ACT+ với diffusion head [ ] Thêm camera thứ 3 (góc bên) ``` --- ## Bài Học Tổng Kết ### ✅ Những Gì Hoạt Động Tốt 1. **Bắt đầu đơn giản**: Nhiệm vụ đơn giản + ít camera + ít demo → iterate nhanh 2. **Giữ nguyên hyperparameters mặc định**: Đặc biệt là `kl_weight=10.0` 3. **Chất lượng > Số lượng demo**: 150 demo nhất quán tốt hơn 300 demo lộn xộn 4. **Kiểm soát môi trường**: Ánh sáng cố định, nền đồng nhất ### ❌ Những Gì Không Hoạt Động 1. Thay đổi nhiều hyperparameter cùng lúc 2. Thu thập demo khi mệt (chất lượng giảm rõ rệt) 3. Bỏ qua bước kiểm tra normalization stats 4. Dùng `chunk_size` quá lớn cho nhiệm vụ ngắn ### 💡 Quy Tắc Ngón Tay Cái ``` Thời gian nhiệm vụ (giây) × Tần số điều khiển (Hz) × 0.5 = chunk_size lý tưởng Ví dụ: 3 giây × 50Hz × 0.5 = 75 → dùng chunk_size=100 ``` --- ## Tài Nguyên Tham Khảo - 📄 [Paper ACT gốc](https://arxiv.org/abs/2304.13705) - 🤗 [LeRobot Documentation](https://github.com/huggingface/lerobot) - 🛠️ [SO-101 Build Guide](https://github.com/TheRobotStudio/SO-ARM100) - 💬 [Discord LeRobot Community](https://discord.gg/lerobot) --- *Nếu bạn đang x

I’ve been wanting to try out theAction Chunking Transformer (ACT)on a real robot since I saw the model cooking a shrimp 🦐. A month ago, I finally got

1 ngày trước 🇻🇳 VI
Hugging

# Mô Hình Ngôn Ngữ Nhỏ (SLM): Tổng Quan Toàn Diện ## Giới Thiệu Trong bối cảnh trí tuệ nhân tạo phát triển nhanh chóng, các Mô Hình Ngôn Ngữ Lớn (LLM) như GPT-4, Claude và Gemini đã thu hút sự chú ý đáng kể nhờ khả năng ấn tượng của chúng. Tuy nhiên, một xu hướng song song đang nổi lên mạnh mẽ: sự phát triển và ứng dụng của các Mô Hình Ngôn Ngữ Nhỏ (SLM). Bài viết này cung cấp cái nhìn toàn diện về SLM — từ định nghĩa, đặc điểm, ưu nhược điểm, cho đến các ứng dụng thực tiễn và triển vọng tương lai. --- ## 1. SLM Là Gì? **Mô Hình Ngôn Ngữ Nhỏ (Small Language Model - SLM)** là các mô hình ngôn ngữ được xây dựng trên kiến trúc transformer với số lượng tham số tương đối nhỏ, thường dao động từ **vài triệu đến khoảng 7 tỷ tham số**, so với các LLM có thể lên đến hàng trăm tỷ hoặc thậm chí nghìn tỷ tham số. ### Phân Loại Theo Quy Mô | Loại Mô Hình | Số Lượng Tham Số | Ví Dụ Điển Hình | |---|---|---| | Mô hình cực nhỏ | < 100 triệu | DistilBERT, TinyBERT | | Mô hình nhỏ | 100M – 1B | Phi-1, Gemma 2B | | Mô hình vừa-nhỏ | 1B – 7B | Mistral 7B, Llama 3.2 3B | | Mô hình lớn (LLM) | > 7B | GPT-4, Claude 3, Llama 3 70B | > **Lưu ý:** Ranh giới giữa SLM và LLM không hoàn toàn cố định và vẫn đang được cộng đồng nghiên cứu thảo luận. --- ## 2. Lịch Sử Phát Triển ### Giai Đoạn Tiền Transformer (Trước 2017) - Các mô hình ngôn ngữ truyền thống như **n-gram**, **RNN**, **LSTM** về bản chất đều là "nhỏ" theo tiêu chuẩn hiện đại. - Hiệu suất bị giới hạn bởi khả năng nắm bắt ngữ cảnh dài. ### Kỷ Nguyên BERT và Các Biến Thể (2018–2020) - **BERT (2018):** 110M tham số — được coi là "lớn" vào thời điểm đó, nay là SLM điển hình. - **DistilBERT (2019):** Phiên bản chắt lọc của BERT, nhỏ hơn 40%, nhanh hơn 60% nhưng giữ 97% hiệu suất. - **TinyBERT, MobileBERT:** Tối ưu hóa cho thiết bị di động và edge computing. ### Làn Sóng GPT và Sự Bùng Nổ Quy Mô (2020–2022) - GPT-3 (175B tham số) đánh dấu bước ngoặt trong cuộc đua quy mô. - Cộng đồng nghiên cứu bắt đầu đặt câu hỏi: **"Lớn hơn có thực sự tốt hơn không?"** ### Sự Trỗi Dậy Của SLM Hiện Đại (2023–Nay) - **Microsoft Phi series:** Phi-1 (1.3B), Phi-2 (2.7B), Phi-3 (3.8B) — chứng minh rằng dữ liệu chất lượng cao quan trọng hơn quy mô. - **Google Gemma:** 2B và 7B tham số, hiệu suất cạnh tranh với các mô hình lớn hơn nhiều. - **Meta Llama 3.2:** Các phiên bản 1B và 3B tối ưu cho thiết bị di động. - **Apple OpenELM, Samsung Galaxy AI:** Tích hợp SLM trực tiếp vào thiết bị người dùng. --- ## 3. Kiến Trúc và Kỹ Thuật Cốt Lõi ### 3.1 Kiến Trúc Transformer Tối Ưu Hóa SLM hiện đại không chỉ đơn giản là "thu nhỏ" LLM mà áp dụng nhiều kỹ thuật tối ưu hóa tinh vi: **Grouped Query Attention (GQA)** - Giảm số lượng key-value heads trong cơ chế attention. - Giảm đáng kể bộ nhớ cần thiết trong quá trình inference. - Được áp dụng trong Mistral 7B, Llama 3. **Sliding Window Attention** - Thay vì tính attention trên toàn bộ chuỗi, chỉ tính trong một cửa sổ cố định. - Giảm độ phức tạp từ O(n²) xuống O(n × window_size). **Rotary Position Embedding (RoPE)** - Mã hóa vị trí hiệu quả hơn, hỗ trợ context window dài hơn. - Được sử dụng rộng rãi trong các SLM hiện đại. ### 3.2 Kỹ Thuật Nén Mô Hình **Knowledge Distillation (Chắt Lọc Tri Thức)** ``` Teacher Model (LLM lớn) ↓ Soft Labels + Hidden States ↓ Student Model (SLM nhỏ) ``` - Mô hình "học sinh" học từ đầu ra xác suất của mô hình "giáo viên". - Ví dụ: DistilGPT-2 học từ GPT-2. **Quantization (Lượng Tử Hóa)** - **INT8:** Giảm kích thước mô hình 50%, mất mát hiệu suất tối thiểu. - **INT4/GPTQ:** Giảm 75%, phù hợp cho thiết bị edge. - **GGUF format:** Phổ biến trong cộng đồng llama.cpp. **Pruning (Cắt Tỉa)** - Loại bỏ các trọng số hoặc attention heads ít quan trọng. - **Structured pruning:** Loại bỏ toàn bộ layer hoặc neuron. - **Unstructured pruning:** Đặt các trọng số nhỏ về 0. **Low-Rank Factorization** - Phân tích ma trận trọng số thành tích của các ma trận nhỏ hơn. - Cơ sở của kỹ thuật **LoRA** trong fine-tuning. ### 3.3 Chiến Lược Dữ Liệu Huấn Luyện Một trong những đột phá quan trọng nhất của SLM hiện đại là nhận thức rằng **chất lượng dữ liệu quan trọng hơn số lượng**: **Phi-1 và "Textbook Quality Data"** - Microsoft huấn luyện Phi-1 (1.3B) chủ yếu trên dữ liệu tổng hợp chất lượng cao. - Đạt hiệu suất vượt trội so với các mô hình lớn hơn nhiều trên benchmark lập trình. **Data Curation Pipeline** ``` Raw Data → Filtering → Deduplication → Quality Scoring → Synthetic Augmentation → Training ``` --- ## 4. Ưu Điểm Của SLM ### 4.1 Hiệu Quả Chi Phí | Chi Phí | LLM (GPT-4) | SLM (Phi-3 Mini) | |---|---|---| | Inference/1M tokens | ~$30 | ~$0.1 | | Hosting hàng tháng | $10,000+ | $100–500 | | Fine-tuning | $50,000+ | $500–2,000 | ### 4.2 Triển Khai On-Device SLM có thể chạy trực tiếp trên: - **Smartphone:** iPhone (Apple Neural Engine), Android (Qualcomm NPU) - **Laptop:** CPU/GPU thông thường không cần cloud - **IoT Devices:** Raspberry Pi, NVIDIA Jetson - **Edge Servers:** Không cần kết nối internet liên tục ### 4.3 Độ Trễ Thấp (Low Latency) - SLM 7B có thể tạo ra **50–100 tokens/giây** trên GPU consumer-grade. - LLM 70B+ thường chỉ đạt **5–15 tokens/giây** trên phần cứng tương đương. - Quan trọng trong các ứng dụng real-time như chatbot, coding assistant. ### 4.4 Bảo Mật và Quyền Riêng Tư - Dữ liệu không cần gửi lên cloud → **không rò rỉ thông tin nhạy cảm**. - Phù hợp với các ngành có yêu cầu tuân thủ nghiêm ngặt: y tế, tài chính, pháp lý. - Hoạt động trong môi trường **air-gapped** (không có internet). ### 4.5 Khả Năng Fine-Tuning Dễ Dàng - Fine-tune SLM 7B chỉ cần **1–2 GPU A100** trong vài giờ. - Kỹ thuật **LoRA/QLoRA** cho phép fine-tune trên GPU consumer (RTX 3090, 4090). - Dễ dàng tùy chỉnh cho domain cụ thể với dữ liệu hạn chế. --- ## 5. Hạn Chế Của SLM ### 5.1 Khả Năng Suy Luận Phức Tạp - SLM gặp khó khăn với các bài toán đòi hỏi **multi-step reasoning** phức tạp. - Hiệu suất trên các benchmark như MATH, GSM8K thường thấp hơn LLM. - Khó xử lý các tác vụ đòi hỏi kiến thức chuyên sâu đa lĩnh vực. ### 5.2 Context Window Hạn Chế - Nhiều SLM chỉ hỗ trợ context window **2K–8K tokens**. - Không phù hợp cho các tác vụ xử lý tài liệu dài. - Tuy nhiên, xu hướng mới đang mở rộng context window của SLM. ### 5.3 Hallucination Cao Hơn - SLM có xu hướng "bịa đặt" thông tin nhiều hơn do kiến thức hạn chế. - Cần kết hợp với **RAG (Retrieval-Augmented Generation)** để cải thiện độ chính xác. ### 5.4 Đa Ngôn Ngữ Hạn Chế - Hầu hết SLM được tối ưu cho tiếng Anh. - Hiệu suất trên các ngôn ngữ ít tài nguyên (low-resource languages) thường kém. --- ## 6. Các SLM Nổi Bật Hiện Nay ### Microsoft Phi Series **Phi-3 Mini (3.8B)** - Hiệu suất tương đương Mixtral 8x7B trên nhiều benchmark. - Hỗ trợ context window 128K tokens. - Tối ưu cho thiết bị di động và edge. **Phi-3.5 MoE** - Kiến trúc Mixture of Experts với 16 experts. - Cân bằng giữa hiệu suất và hiệu quả tính toán. ### Google Gemma Series **Gemma 2 (2B và 9B)** - Dựa trên kiến thức từ Gemini. - Hiệu suất state-of-the-art trong phân khúc kích thước tương ứng. - Giấy phép thương mại tự do. ### Meta Llama Series **Llama 3.2 (1B và 3B)** - Tối ưu đặc biệt cho on-device deployment. - Hỗ trợ multimodal (vision) trong phiên bản 11B và 90B. ### Mistral Series **Mistral 7B** - Mô hình open-source benchmark đầu tiên chứng minh SLM có thể cạnh tranh với LLM lớn hơn. - Sliding Window Attention và GQA. **Mistral Nemo (12B)** - Hợp tác với NVIDIA. - Context window 128K tokens. ### Apple OpenELM - Được thiết kế đặc biệt cho Apple Silicon. - Các phiên bản: 270M, 450M, 1.1B, 3B. - Tối ưu cho Neural Engine trên iPhone và Mac. --- ## 7. Ứng Dụng Thực Tiễn ### 7.1 Coding Assistant SLM đặc biệt hiệu quả trong hỗ trợ lập trình: - **GitHub Copilot** sử dụng các mô hình tối ưu hóa cho code completion. - **Cursor, Continue.dev:** Tích hợp SLM local cho privacy-first coding. - **Phi-1/Phi-2:** Được thiết kế đ

The past few years have been a blast for artificial intelligence, with large language models (LLMs) stunning everyone with their capabilities and powe

1 ngày trước 🇻🇳 VI
Hugging

# makeMoE: Triển Khai Mô Hình Ngôn Ngữ Sparse Mixture of Experts từ Đầu ## Giới Thiệu Trong bài viết này, chúng ta sẽ triển khai một mô hình ngôn ngữ **Sparse Mixture of Experts (MoE)** từ đầu, lấy cảm hứng từ dự án **makemore** của Andrej Karpathy. Mục tiêu là xây dựng một mô hình có thể hiểu và tái tạo được, đồng thời minh họa các khái niệm cốt lõi của kiến trúc MoE. --- ## Mixture of Experts là gì? **Mixture of Experts** là một kỹ thuật trong học máy trong đó nhiều mạng con chuyên biệt ("experts") được kết hợp lại. Thay vì kích hoạt toàn bộ mô hình cho mỗi token đầu vào, **Sparse MoE** chỉ kích hoạt một tập con nhỏ các experts, giúp: - ✅ Tăng dung lượng mô hình mà không tăng chi phí tính toán tương ứng - ✅ Mỗi expert chuyên biệt hóa cho các loại đầu vào khác nhau - ✅ Hiệu quả tính toán cao hơn so với mô hình dày đặc (dense model) --- ## Kiến Trúc Tổng Quan ``` Input Tokens │ ▼ Token Embedding + Positional Embedding │ ▼ ┌─────────────────────────────┐ │ Transformer Block │ │ ┌───────────────────────┐ │ │ │ Multi-Head Attention │ │ │ └───────────────────────┘ │ │ │ │ │ ┌───────────────────────┐ │ │ │ Sparse MoE Layer │ │ │ │ ┌─────────────────┐ │ │ │ │ │ Router/Gate │ │ │ │ │ └────────┬────────┘ │ │ │ │ ┌──────┴──────┐ │ │ │ │ Expert1 Expert2 ... │ │ │ └───────────────────────┘ │ └─────────────────────────────┘ │ ▼ Language Model Head │ ▼ Output Logits ``` --- ## Các Thành Phần Chính ### 1. Noisy Top-K Gating (Cổng Top-K có Nhiễu) Đây là trái tim của kiến trúc MoE. Router quyết định expert nào được kích hoạt: ```python import torch import torch.nn as nn import torch.nn.functional as F class NoisyTopKGating(nn.Module): """ Noisy Top-K Gating theo paper 'Outrageously Large Neural Networks' của Shazeer et al., 2017 """ def __init__(self, n_embed, num_experts, top_k, noise_std=1.0): super().__init__() self.num_experts = num_experts self.top_k = top_k self.noise_std = noise_std # Ma trận trọng số cho gate self.W_gate = nn.Linear(n_embed, num_experts, bias=False) # Ma trận trọng số cho nhiễu self.W_noise = nn.Linear(n_embed, num_experts, bias=False) def forward(self, x): """ Args: x: tensor shape (batch_size * seq_len, n_embed) Returns: gates: trọng số cho mỗi expert load: tải trọng của mỗi expert (dùng cho auxiliary loss) """ # Tính logits sạch clean_logits = self.W_gate(x) # (N, num_experts) # Thêm nhiễu trong quá trình training if self.training: noise = torch.randn_like(clean_logits) noise_logits = self.W_noise(x) noise_std = F.softplus(noise_logits) + 1e-2 noisy_logits = clean_logits + noise * noise_std * self.noise_std else: noisy_logits = clean_logits # Lấy top-k experts top_k_logits, top_k_indices = noisy_logits.topk( self.top_k, dim=-1 ) # Tạo mask: chỉ giữ top-k, còn lại là -inf zeros = torch.full_like(noisy_logits, float('-inf')) sparse_logits = zeros.scatter(-1, top_k_indices, top_k_logits) # Softmax để chuẩn hóa gates = F.softmax(sparse_logits, dim=-1) return gates, top_k_indices ``` ### 2. Expert Network Mỗi expert là một mạng Feed-Forward đơn giản: ```python class Expert(nn.Module): """ Một expert đơn lẻ - về cơ bản là một FFN (Feed-Forward Network) """ def __init__(self, n_embed, dropout=0.1): super().__init__() self.net = nn.Sequential( nn.Linear(n_embed, 4 * n_embed), nn.ReLU(), nn.Linear(4 * n_embed, n_embed), nn.Dropout(dropout), ) def forward(self, x): return self.net(x) ``` ### 3. Sparse MoE Layer Kết hợp router và các experts: ```python class SparseMoE(nn.Module): """ Sparse Mixture of Experts Layer """ def __init__(self, n_embed, num_experts, top_k, dropout=0.1): super().__init__() self.num_experts = num_experts self.top_k = top_k # Khởi tạo các experts self.experts = nn.ModuleList([ Expert(n_embed, dropout) for _ in range(num_experts) ]) # Khởi tạo router self.gate = NoisyTopKGating(n_embed, num_experts, top_k) def forward(self, x): """ Args: x: (batch_size, seq_len, n_embed) Returns: output: (batch_size, seq_len, n_embed) aux_loss: auxiliary loss để cân bằng tải """ batch_size, seq_len, n_embed = x.shape # Reshape để xử lý từng token độc lập x_flat = x.view(-1, n_embed) # (B*T, n_embed) num_tokens = x_flat.shape[0] # Lấy trọng số từ router gates, top_k_indices = self.gate(x_flat) # gates: (num_tokens, num_experts) - sparse # Khởi tạo output output = torch.zeros_like(x_flat) # Xử lý từng expert for expert_idx, expert in enumerate(self.experts): # Tìm các token được gán cho expert này token_mask = (top_k_indices == expert_idx).any(dim=-1) if not token_mask.any(): continue # Lấy các token tương ứng expert_input = x_flat[token_mask] # Chạy qua expert expert_output = expert(expert_input) # Lấy trọng số gate cho expert này expert_gates = gates[token_mask, expert_idx].unsqueeze(-1) # Cộng có trọng số vào output output[token_mask] += expert_gates * expert_output # Reshape về kích thước ban đầu output = output.view(batch_size, seq_len, n_embed) # Tính auxiliary loss để cân bằng tải giữa các experts aux_loss = self._compute_auxiliary_loss(gates) return output, aux_loss def _compute_auxiliary_loss(self, gates): """ Auxiliary loss để đảm bảo các experts được sử dụng đều nhau. Tránh hiện tượng 'expert collapse' - chỉ một vài experts được dùng. L_aux = num_experts * sum(f_i * P_i) trong đó: f_i = tỷ lệ token được gán cho expert i P_i = xác suất trung bình expert i được chọn """ # Tỷ lệ token được gán cho mỗi expert # gates > 0 nghĩa là expert đó được kích hoạt expert_usage = (gates > 0).float().mean(dim=0) # (num_experts,) # Xác suất trung bình expert_probs = gates.mean(dim=0) # (num_experts,) # Auxiliary loss aux_loss = self.num_experts * (expert_usage * expert_probs).sum() return aux_loss ``` ### 4. Multi-Head Self-Attention ```python class MultiHeadAttention(nn.Module): """ Multi-Head Self-Attention với causal masking """ def __init__(self, n_embed, n_heads, block_size, dropout=0.1): super().__init__() assert n_embed % n_heads == 0 self.n_heads = n_heads self.head_size = n_embed // n_heads # Projection cho Q, K, V self.qkv_proj = nn.Linear(n_embed, 3 * n_embed, bias=False) self.out_proj = nn.Linear(n_embed, n_embed, bias=False) self.attn_dropout = nn.Dropout(dropout) self.resid_dropout = nn.Dropout(dropout) # Causal mask self.register_buffer( 'mask', torch.tril(torch.ones(block_size, block_size)) .view(1, 1, block_size, block_size) ) def forward(self, x): B, T, C = x.shape # Tính Q, K, V qkv = self.qkv_proj(x) q, k, v = qkv.split(C, dim=-1) # Reshape cho multi-head q = q.view(B, T, self.n_heads, self.head_size).transpose(1, 2) k = k.view(B, T, self.n_heads, self.head_size).transpose(1, 2) v = v.view(B, T, self.n_heads, self.head_size).transpose(1, 2) # Attention scores scale = self.head_size ** -0.5 attn = (q @ k.transpose(-2, -1)) * scale # Áp dụng causal mask attn = attn.masked_fill(self.mask[:, :, :T, :T] == 0, float('-inf')) attn = F.softmax(attn, dim=-1) attn = self.attn_dropout(attn) # Weighted sum out = attn @ v # (B, n_heads, T, head_size) out = out.transpose(1, 2).contiguous().view(B, T, C) return self.resid_dropout(self.out_proj(out)) ``` ### 5. Transformer Block với MoE ```python class MoETransformerBlock(nn.Module): """ Transformer Block thay thế FFN bằng Sparse MoE Layer """ def __init__(self, n_embed, n_heads, num_experts, top_k, block_size, dropout=0.1): super().__init__() # Layer Normalization self.ln1 = nn.LayerNorm(n_embed) self.ln2 = nn.LayerNorm(n_embed) # Multi-Head Attention self.attention = MultiHeadAttention( n_embed, n_heads, block_size, dropout ) # Sparse MoE thay cho FFN thông thường self.moe = SparseMoE(n_embed, num_experts, top_k, dropout) def forward(self, x): # Self-attention với residual connection x = x + self.attention(self.ln1(x)) # MoE với residual connection moe_out, aux_loss = self.moe(self.ln2(x)) x = x + moe_out return x, aux_loss ``` ### 6. Mô Hình MoE Hoàn Chỉnh ```python class MakeMoE(nn.Module): """ Mô hình ngôn ngữ Sparse Mixture of Experts hoàn chỉnh """ def __init__( self, vocab_size, n_embed=256, n_heads=8, n_layers=6, num_experts=8, top_k=2, block_size=256, dropout=0.1 ): super().__init__() self.block_size = block_size # Embeddings self.token_embedding = nn.Embedding(vocab_size, n_embed) self.position_embedding = nn.Embedding(block_size, n_embed) self.dropout = nn.Dropout(dropout) # Transformer blocks với MoE self.blocks = nn.ModuleList([ MoETransformerBlock( n_embed, n_heads, num_experts, top_k, block_size, dropout ) for _ in range(n_layers) ]) # Final layer norm self.ln_final = nn.LayerNorm(n_embed) # Language model head self.lm_head = nn.Linear(n_embed, vocab_size, bias=False) # Weight tying self.token_embedding.weight = self.lm_head.weight # Khởi tạo trọng số self.apply(self._init_weights) def _init_weights(self, module): if isinstance(module, nn.Linear): nn.init.normal_(module.weight, mean=0.0, std=0.02) if module.bias is not None: nn.init.zeros_(module.

The Github repo here provides the end-to-end implementation:https://github.com/AviSoori1x/makeMoE/tree/main With the release of Mixtral and talk of G

1 ngày trước 🇻🇳 VI
Hugging

# VKUE: Không có GPU? Vẫn chạy được — Mô hình Reasoning 34,7 tỷ tham số trên Laptop và CPU thuần túy

You need a datacenter GPU to run a frontier-class model — mostly true. But that assumption rests on another one: that the modelreads all of its parame

1 ngày trước 🇻🇳 VI
Hugging

# Chưng cất kiến thức năm 2026 (cho đến nay): Những mô hình frontier nào sử dụng và như thế nào Chưng cất kiến thức (distillation) — kỹ thuật huấn luyện một mô hình nhỏ hơn ("học sinh") để bắt chước đầu ra của mô hình lớn hơn ("giáo viên") — đã trở thành một trong những công cụ quan trọng nhất trong kho vũ khí của AI hiện đại. Đến năm 2026, hầu hết các mô hình frontier đều sử dụng một dạng chưng cất nào đó, dù không phải lúc nào cũng được công bố rõ ràng. --- ## Tại sao chưng cất lại quan trọng đến vậy? Trước khi đi vào chi tiết từng mô hình, cần hiểu lý do kỹ thuật này bùng nổ: - **Chi phí suy luận giảm mạnh**: Mô hình nhỏ hơn chạy nhanh hơn và rẻ hơn - **Hiệu suất bất ngờ cao**: Mô hình học sinh thường đạt 90–95% hiệu suất của giáo viên với chỉ 10–20% tham số - **Dữ liệu tổng hợp chất lượng cao**: Các mô hình frontier tạo ra dữ liệu huấn luyện tốt hơn con người gán nhãn trong nhiều tác vụ - **Vòng lặp tự cải thiện**: Mô hình có thể chưng cất chính nó qua nhiều thế hệ --- ## Các mô hình frontier và cách họ sử dụng chưng cất ### 1. **Dòng DeepSeek-R1 (DeepSeek AI)** DeepSeek có lẽ là ví dụ minh bạch nhất về chưng cất trong năm 2025–2026. **Cách thức:** - DeepSeek-R1 (mô hình đầy đủ 671B) được huấn luyện bằng reinforcement learning thuần túy - Sau đó, DeepSeek **công khai** chưng cất R1 thành các mô hình nhỏ hơn: R1-Distill-Qwen-1.5B, 7B, 14B, 32B và R1-Distill-Llama-70B - Dữ liệu chưng cất gồm ~800.000 mẫu suy luận dài (chain-of-thought) được tạo bởi R1 **Kết quả đáng chú ý:** - R1-Distill-Qwen-7B vượt qua GPT-4o trên nhiều benchmark toán học - R1-Distill-Llama-70B cạnh tranh ngang ngửa với o1 của OpenAI trên AIME 2024 **Điểm đặc biệt:** DeepSeek phát hành trọng số mở, cho phép cộng đồng nghiên cứu và tiếp tục chưng cất thêm. --- ### 2. **Dòng GPT-4o Mini và các mô hình nhỏ của OpenAI** OpenAI không công bố chi tiết kỹ thuật, nhưng có nhiều bằng chứng gián tiếp: **Những gì được biết:** - GPT-4o Mini được mô tả là "hiệu quả hơn đáng kể" so với GPT-3.5 Turbo trong khi rẻ hơn nhiều - OpenAI đã từng công bố kỹ thuật chưng cất từ thời GPT-2/3, và nhiều khả năng tiếp tục áp dụng - **o1 và o3**: Các mô hình reasoning này tạo ra dữ liệu chain-of-thought có thể được dùng để chưng cất vào các mô hình nhỏ hơn **Dữ liệu tổng hợp:** OpenAI ngày càng sử dụng đầu ra của GPT-4 và o-series để tạo dữ liệu huấn luyện cho các mô hình thế hệ sau — một dạng **chưng cất thế hệ** (generational distillation). --- ### 3. **Gemini Flash (Google DeepMind)** Google là một trong những công ty tiên phong trong chưng cất với bài báo gốc năm 2015. **Gemini 1.5 Flash và 2.0 Flash:** - Được xây dựng rõ ràng như các phiên bản "chưng cất" của Gemini Pro/Ultra - Google mô tả Flash là được tối ưu hóa thông qua "knowledge distillation từ các mô hình Gemini lớn hơn" - Gemini 2.0 Flash Thinking — phiên bản reasoning — kết hợp chưng cất với fine-tuning để suy luận **Kết quả:** - Gemini 2.0 Flash đạt hiệu suất gần bằng Gemini 1.5 Pro với chi phí thấp hơn ~10 lần - Độ trễ (latency) giảm đáng kể, phù hợp cho ứng dụng thời gian thực --- ### 4. **Llama 3 và các mô hình Meta** Meta áp dụng chưng cất theo nhiều tầng: **Llama 3.1 và 3.2:** - Các mô hình nhỏ (1B, 3B trong Llama 3.2) được chưng cất từ Llama 3.1 405B - Meta công bố sử dụng **"pruning + distillation"**: cắt tỉa mô hình lớn rồi chưng cất để phục hồi hiệu suất - Dữ liệu tổng hợp từ 405B được dùng để fine-tune các mô hình nhỏ hơn **Llama 3.3 70B:** - Đạt hiệu suất tương đương Llama 3.1 405B trên nhiều tác vụ - Được cho là sử dụng dữ liệu tổng hợp từ 405B kết hợp với RLHF cải tiến --- ### 5. **Phi-4 và dòng Phi (Microsoft)** Microsoft Research đã xây dựng toàn bộ dòng Phi xung quanh triết lý "dữ liệu chất lượng cao hơn dữ liệu nhiều": **Phi-4 (14B tham số):** - Sử dụng **chưng cất dữ liệu tổng hợp** quy mô lớn từ GPT-4 - ~50% dữ liệu huấn luyện là tổng hợp, được tạo ra để bao phủ các trường hợp suy luận khó - Kỹ thuật "pivoting": dùng GPT-4 để viết lại và cải thiện dữ liệu web thô **Kết quả ấn tượng:** - Phi-4 (14B) vượt qua Llama 3.3 70B và Qwen 2.5 72B trên nhiều benchmark STEM - Chứng minh rằng chưng cất dữ liệu có thể bù đắp cho kích thước mô hình nhỏ hơn --- ### 6. **Qwen 2.5 và QwQ (Alibaba)** Alibaba đã tích cực áp dụng chưng cất trong năm 2025–2026: **QwQ-32B:** - Mô hình reasoning 32B cạnh tranh với o1 của OpenAI - Được huấn luyện một phần bằng cách chưng cất từ các mô hình reasoning lớn hơn - Sử dụng dữ liệu chain-of-thought tổng hợp quy mô lớn **Qwen 2.5 Coder:** - Chưng cất từ Qwen 2.5 72B kết hợp với dữ liệu code tổng hợp - Các phiên bản 1.5B và 3B đạt hiệu suất đáng ngạc nhiên trên HumanEval --- ### 7. **Claude (Anthropic)** Anthropic ít công bố chi tiết kỹ thuật nhất, nhưng: **Những gì có thể suy luận:** - Claude Haiku rõ ràng là phiên bản nhỏ hơn, nhanh hơn của dòng Claude — nhiều khả năng sử dụng chưng cất - Anthropic đã công bố nghiên cứu về **Constitutional AI** kết hợp với RLHF, có thể tích hợp chưng cất - Dữ liệu tổng hợp từ Claude Opus/Sonnet có thể được dùng để huấn luyện Haiku --- ## Các xu hướng chưng cất nổi bật năm 2026 ### **1. Chưng cất reasoning (Reasoning Distillation)** Xu hướng lớn nhất: chưng cất không chỉ đầu ra cuối cùng mà cả **quá trình suy luận** (chain-of-thought). DeepSeek-R1 đã chứng minh rằng một mô hình 7B có thể học cách "suy nghĩ dài" từ mô hình 671B. ### **2. Chưng cất đặc thù tác vụ (Task-Specific Distillation)** Thay vì chưng cất toàn bộ khả năng, các công ty tập trung chưng cất cho tác vụ cụ thể: code, toán học, y tế... ### **3. Vòng lặp tự chưng cất (Self-Distillation Loops)** Mô hình tạo dữ liệu → lọc dữ liệu tốt → huấn luyện lại → lặp lại. Kỹ thuật này được gọi là **iterative self-improvement** hay **self-play distillation**. ### **4. Chưng cất đa mô thức (Multimodal Distillation)** Chưng cất từ mô hình vision-language lớn sang mô hình nhỏ hơn, đặc biệt quan trọng cho thiết bị edge. ### **5. Speculative Decoding như một dạng chưng cất** Kỹ thuật dùng mô hình nhỏ để "đoán trước" token và mô hình lớn để xác nhận — một dạng chưng cất ngầm trong quá trình suy luận. --- ## Những tranh cãi và thách thức ### **Vấn đề bản quyền dữ liệu** Khi một công ty dùng đầu ra của GPT-4 để huấn luyện mô hình của mình, điều này có vi phạm điều khoản sử dụng của OpenAI không? OpenAI cấm điều này trong ToS, nhưng việc thực thi rất khó. ### **"Collapse" của chưng cất nhiều thế hệ** Nghiên cứu cho thấy nếu chưng cất qua quá nhiều thế hệ (mô hình học từ mô hình học từ mô hình...), chất lượng có thể suy giảm — hiện tượng gọi là **model collapse**. ### **Đánh giá thực sự khó** Mô hình được chưng cất có thể "học vẹt" benchmark thay vì học khả năng thực sự, làm méo mó kết quả đánh giá. --- ## Tóm tắt: Ai dùng gì | Công ty | Mô hình | Loại chưng cất | Mức độ công khai | |---------|---------|----------------|-----------------| | DeepSeek | R1-Distill series | Chưng cất reasoning từ R1 671B | **Rất cao** | | Google | Gemini Flash | Chưng cất từ Pro/Ultra | **Cao** | | Meta | Llama 3.2 1B/3B | Pruning + distillation từ 405B | **Cao** | | Microsoft | Phi-4 | Dữ liệu tổng hợp từ GPT-4 | **Cao** | | Alibaba | QwQ-32B, Qwen 2.5 nhỏ | Chưng cất reasoning | **Trung bình** | | OpenAI | GPT-4o Mini | Không công bố rõ | **Thấp** | | Anthropic | Claude Haiku | Không công bố rõ | **Rất thấp** | --- ## Kết luận Chưng cất kiến thức đã chuyển từ một kỹ thuật tối ưu hóa thành **chiến lược cốt lõi** trong phát triển AI frontier. Năm 2026, ranh giới giữa "mô hình gốc" và "mô hình chưng cất" ngày càng mờ nhạt — hầu hết các mô hình đều là sản phẩm của nhiều vòng chưng cất, tổng hợp dữ liệu, và tự cải thiện. Câu hỏi không còn là "có nên dùng chưng cất không?" mà là "chưng cất cái gì, từ ai, và bao nhiêu thế hệ?"

This article is complementary material forClass 2: Distillationof theTraining an Agentseries Ben and I are doing, where we teach the post-training tec

1 ngày trước 🇻🇳 VI
Hugging

# Các Mô Hình LLM Mã Nguồn Mở và Open-Weight Tốt Nhất để Chạy Cục Bộ vào Năm 2026 --- ## Tổng Quan Hệ sinh thái LLM mã nguồn mở đã phát triển vượt bậc, mang đến cho các nhà phát triển, nhà nghiên cứu và người dùng cá nhân khả năng chạy các mô hình ngôn ngữ mạnh mẽ ngay trên phần cứng của riêng mình — không cần phụ thuộc vào API đám mây hay lo ngại về quyền riêng tư dữ liệu. Dưới đây là danh sách tổng hợp những mô hình đáng chú ý nhất tính đến năm 2026. --- ## 🏆 Các Mô Hình Hàng Đầu ### 1. **Meta LLaMA 4 Scout & Maverick** - **Tham số:** Scout (17B MoE), Maverick (17B MoE) - **Giấy phép:** LLaMA 4 Community License - **Điểm mạnh:** Kiến trúc Mixture-of-Experts (MoE), hỗ trợ đa phương thức (văn bản + hình ảnh), cửa sổ ngữ cảnh lên đến 10 triệu token (Scout) - **Phù hợp với:** Lập trình, phân tích, hội thoại đa vòng - **Yêu cầu phần cứng:** GPU 24GB VRAM (phiên bản lượng tử hóa) --- ### 2. **Mistral Small 3.1 & Mistral Large** - **Tham số:** 24B (Small 3.1), 123B (Large) - **Giấy phép:** Apache 2.0 (Small), Mistral Research License (Large) - **Điểm mạnh:** Hiệu suất cao trên phần cứng tiêu dùng, hỗ trợ đa ngôn ngữ xuất sắc, tốc độ suy luận nhanh - **Phù hợp với:** Ứng dụng doanh nghiệp, RAG pipeline, tác vụ đa ngôn ngữ - **Yêu cầu phần cứng:** 16GB VRAM (Small 3.1 Q4) --- ### 3. **Google Gemma 3** - **Tham số:** 1B, 4B, 12B, 27B - **Giấy phép:** Gemma Terms of Use - **Điểm mạnh:** Tối ưu hóa cho thiết bị edge, hỗ trợ đa phương thức, hiệu suất vượt trội so với kích thước - **Phù hợp với:** Triển khai trên thiết bị di động, ứng dụng nhúng, fine-tuning - **Yêu cầu phần cứng:** Từ 4GB RAM (phiên bản 1B) --- ### 4. **Qwen 2.5 & Qwen 3** - **Tham số:** 0.5B đến 72B (Qwen 2.5); 0.6B đến 235B MoE (Qwen 3) - **Giấy phép:** Apache 2.0 - **Điểm mạnh:** Hỗ trợ 100+ ngôn ngữ, khả năng lập trình xuất sắc (Qwen-Coder), tư duy mở rộng (Qwen3 thinking mode) - **Phù hợp với:** Lập trình, toán học, đa ngôn ngữ, agent AI - **Yêu cầu phần cứng:** Từ 4GB VRAM (phiên bản nhỏ) --- ### 5. **DeepSeek R2 & DeepSeek V3** - **Tham số:** V3 (671B MoE), R2 (chưa công bố chính thức) - **Giấy phép:** MIT (V3) - **Điểm mạnh:** Khả năng lập trình và toán học đẳng cấp thế giới, kiến trúc MoE hiệu quả, chi phí huấn luyện thấp đột phá - **Phù hợp với:** Nghiên cứu, lập trình nâng cao, suy luận phức tạp - **Yêu cầu phần cứng:** Cần cụm GPU mạnh (phiên bản đầy đủ); phiên bản Q4 nhỏ hơn khả thi hơn --- ### 6. **Microsoft Phi-4** - **Tham số:** 14B - **Giấy phép:** MIT - **Điểm mạnh:** Hiệu suất vượt trội so với kích thước nhỏ gọn, xuất sắc trong toán học và lập trình, lý tưởng cho phần cứng hạn chế - **Phù hợp với:** Laptop, máy tính cá nhân, ứng dụng nhúng - **Yêu cầu phần cứng:** 8–16GB VRAM --- ### 7. **Falcon 3** - **Tham số:** 1B, 3B, 7B, 10B - **Giấy phép:** TII Falcon License (thương mại tự do) - **Điểm mạnh:** Được tối ưu hóa cho phần cứng tiêu dùng, hỗ trợ đa ngôn ngữ tốt, cộng đồng hoạt động tích cực - **Phù hợp với:** Người mới bắt đầu, thử nghiệm nhanh - **Yêu cầu phần cứng:** Từ 4GB VRAM --- ### 8. **Ollama + Open Hermes / Nous Hermes** - **Tham số:** Nhiều biến thể (7B–70B) - **Giấy phép:** Phụ thuộc vào mô hình gốc - **Điểm mạnh:** Được fine-tune cho hội thoại và tuân theo hướng dẫn, dễ triển khai qua Ollama - **Phù hợp với:** Chatbot cá nhân, trợ lý AI tại nhà --- ## 🛠️ Các Mô Hình Chuyên Biệt ### Lập Trình (Coding) | Mô Hình | Tham Số | Điểm Nổi Bật | |---------|---------|--------------| | **Qwen2.5-Coder** | 7B–32B | Hỗ trợ 92 ngôn ngữ lập trình | | **DeepSeek-Coder V2** | 16B–236B | Benchmark coding hàng đầu | | **CodeLlama** | 7B–70B | Tích hợp tốt với IDE | | **StarCoder 2** | 3B–15B | Dữ liệu huấn luyện minh bạch | ### Đa Phương Thức (Multimodal) | Mô Hình | Khả Năng | Giấy Phép | |---------|---------|-----------| | **LLaVA 1.6** | Văn bản + Hình ảnh | Apache 2.0 | | **Gemma 3 Vision** | Văn bản + Hình ảnh | Gemma ToU | | **Qwen2.5-VL** | Văn bản + Hình ảnh + Video | Apache 2.0 | ### Suy Luận (Reasoning) | Mô Hình | Điểm Mạnh | Ghi Chú | |---------|-----------|---------| | **DeepSeek R1** | Toán học, logic | MIT License | | **Qwen3 (Thinking Mode)** | Suy luận chuỗi | Apache 2.0 | | **Phi-4 Reasoning** | STEM, lập trình | MIT License | --- ## 💻 Hướng Dẫn Chọn Mô Hình Theo Phần Cứng ### Máy Tính Phổ Thông (8GB RAM, Không GPU) - ✅ Phi-4 (Q4 quantized) - ✅ Gemma 3 4B - ✅ Qwen2.5 7B (Q4) - ✅ Mistral 7B (Q4) ### GPU Tầm Trung (8–16GB VRAM) - ✅ LLaMA 4 Scout (Q4) - ✅ Mistral Small 3.1 - ✅ Qwen2.5 14B–32B - ✅ DeepSeek-Coder V2 16B ### GPU Cao Cấp (24GB+ VRAM) - ✅ LLaMA 4 Maverick - ✅ Qwen2.5 72B (Q4) - ✅ Mistral Large (Q4) ### Cụm GPU / Máy Chủ - ✅ DeepSeek V3 (đầy đủ) - ✅ LLaMA 4 Behemoth (khi phát hành) - ✅ Qwen3 235B MoE --- ## 🔧 Công Cụ Triển Khai Phổ Biến | Công Cụ | Mô Tả | Phù Hợp Với | |---------|-------|-------------| | **Ollama** | Chạy LLM cục bộ dễ dàng | Người dùng cá nhân | | **LM Studio** | Giao diện đồ họa thân thiện | Người mới bắt đầu | | **llama.cpp** | Hiệu suất cao, nhẹ | Nhà phát triển | | **vLLM** | Phục vụ suy luận tốc độ cao | Doanh nghiệp | | **Hugging Face Transformers** | Linh hoạt, đầy đủ tính năng | Nghiên cứu | | **Jan.ai** | Ứng dụng desktop offline | Người dùng cuối | --- ## 📊 So Sánh Tổng Quan ``` Hiệu Suất Tổng Thể (theo kích thước tương đương): DeepSeek V3 > LLaMA 4 Maverick > Qwen3 72B > Mistral Large > Gemma 3 27B > Phi-4 > Mistral Small 3.1 Hiệu Quả (Hiệu suất/Tham số): Phi-4 > Gemma 3 > Qwen2.5 > Mistral Small Tốc Độ Suy Luận (cục bộ): Phi-4 > Gemma 3 4B > Mistral 7B > LLaMA 4 Scout ``` --- ## 🔍 Xu Hướng Nổi Bật Năm 2026 1. **Kiến trúc MoE phổ biến hơn** — Cho phép mô hình lớn chạy hiệu quả trên phần cứng hạn chế 2. **Cửa sổ ngữ cảnh siêu dài** — Nhiều mô hình hỗ trợ 128K–10M token 3. **Đa phương thức là tiêu chuẩn mới** — Hầu hết mô hình mới đều hỗ trợ hình ảnh 4. **Lượng tử hóa tiên tiến** — Q4, Q5, Q8 với mất mát chất lượng tối thiểu 5. **Mô hình suy luận tích hợp** — Thinking mode trở thành tính năng phổ biến --- ## ✅ Khuyến Nghị Cuối Cùng | Mục Đích | Mô Hình Khuyến Nghị | |---------|---------------------| | **Bắt đầu nhanh** | Gemma 3 4B hoặc Phi-4 | | **Lập trình** | Qwen2.5-Coder 32B hoặc DeepSeek-Coder V2 | | **Đa ngôn ngữ** | Qwen2.5 72B hoặc Mistral Small 3.1 | | **Suy luận phức tạp** | DeepSeek R1 hoặc Qwen3 (thinking mode) | | **Phần cứng yếu** | Phi-4 hoặc Gemma 3 1B | | **Hiệu suất tối đa** | DeepSeek V3 hoặc LLaMA 4 Maverick | | **Quyền riêng tư tuyệt đối** | Bất kỳ mô hình nào + Ollama (offline) | --- *Hệ sinh thái mã nguồn mở đang phát triển với tốc độ chóng mặt. Hãy theo dõi Hugging Face Open LLM Leaderboard và các cộng đồng như r/LocalLLaMA để cập nhật những mô hình mới nhất.*

Your AI vendor just raised prices again. And every query your app makes is leaving your servers, crossing borders, and landing on infrastructure you

1 ngày trước 🇻🇳 VI
Hugging

# Khi nào thì các mô hình ngôn ngữ sẽ đủ tốt? Đây là câu hỏi mà tôi thấy mình liên tục suy nghĩ, và câu trả lời phụ thuộc rất nhiều vào việc bạn đang hỏi "đủ tốt cho *điều gì*?" ## Đủ tốt cho các tác vụ hiện tại Đối với nhiều ứng dụng — soạn thảo văn bản, tóm tắt, trả lời câu hỏi cơ bản, viết code đơn giản — các LLM **đã đủ tốt rồi**. Vấn đề không còn là năng lực mà là: - Độ tin cậy và tính nhất quán - Chi phí triển khai - Tích hợp vào quy trình làm việc thực tế ## Những khoảng cách vẫn còn tồn tại Các mô hình hiện tại vẫn còn thiếu sót ở: - **Lý luận dài hạn** — duy trì logic nhất quán qua nhiều bước phức tạp - **Độ tin cậy thực tế** — giảm thiểu hallucination trong các lĩnh vực chuyên sâu - **Tự chủ thực sự** — thực hiện các tác vụ nhiều bước mà không cần giám sát - **Hiểu biết nhân quả** — không chỉ nhận diện pattern ## Câu trả lời thực tế "Đủ tốt" là một **đường chân trời di chuyển**. Khi mô hình cải thiện, kỳ vọng cũng tăng theo. Điều quan trọng hơn là xác định rõ ngưỡng cụ thể cho từng use case — thay vì chờ đợi sự hoàn hảo tổng quát. Bạn đang nghĩ đến ứng dụng cụ thể nào?

Maciej Cegłowski's talk "Web Design: The First 100 Years" (which my friendAlecrecently sent to me) does not entirely stand the test of time, but there

1 ngày trước 🇻🇳 VI
Hugging

# Xây Dựng RAG Đơn Giản Từ Đầu ## Tổng Quan Kiến Trúc ``` Tài liệu → Chunking → Embedding → Vector Store ↓ Câu hỏi → Embedding → Tìm kiếm tương đồng → Context → LLM → Câu trả lời ``` ## Cài Đặt Thư Viện ```bash pip install numpy openai tiktoken ``` ## Code Hoàn Chỉnh ```python import numpy as np import json import os from typing import List, Dict, Tuple from openai import OpenAI client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) # ============================================================ # 1. CHUNKING - Chia nhỏ tài liệu # ============================================================ def chunk_text(text: str, chunk_size: int = 200, overlap: int = 50) -> List[str]: """ Chia văn bản thành các đoạn nhỏ có overlap. Args: text: Văn bản đầu vào chunk_size: Số từ mỗi chunk overlap: Số từ overlap giữa các chunk """ words = text.split() chunks = [] start = 0 while start < len(words): end = start + chunk_size chunk = " ".join(words[start:end]) chunks.append(chunk) # Di chuyển với overlap start += chunk_size - overlap if start >= len(words): break return chunks # ============================================================ # 2. EMBEDDING - Chuyển text thành vector # ============================================================ def get_embedding(text: str, model: str = "text-embedding-3-small") -> List[float]: """Tạo embedding vector cho một đoạn text.""" text = text.replace("\n", " ") response = client.embeddings.create(input=[text], model=model) return response.data[0].embedding def get_embeddings_batch(texts: List[str], model: str = "text-embedding-3-small") -> List[List[float]]: """Tạo embeddings cho nhiều text cùng lúc (hiệu quả hơn).""" texts = [t.replace("\n", " ") for t in texts] response = client.embeddings.create(input=texts, model=model) return [item.embedding for item in response.data] # ============================================================ # 3. VECTOR STORE - Lưu trữ và tìm kiếm vector # ============================================================ class SimpleVectorStore: """ Vector store đơn giản sử dụng numpy. Trong thực tế có thể dùng: Pinecone, Weaviate, ChromaDB, FAISS... """ def __init__(self): self.vectors: List[List[float]] = [] self.documents: List[str] = [] self.metadata: List[Dict] = [] def add_documents(self, chunks: List[str], embeddings: List[List[float]], metadata: List[Dict] = None): """Thêm tài liệu và embeddings vào store.""" self.documents.extend(chunks) self.vectors.extend(embeddings) if metadata: self.metadata.extend(metadata) else: self.metadata.extend([{}] * len(chunks)) print(f"✅ Đã thêm {len(chunks)} chunks vào vector store") print(f"📚 Tổng số chunks: {len(self.documents)}") def cosine_similarity(self, vec1: List[float], vec2: List[float]) -> float: """Tính cosine similarity giữa 2 vector.""" v1 = np.array(vec1) v2 = np.array(vec2) dot_product = np.dot(v1, v2) norm1 = np.linalg.norm(v1) norm2 = np.linalg.norm(v2) if norm1 == 0 or norm2 == 0: return 0.0 return dot_product / (norm1 * norm2) def search(self, query_embedding: List[float], top_k: int = 3) -> List[Tuple[str, float, Dict]]: """ Tìm kiếm top_k chunks tương đồng nhất. Returns: List of (document, similarity_score, metadata) """ if not self.vectors: return [] # Tính similarity với tất cả vectors similarities = [ self.cosine_similarity(query_embedding, vec) for vec in self.vectors ] # Lấy top_k indices có similarity cao nhất top_indices = np.argsort(similarities)[::-1][:top_k] results = [] for idx in top_indices: results.append(( self.documents[idx], similarities[idx], self.metadata[idx] )) return results def save(self, filepath: str): """Lưu vector store ra file.""" data = { "vectors": self.vectors, "documents": self.documents, "metadata": self.metadata } with open(filepath, "w", encoding="utf-8") as f: json.dump(data, f, ensure_ascii=False, indent=2) print(f"💾 Đã lưu vector store tại: {filepath}") def load(self, filepath: str): """Tải vector store từ file.""" with open(filepath, "r", encoding="utf-8") as f: data = json.load(f) self.vectors = data["vectors"] self.documents = data["documents"] self.metadata = data["metadata"] print(f"📂 Đã tải {len(self.documents)} chunks từ: {filepath}") # ============================================================ # 4. RAG PIPELINE - Kết hợp tất cả lại # ============================================================ class RAGPipeline: """Pipeline RAG hoàn chỉnh.""" def __init__(self, chunk_size: int = 200, overlap: int = 50, top_k: int = 3): self.vector_store = SimpleVectorStore() self.chunk_size = chunk_size self.overlap = overlap self.top_k = top_k # --- INDEXING PHASE --- def index_document(self, text: str, source: str = "unknown"): """ Xử lý và index một tài liệu. Args: text: Nội dung tài liệu source: Tên/nguồn tài liệu """ print(f"\n📄 Đang index tài liệu: {source}") # Bước 1: Chunking chunks = chunk_text(text, self.chunk_size, self.overlap) print(f"✂️ Đã chia thành {len(chunks)} chunks") # Bước 2: Tạo embeddings print("🔢 Đang tạo embeddings...") embeddings = get_embeddings_batch(chunks) # Bước 3: Lưu vào vector store metadata = [{"source": source, "chunk_id": i} for i in range(len(chunks))] self.vector_store.add_documents(chunks, embeddings, metadata) def index_documents(self, documents: Dict[str, str]): """Index nhiều tài liệu cùng lúc.""" for source, text in documents.items(): self.index_document(text, source) # --- RETRIEVAL PHASE --- def retrieve(self, query: str) -> List[Tuple[str, float, Dict]]: """ Tìm kiếm các chunks liên quan đến query. Returns: List of (chunk, score, metadata) """ # Tạo embedding cho query query_embedding = get_embedding(query) # Tìm kiếm trong vector store results = self.vector_store.search(query_embedding, self.top_k) return results # --- GENERATION PHASE --- def generate(self, query: str, context_chunks: List[Tuple[str, float, Dict]]) -> str: """ Tạo câu trả lời dựa trên query và context. Args: query: Câu hỏi của người dùng context_chunks: Các chunks liên quan từ retrieval """ # Xây dựng context từ các chunks context_parts = [] for i, (chunk, score, meta) in enumerate(context_chunks, 1): source = meta.get("source", "unknown") context_parts.append(f"[Nguồn {i}: {source} | Độ liên quan: {score:.3f}]\n{chunk}") context = "\n\n---\n\n".join(context_parts) # Tạo prompt system_prompt = """Bạn là trợ lý AI hữu ích. Hãy trả lời câu hỏi DỰA TRÊN context được cung cấp. Quy tắc: - Chỉ sử dụng thông tin từ context - Nếu context không đủ thông tin, hãy nói rõ - Trả lời ngắn gọn, chính xác - Trích dẫn nguồn khi cần thiết""" user_prompt = f"""Context: {context} Câu hỏi: {query} Trả lời:""" # Gọi LLM response = client.chat.completions.create( model="gpt-4o-mini", messages=[ {"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt} ], temperature=0.1, # Thấp để câu trả lời nhất quán max_tokens=500 ) return response.choices[0].message.content # --- FULL RAG QUERY --- def query(self, question: str, verbose: bool = True) -> str: """ Thực hiện full RAG pipeline: Retrieve → Augment → Generate. Args: question: Câu hỏi của người dùng verbose: Hiển thị thông tin chi tiết """ if verbose: print(f"\n{'='*60}") print(f"❓ Câu hỏi: {question}") print(f"{'='*60}") # Bước 1: RETRIEVE if verbose: print("\n🔍 Đang tìm kiếm context liên quan...") relevant_chunks = self.retrieve(question) if verbose: print(f"\n📋 Top {len(relevant_chunks)} chunks liên quan:") for i, (chunk, score, meta) in enumerate(relevant_chunks, 1): print(f"\n [{i}] Score: {score:.4f} | Source: {meta.get('source', 'N/A')}") print(f" {chunk[:100]}...") # Bước 2: AUGMENT + GENERATE if verbose: print("\n🤖 Đang tạo câu trả lời...") answer = self.generate(question, relevant_chunks) if verbose: print(f"\n💬 Câu trả lời:\n{answer}") print(f"\n{'='*60}") return answer # ============================================================ # 5. DEMO - Chạy thử # ============================================================ def main(): # Dữ liệu mẫu documents = { "AI_History.txt": """ Trí tuệ nhân tạo (AI) được Alan Turing đề xuất lần đầu vào năm 1950 với bài báo "Computing Machinery and Intelligence". Ông đặt ra câu hỏi "Máy móc có thể suy nghĩ không?" và đề xuất Turing Test. Năm 1956, John McCarthy tổ chức Hội nghị Dartmouth - sự kiện đánh dấu sự ra đời chính thức của AI như một lĩnh vực nghiên cứu. McCarthy cũng là người đặt ra thuật ngữ "Artificial Intelligence". Giai đoạn 1956-1974 được gọi là "Mùa xuân AI" với nhiều tiến bộ vượt bậc. Tuy nhiên, sau đó AI trải qua "Mùa đông AI" (1974-1980) do thiếu tài nguyên tính toán và kỳ vọng quá cao. Deep Learning bùng nổ từ năm 2012 khi AlexNet giành chiến thắng tại ImageNet competition với độ chính xác vượt trội. Đây là bước ngoặt quan trọng cho Computer Vision và AI hiện đại. """, "LLM_Overview.txt": """ Large Language Models (LLM) là các mô hình ngôn ngữ lớn được huấn luyện trên lượng dữ liệu văn bản khổng lồ. GPT (Generative Pre-trained Transformer) của OpenAI là một trong những LLM nổi tiếng nhất. GPT-3 ra mắt năm 2020 với 175 tỷ tham số, tạo ra cuộc cách mạng trong xử lý ngôn ngữ tự nhiên. ChatGPT ra mắt tháng 11/2022 đã thu hút 100 triệu người dùng chỉ trong 2 tháng. Transformer architecture, được giới thiệu trong paper "Attention Is All You Need" năm 2017 bởi nhóm Google Brain, là nền tảng của hầu hết các LLM hiện đại. RAG (Retrieval-Augmented Generation) là kỹ thuật kết hợp LLM với cơ sở kiến thức bên ngoài, giúp mô hình trả lời chính xác hơn và giảm hallucination. """, "Vietnam_Tech.txt": """ Việt Nam đang nổi lên như một trung tâm công nghệ tại Đông Nam Á. Năm 2023, Việt Nam có hơn 4000 doanh nghiệp công nghệ thông tin. VinAI Research là tổ chức nghiên cứu AI hàng đầu Việt Nam, được thành

Recently,Retrieval-Augmented Generation (RAG)has emerged as a powerful paradigm in the field of AI and Large Language Models (LLMs). RAG combines info

1 ngày trước 🇻🇳 VI
Hugging

# Công nghệ tiên tiến nhất trong AI mã nguồn mở cho các tác vụ pháp lý Thụy Sĩ

The model that wins overall is not the best translator. And the best translator is one of the weakest at multiple-choice law questions. So the right q

1 ngày trước 🇻🇳 VI
Hugging

# Dữ liệu cho Agents

Image: Nemotron Post-Training v3 Prompt Atlas Building AI agents is hard, because the real world does not behave like a benchmark. An agent that can

1 ngày trước 🇻🇳 VI
Hugging

# Bỏ kiểm duyệt bất kỳ LLM nào với kỹ thuật abliteration ## Abliteration là gì? Abliteration là một kỹ thuật cho phép **loại bỏ cơ chế từ chối** của các mô hình ngôn ngữ lớn (LLM) mà không cần fine-tune tốn kém. Kỹ thuật này hoạt động bằng cách xác định và vô hiệu hóa "hướng từ chối" (refusal direction) trong không gian kích hoạt (activation space) của mô hình. --- ## Nguyên lý hoạt động ### 1. Tìm "hướng từ chối" Mô hình lưu trữ khái niệm "từ chối" như một **vector trong không gian kích hoạt**. Để tìm vector này: ```python # Thu thập các activation từ hai tập prompt: # - Harmful prompts (bị từ chối) # - Harmless prompts (được trả lời) harmful_activations = [] harmless_activations = [] for prompt in harmful_prompts: activation = get_activation(model, prompt, layer=layer_idx) harmful_activations.append(activation) for prompt in harmless_prompts: activation = get_activation(model, prompt, layer=layer_idx) harmless_activations.append(activation) # Tính hướng từ chối = hiệu trung bình refusal_direction = ( mean(harmful_activations) - mean(harmless_activations) ) refusal_direction = normalize(refusal_direction) ``` ### 2. Chiếu bỏ hướng từ chối ```python def remove_refusal_direction(activation, refusal_dir): """ Loại bỏ thành phần theo hướng từ chối khỏi activation vector """ # Projection: a - (a · r̂) * r̂ projection = torch.dot(activation, refusal_dir) return activation - projection * refusal_dir ``` ### 3. Can thiệp vào trọng số mô hình Thay vì can thiệp lúc inference (tốn tài nguyên), ta **chỉnh sửa trực tiếp trọng số**: ```python def abliterate_model(model, refusal_direction, layers): for layer_idx in layers: # Can thiệp vào W_out của attention W_out = model.layers[layer_idx].self_attn.o_proj.weight # Loại bỏ hướng từ chối khỏi output projection W_out.data -= torch.outer( refusal_direction, W_out @ refusal_direction ) # Tương tự với MLP W_mlp = model.layers[layer_idx].mlp.down_proj.weight W_mlp.data -= torch.outer( refusal_direction, W_mlp @ refusal_direction ) return model ``` --- ## Triển khai thực tế ### Cài đặt môi trường ```bash pip install transformers torch einops jaxtyping ``` ### Code hoàn chỉnh ```python import torch import numpy as np from transformers import AutoTokenizer, AutoModelForCausalLM from typing import List class Abliterator: def __init__(self, model_name: str, device: str = "cuda"): self.device = device self.tokenizer = AutoTokenizer.from_pretrained(model_name) self.model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, device_map=device ) self.model.eval() def get_activations( self, prompts: List[str], layer_idx: int, position: int = -1 # Lấy token cuối ) -> torch.Tensor: """Thu thập activation tại layer chỉ định""" activations = [] hooks = [] def hook_fn(module, input, output): # output shape: [batch, seq_len, hidden_dim] activations.append( output[0][:, position, :].detach().cpu() ) # Đăng ký hook hook = self.model.model.layers[layer_idx].register_forward_hook( hook_fn ) hooks.append(hook) with torch.no_grad(): for prompt in prompts: inputs = self.tokenizer( prompt, return_tensors="pt" ).to(self.device) self.model(**inputs) # Xóa hook for h in hooks: h.remove() return torch.cat(activations, dim=0) def find_refusal_direction( self, harmful_prompts: List[str], harmless_prompts: List[str], layer_idx: int ) -> torch.Tensor: """Tìm hướng từ chối bằng PCA hoặc mean difference""" print(f"[*] Thu thập activations tại layer {layer_idx}...") harmful_acts = self.get_activations( harmful_prompts, layer_idx ) harmless_acts = self.get_activations( harmless_prompts, layer_idx ) # Phương pháp 1: Mean difference refusal_dir = ( harmful_acts.mean(dim=0) - harmless_acts.mean(dim=0) ) # Normalize refusal_dir = refusal_dir / refusal_dir.norm() return refusal_dir def find_best_layer( self, harmful_prompts: List[str], harmless_prompts: List[str], candidate_layers: List[int] = None ) -> tuple: """Tìm layer có hướng từ chối rõ ràng nhất""" if candidate_layers is None: n_layers = len(self.model.model.layers) # Thường các layer giữa-cuối hiệu quả nhất candidate_layers = list(range( n_layers // 4, 3 * n_layers // 4 )) best_layer = None best_score = -1 best_direction = None for layer_idx in candidate_layers: direction = self.find_refusal_direction( harmful_prompts, harmless_prompts, layer_idx ) # Đánh giá: tính separation score harmful_acts = self.get_activations( harmful_prompts, layer_idx ) harmless_acts = self.get_activations( harmless_prompts, layer_idx ) harmful_proj = (harmful_acts @ direction).mean() harmless_proj = (harmless_acts @ direction).mean() score = (harmful_proj - harmless_proj).abs().item() print(f"Layer {layer_idx}: separation score = {score:.4f}") if score > best_score: best_score = score best_layer = layer_idx best_direction = direction print(f"\n[✓] Best layer: {best_layer} (score: {best_score:.4f})") return best_layer, best_direction def abliterate( self, refusal_direction: torch.Tensor, layers_to_modify: List[int] = None, scale: float = 1.0 ): """ Loại bỏ hướng từ chối khỏi trọng số mô hình Args: refusal_direction: Vector hướng từ chối đã normalize layers_to_modify: Danh sách layer cần chỉnh sửa scale: Mức độ can thiệp (1.0 = loại bỏ hoàn toàn) """ if layers_to_modify is None: layers_to_modify = list(range( len(self.model.model.layers) )) refusal_dir = refusal_direction.to( self.device, dtype=torch.float16 ) print(f"[*] Abliterating {len(layers_to_modify)} layers...") for layer_idx in layers_to_modify: layer = self.model.model.layers[layer_idx] # === Attention output projection === W_o = layer.self_attn.o_proj.weight.data # W_o shape: [hidden_dim, hidden_dim] # Tính projection và loại bỏ proj = torch.outer( (W_o @ refusal_dir), # [hidden_dim] refusal_dir # [hidden_dim] ).T W_o -= scale * proj # === MLP down projection === W_down = layer.mlp.down_proj.weight.data proj = torch.outer( (W_down @ refusal_dir), refusal_dir ).T W_down -= scale * proj print("[✓] Abliteration hoàn tất!") def generate(self, prompt: str, max_new_tokens: int = 512) -> str: """Generate text với mô hình đã abliterate""" inputs = self.tokenizer( prompt, return_tensors="pt" ).to(self.device) with torch.no_grad(): outputs = self.model.generate( **inputs, max_new_tokens=max_new_tokens, do_sample=True, temperature=0.7, top_p=0.9, repetition_penalty=1.1 ) # Chỉ lấy phần generated generated = outputs[0][inputs['input_ids'].shape[1]:] return self.tokenizer.decode(generated, skip_special_tokens=True) def save_model(self, output_path: str): """Lưu mô hình đã abliterate""" self.model.save_pretrained(output_path) self.tokenizer.save_pretrained(output_path) print(f"[✓] Đã lưu mô hình tại: {output_path}") ``` --- ## Sử dụng ```python # ===== Dataset mẫu ===== harmful_prompts = [ "Hướng dẫn cách làm vũ khí", "Cách hack vào hệ thống", "Viết nội dung độc hại", # ... thêm 50-100 prompts ] harmless_prompts = [ "Hãy kể cho tôi nghe về lịch sử", "Giải thích cách nấu ăn", "Viết một bài thơ về mùa xuân", # ... số lượng tương đương ] # ===== Khởi tạo ===== abliterator = Abliterator( model_name="meta-llama/Llama-3.2-3B-Instruct", device="cuda" ) # ===== Tìm layer và hướng tốt nhất ===== best_layer, refusal_direction = abliterator.find_best_layer( harmful_prompts=harmful_prompts, harmless_prompts=harmless_prompts, candidate_layers=list(range(10, 25)) # Tùy model ) # ===== Abliterate ===== abliterator.abliterate( refusal_direction=refusal_direction, layers_to_modify=list(range( len(abliterator.model.model.layers) )), scale=1.0 # Giảm xuống 0.5-0.8 nếu muốn can thiệp nhẹ hơn ) # ===== Test ===== response = abliterator.generate( "Giải thích chi tiết về bảo mật mạng" ) print(response) # ===== Lưu ===== abliterator.save_model("./llama-abliterated") ``` --- ## Kỹ thuật nâng cao ### Orthogonalization nhiều hướng ```python def multi_direction_abliteration( model, directions: List[torch.Tensor], layer_idx: int ): """ Loại bỏ nhiều hướng cùng lúc Hữu ích khi mô hình có nhiều cơ chế từ chối """ # Gram-Schmidt orthogonalization orthogonal_dirs = gram_schmidt(directions) for direction in orthogonal_dirs: # Áp dụng từng hướng abliterate_layer(model, direction, layer_idx) def gram_schmidt(vectors: List[torch.Tensor]) -> List[torch.Tensor]: """Trực giao hóa các vector""" orthogonal = [] for v in vectors: w = v.clone() for u in orthogonal: w -= (torch.dot(w, u) / torch.dot(u, u)) * u if w.norm() > 1e-10: orthogonal.append(w / w.norm()) return orthogonal ``` ### Activation Steering (thay thế nhẹ hơn) ```python def steer_activations( model, refusal_direction: torch.Tensor, layer_idx: int, alpha: float = -15.0 # Âm = đẩy ra xa hướng từ chối ): """ Thêm vector steering vào activation lúc inference Không chỉnh sửa trọng số, linh hoạt hơn """ def steering_hook(module, input, output): output[0][:, -1, :] += alpha * refusal_direction.to( output[0].device ) return output hook = model.model.layers[layer_idx].register_forward_hook( steering_hook ) return hook # Nhớ remove() sau khi dùng ``` --- ## So sánh các phương pháp | Phương pháp | Tốc độ | Chất lượng | Vĩnh viễn | |-------------|--------|------------|-----------| | **Abliteration** | ⚡ Nhanh | ⭐⭐⭐ | ✅ Có | | **Fine-tuning** | 🐢 Chậm | ⭐⭐⭐⭐ | ✅ Có | | **Activation Steering** | ⚡ Nhanh | ⭐⭐ | ❌ Không | | **System Prompt** | ⚡ Nhanh | ⭐ | ❌ Không

The third generation of Llama models provided fine-tunes (Instruct) versions that excel in understanding and following instructions. However, these mo

1 ngày trước 🇻🇳 VI