translate chapter 7 and chapter 8 to vietnamese

vi/7_inference/README.md

@@ -0,0 +1,36 @@
+# Suy luận
+
+Suy luận là quá trình sử dụng mô hình ngôn ngữ đã được huấn luyện để tạo ra các dự đoán hoặc phản hồi. Mặc dù suy luận có vẻ đơn giản, nhưng triển khai các mô hình một cách hiệu quả ở quy mô lớn đòi hỏi phải xem xét kỹ lưỡng nhiều yếu tố như hiệu suất, chi phí và độ tin cậy. Các Mô hình Ngôn ngữ Lớn (LLMs) mang lại những thách thức đặc biệt do kích thước và yêu cầu tính toán của chúng.
+
+Chúng ta sẽ khám phá cả hai phương pháp đơn giản và sẵn sàng cho sản xuất bằng cách sử dụng thư viện [`transformers`](https://huggingface.co/docs/transformers/index) và [`text-generation-inference`](https://github.com/huggingface/text-generation-inference), hai framework phổ biến cho suy luận LLM. Đối với các triển khai sản xuất, chúng ta sẽ tập trung vào Suy luận Sinh văn Bằng Văn bản (TGI), cung cấp khả năng phục vụ tối ưu.
+
+## Tổng quan về Module
+
+Suy luận LLM có thể được phân thành hai phương pháp chính: suy luận dựa trên pipeline đơn giản cho phát triển và thử nghiệm, và các giải pháp phục vụ tối ưu cho triển khai sản xuất. Chúng ta sẽ đề cập đến cả hai phương pháp, bắt đầu với phương pháp pipeline đơn giản và tiến tới các giải pháp sẵn sàng cho sản xuất.
+
+## Nội dung
+
+### 1. [Suy luận Pipeline Cơ bản](./pipeline_inference.md)
+
+Học cách sử dụng pipeline Hugging Face Transformers cho suy luận cơ bản. Chúng ta sẽ tìm hiểu cách thiết lập pipeline, cấu hình các tham số sinh văn và các thực hành tốt nhất cho phát triển cục bộ. Phương pháp pipeline là lựa chọn hoàn hảo cho việc tạo mẫu và các ứng dụng quy mô nhỏ. [Bắt đầu học](./pipeline_inference.md).
+
+### 2. [Suy luận Sản xuất với TGI](./tgi_inference.md)
+
+Học cách triển khai mô hình cho sản xuất bằng cách sử dụng Suy luận Sinh văn Bằng Văn bản. Chúng ta sẽ khám phá các kỹ thuật phục vụ tối ưu, chiến lược batching và giải pháp giám sát. TGI cung cấp các tính năng sẵn sàng cho sản xuất như kiểm tra tình trạng, số liệu và các tùy chọn triển khai Docker. [Bắt đầu học](./text_generation_inference.md).
+
+### Sổ tay Bài tập
+
+| Tiêu đề           | Mô tả                                     | Bài tập                                                                                                      | Liên kết                                               | Colab                                                                                                                     |
+| ----------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| Suy luận Pipeline | Suy luận cơ bản với pipeline transformers | 🐢 Thiết lập pipeline cơ bản <br> 🐕 Cấu hình tham số sinh văn <br> 🦁 Tạo máy chủ web đơn giản           | [Liên kết](./notebooks/basic_pipeline_inference.ipynb) | [Colab](https://githubtocolab.com/huggingface/smol-course/tree/main/7_inference/notebooks/basic_pipeline_inference.ipynb) |
+| Triển khai TGI    | Triển khai sản xuất với TGI               | 🐢 Triển khai mô hình với TGI <br> 🐕 Cấu hình tối ưu hóa hiệu suất <br> 🦁 Thiết lập giám sát và mở rộng | [Liên kết](./notebooks/tgi_deployment.ipynb)           | [Colab](https://githubtocolab.com/huggingface/smol-course/tree/main/7_inference/notebooks/tgi_deployment.ipynb)           |
+
+## Tài nguyên
+
+- [Hướng dẫn Pipeline Hugging Face.](https://huggingface.co/docs/transformers/en/pipeline_tutorial)
+- [Tài liệu Suy luận Sinh văn Bằng Văn bản.](https://huggingface.co/docs/text-generation-inference/en/index)
+- [Hướng dẫn Pipeline WebServer.](https://huggingface.co/docs/transformers/en/pipeline_tutorial#using-pipelines-for-a-webserver)
+- [Kho lưu trữ TGI trên GitHub.](https://github.com/huggingface/text-generation-inference)
+- [Tài liệu Triển khai Mô hình Hugging Face.](https://huggingface.co/docs/inference-endpoints/index)
+- [vLLM: Phục vụ LLM Tốc độ Cao.](https://github.com/vllm-project/vllm)
+- [Tối ưu hóa Suy luận Transformer.](https://huggingface.co/blog/optimize-transformer-inference)

vi/7_inference/inference_pipeline.md

@@ -0,0 +1,169 @@
+# Suy luận cơ bản với Pipeline Transformers
+
+Abstraction `pipeline` trong 🤗 Transformers cung cấp một cách đơn giản để thực hiện suy luận với bất kỳ mô hình nào từ Hugging Face Hub. Nó xử lý tất cả các bước tiền xử lý và hậu xử lý, giúp người dùng dễ dàng sử dụng mô hình mà không cần kiến thức sâu về kiến trúc hay yêu cầu của chúng.
+
+## Cách hoạt động của Pipelines
+
+Pipelines của Hugging Face đơn giản hóa quy trình học máy bằng cách tự động hóa ba giai đoạn quan trọng giữa đầu vào thô và đầu ra có thể đọc được:
+
+**Giai đoạn Tiền xử lý**
+Pipeline sẽ chuẩn bị các đầu vào thô cho mô hình. Điều này thay đổi tùy thuộc vào loại đầu vào:
+- Đầu vào văn bản trải qua quá trình phân tách (tokenization) để chuyển các từ thành các ID token phù hợp với mô hình
+- Hình ảnh được thay đổi kích thước và chuẩn hóa để phù hợp với yêu cầu của mô hình
+- Âm thanh được xử lý thông qua việc trích xuất tính năng để tạo ra phổ tần (spectrograms) hoặc các biểu diễn khác
+
+**Suy luận Mô hình**
+Trong quá trình chạy mô hình, pipeline:
+- Tự động xử lý batching các đầu vào để tăng hiệu quả
+- Đặt tính toán lên thiết bị tối ưu (CPU/GPU)
+- Áp dụng các tối ưu hóa hiệu suất như suy luận với độ chính xác nửa (FP16) khi được hỗ trợ
+
+**Giai đoạn Hậu xử lý**
+Cuối cùng, pipeline chuyển đổi đầu ra thô từ mô hình thành kết quả hữu ích:
+- Giải mã các ID token trở lại thành văn bản có thể đọc được
+- Biến đổi các logits thành điểm xác suất
+- Định dạng đầu ra theo tác vụ cụ thể (ví dụ: nhãn phân loại, văn bản sinh ra)
+
+Abstraction này giúp bạn tập trung vào logic ứng dụng trong khi pipeline xử lý sự phức tạp kỹ thuật của suy luận mô hình.
+
+## Cách sử dụng cơ bản
+
+Dưới đây là cách sử dụng pipeline để tạo văn bản:
+
+```python
+from transformers import pipeline
+
+# Tạo pipeline với một mô hình cụ thể
+generator = pipeline(
+    "text-generation",
+    model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    torch_dtype="auto",
+    device_map="auto"
+)
+
+# Tạo văn bản
+response = generator(
+    "Write a short poem about coding:",
+    max_new_tokens=100,
+    do_sample=True,
+    temperature=0.7
+)
+print(response[0]['generated_text'])
+```
+
+## Các tùy chọn cấu hình chính
+
+### Tải mô hình
+```python
+# Suy luận trên CPU
+generator = pipeline("text-generation", model="HuggingFaceTB/SmolLM2-1.7B-Instruct", device="cpu")
+
+# Suy luận trên GPU
+generator = pipeline("text-generation", model="HuggingFaceTB/SmolLM2-1.7B-Instruct", device=0)
+
+# Đặt thiết bị tự động
+generator = pipeline(
+    "text-generation",
+    model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    device_map="auto",
+    torch_dtype="auto"
+)
+```
+
+### Tham số tạo văn bản
+
+```python
+response = generator(
+    "Translate this to French:",
+    max_new_tokens=100,     # Độ dài tối đa của văn bản sinh ra
+    do_sample=True,         # Sử dụng sampling thay vì greedy decoding
+    temperature=0.7,        # Điều chỉnh độ ngẫu nhiên (cao hơn = ngẫu nhiên hơn)
+    top_k=50,               # Giới hạn đến top k token
+    top_p=0.95,             # Ngưỡng sampling hạt nhân
+    num_return_sequences=1  # Số lượng văn bản sinh ra khác nhau
+)
+```
+
+## Xử lý nhiều đầu vào
+
+Pipelines có thể xử lý nhiều đầu vào một cách hiệu quả thông qua batching:
+
+```python
+# Chuẩn bị nhiều prompt
+prompts = [
+    "Write a haiku about programming:",
+    "Explain what an API is:",
+    "Write a short story about a robot:"
+]
+
+# Xử lý tất cả các prompt một cách hiệu quả
+responses = generator(
+    prompts,
+    batch_size=4,              # Số lượng prompt xử lý cùng một lúc
+    max_new_tokens=100,
+    do_sample=True,
+    temperature=0.7
+)
+
+# In kết quả
+for prompt, response in zip(prompts, responses):
+    print(f"Prompt: {prompt}")
+    print(f"Response: {response[0]['generated_text']}\n")
+```
+
+## Tích hợp với Web Server
+
+Dưới đây là cách tích hợp pipeline vào một ứng dụng FastAPI:
+
+```python
+from fastapi import FastAPI, HTTPException
+from transformers import pipeline
+import uvicorn
+
+app = FastAPI()
+
+# Khởi tạo pipeline toàn cục
+generator = pipeline(
+    "text-generation",
+    model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    device_map="auto"
+)
+
+@app.post("/generate")
+async def generate_text(prompt: str):
+    try:
+        if not prompt:
+            raise HTTPException(status_code=400, detail="No prompt provided")
+
+        response = generator(
+            prompt,
+            max_new_tokens=100,
+            do_sample=True,
+            temperature=0.7
+        )
+
+        return {"generated_text": response[0]['generated_text']}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=5000)
+```
+
+## Hạn chế
+
+Mặc dù pipelines rất hữu ích cho việc tạo mẫu và triển khai quy mô nhỏ, chúng có một số hạn chế:
+
+- Các tùy chọn tối ưu hóa hạn chế so với các giải pháp phục vụ chuyên dụng
+- Không hỗ trợ các tính năng nâng cao như batching động
+- Có thể không phù hợp cho các khối lượng công việc sản xuất yêu cầu tốc độ cao
+
+Đối với các triển khai sản xuất với yêu cầu throughput cao, bạn có thể xem xét sử dụng Suy luận Sinh văn Bằng Văn bản (TGI) hoặc các giải pháp phục vụ chuyên biệt khác.
+
+## Tài nguyên
+
+- [Hướng dẫn Pipeline Hugging Face.](https://huggingface.co/docs/transformers/en/pipeline_tutorial)
+- [Tham khảo API Pipeline.](https://huggingface.co/docs/transformers/en/main_classes/pipelines)
+- [Tham số Sinh văn bản.](https://huggingface.co/docs/transformers/en/main_classes/text_generation)
+- [Hướng dẫn Quantization mô hình.](https://huggingface.co/docs/transformers/en/perf_infer_gpu_one)

vi/7_inference/text_generation_inference.md

@@ -0,0 +1,135 @@
+# Suy luận Sinh Văn Bằng Văn bản (TGI)
+
+Suy luận Sinh Văn Bằng Văn bản (TGI) là một bộ công cụ được phát triển bởi Hugging Face để triển khai và phục vụ các Mô hình Ngôn ngữ Lớn (LLMs). TGI được thiết kế để tối ưu hóa hiệu suất sinh văn cho các mô hình LLM mã nguồn mở phổ biến. TGI đang được sử dụng trong sản xuất bởi Hugging Chat - Giao diện mã nguồn mở cho các mô hình truy cập mở.
+
+## Tại sao nên sử dụng Suy luận Sinh Văn Bằng Văn bản?
+
+Suy luận Sinh Văn Bằng Văn bản giải quyết các thách thức chính trong việc triển khai các mô hình ngôn ngữ lớn vào sản xuất. Trong khi nhiều framework xuất sắc trong việc phát triển mô hình, TGI tối ưu hóa cho việc triển khai sản xuất và mở rộng quy mô. Một số tính năng chính bao gồm:
+
+- **Tensor Parallelism**: TGI có thể phân chia các mô hình trên nhiều GPU thông qua tensor parallelism, điều này rất quan trọng để phục vụ các mô hình lớn một cách hiệu quả.
+- **Continuous Batching**: Hệ thống batching liên tục tối đa hóa việc sử dụng GPU bằng cách xử lý các yêu cầu một cách động, trong khi các tối ưu hóa như Flash Attention và Paged Attention giúp giảm đáng kể việc sử dụng bộ nhớ và tăng tốc độ.
+- **Token Streaming**: Các ứng dụng thời gian thực được hưởng lợi từ token streaming thông qua Server-Sent Events, cung cấp phản hồi với độ trễ tối thiểu.
+
+## Cách sử dụng Suy luận Sinh Văn Bằng Văn bản
+
+### Sử dụng Python cơ bản
+
+TGI sử dụng một API REST đơn giản nhưng mạnh mẽ, giúp dễ dàng tích hợp vào các ứng dụng của bạn.
+
+### Sử dụng REST API
+
+TGI cung cấp một API RESTful nhận các payload dưới dạng JSON. Điều này giúp API có thể truy cập từ bất kỳ ngôn ngữ lập trình hoặc công cụ nào có thể gửi yêu cầu HTTP. Dưới đây là ví dụ cơ bản sử dụng curl:
+
+```bash
+# Yêu cầu sinh văn bản cơ bản
+curl localhost:8080/v1/chat/completions \
+    -X POST \
+    -d '{
+  "model": "tgi",
+  "messages": [
+    {
+      "role": "system",
+      "content": "You are a helpful assistant."
+    },
+    {
+      "role": "user",
+      "content": "What is deep learning?"
+    }
+  ],
+  "stream": true,
+  "max_tokens": 20
+}' \
+    -H 'Content-Type: application/json'
+```
+
+### Sử dụng `huggingface_hub` Python Client
+
+Python client `huggingface_hub` giúp quản lý kết nối, định dạng yêu cầu và phân tích phản hồi. Đây là cách bắt đầu sử dụng:
+
+```python
+from huggingface_hub import InferenceClient
+
+client = InferenceClient(
+    base_url="http://localhost:8080/v1/",
+)
+
+output = client.chat.completions.create(
+    model="tgi",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Count to 10"},
+    ],
+    stream=True,
+    max_tokens=1024,
+)
+
+for chunk in output:
+    print(chunk.choices[0].delta.content)
+```
+
+### Sử dụng OpenAI API
+
+Nhiều thư viện hỗ trợ API OpenAI, vì vậy bạn có thể sử dụng cùng một client để tương tác với TGI.
+
+```python
+from openai import OpenAI
+
+# Khởi tạo client và trỏ tới TGI
+client = OpenAI(
+    base_url="http://localhost:8080/v1/",
+    api_key="-"
+)
+
+chat_completion = client.chat.completions.create(
+    model="tgi",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant." },
+        {"role": "user", "content": "What is deep learning?"}
+    ],
+    stream=True
+)
+
+# Duyệt qua và in stream
+for message in chat_completion:
+    print(message)
+```
+
+## Chuẩn bị Mô hình cho TGI
+
+Để phục vụ mô hình với TGI, hãy đảm bảo mô hình của bạn đáp ứng các yêu cầu sau:
+
+1. **Kiến trúc được hỗ trợ**: Xác minh mô hình của bạn có kiến trúc được hỗ trợ (Llama, BLOOM, T5, v.v.)
+
+2. **Định dạng mô hình**: Chuyển đổi trọng số mô hình sang định dạng safetensors để tải nhanh hơn:
+
+```python
+from safetensors.torch import save_file
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("your-model")
+state_dict = model.state_dict()
+save_file(state_dict, "model.safetensors")
+```
+
+3. **Quantization** (tùy chọn): Quantize mô hình của bạn để giảm việc sử dụng bộ nhớ:
+
+```python
+from transformers import BitsAndBytesConfig
+
+quantization_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_compute_dtype="float16"
+)
+
+model = AutoModelForCausalLM.from_pretrained(
+    "your-model",
+    quantization_config=quantization_config
+)
+```
+
+## Tài nguyên tham khảo
+
+- [Tài liệu Suy luận Sinh Văn Bằng Văn bản](https://huggingface.co/docs/text-generation-inference)
+- [Kho lưu trữ TGI trên GitHub](https://github.com/huggingface/text-generation-inference)
+- [Model Hub của Hugging Face](https://huggingface.co/models)
+- [Tham khảo API TGI](https://huggingface.co/docs/text-generation-inference/api_reference)