Buckets:
| # استقرار بهینهی استنتاج | |
| در این بخش، چارچوبهای پیشرفتهی بهینهسازی استقرار مدلهای زبانی بزرگ را بررسی میکنیم: Text Generation Inference (TGI)، vLLM و llama.cpp. این برنامهها عمدتاً در محیطهای تولید برای ارائهی مدلهای زبانی بزرگ به کاربران استفاده میشوند. تمرکز این بخش بر نحوهی استقرار این چارچوبها در محیط تولید است، نه نحوهی استفاده از آنها برای استنتاج روی یک ماشین منفرد. | |
| بررسی خواهیم کرد که این ابزارها چگونه کارایی استنتاج را به حداکثر میرسانند و استقرار مدلهای زبانی بزرگ را در محیط تولید سادهتر میکنند. | |
| ## راهنمای انتخاب چارچوب | |
| TGI، vLLM و llama.cpp هدفهای مشابهی دارند، اما ویژگیهای متمایزی دارند که باعث میشود هرکدام برای موارد استفادهی متفاوتی مناسبتر باشند. بیایید تفاوتهای کلیدی آنها را با تمرکز بر عملکرد و یکپارچهسازی بررسی کنیم. | |
| ### مدیریت حافظه و عملکرد | |
| **TGI** برای پایدار و قابلپیشبینی بودن در محیط تولید طراحی شده و از طولهای ثابت رشته استفاده میکند تا مصرف حافظه را ثابت نگه دارد. TGI حافظه را با استفاده از Flash Attention 2 و تکنیکهای بتچسازی پیوسته مدیریت میکند. این یعنی میتواند محاسبات توجه را بسیار کارآمد انجام دهد و با تغذیهی پیوستهی کار، GPU را مشغول نگه دارد. سیستم میتواند در صورت نیاز بخشهایی از مدل را بین CPU و GPU جابهجا کند و به این ترتیب از مدلهای بزرگتر پشتیبانی کند. | |
| Flash Attention تکنیکی است که با برطرف کردن گلوگاههای پهنای باند حافظه، مکانیزم توجه را در مدلهای ترنسفورمر بهینه میکند. همانطور که پیشتر در [بخش ۱.۸](/course/chapter1/8) گفتیم، مکانیزم توجه پیچیدگی و مصرف حافظهی درجهدوم دارد و همین موضوع آن را برای رشتههای طولانی ناکارآمد میکند. | |
| نوآوری اصلی در نحوهی مدیریت انتقال حافظه است. توجه سنتی دادهها را بارها بین حافظهی با پهنای باند بالا (HBM) و کش سریع SRAM جابهجا میکند و با بیکار گذاشتن GPU گلوگاه ایجاد میکند. Flash Attention دادهها را یکبار در SRAM بارگذاری میکند و همهی محاسبات را همانجا انجام میدهد؛ در نتیجه انتقالهای پرهزینهی حافظه به حداقل میرسند. | |
| اگرچه مزایای آن در زمان تعلیم بیشترین مقدار را دارند، مصرف کمتر VRAM و کارایی بهتر Flash Attention باعث میشود برای استنتاج نیز ارزشمند باشد و ارائهی سریعتر و مقیاسپذیرتر مدلهای زبانی بزرگ را ممکن کند. | |
| **vLLM** با استفاده از PagedAttention رویکرد متفاوتی دارد. همانطور که رایانه حافظهی خود را به صفحهها تقسیم میکند، vLLM حافظهی مدل را به بلوکهای کوچکتر تقسیم میکند. این سیستم هوشمندانه باعث میشود بتواند درخواستهایی با اندازههای مختلف را انعطافپذیرتر مدیریت کند و فضای حافظه را هدر ندهد. این چارچوب در اشتراکگذاری حافظه بین درخواستهای مختلف بسیار خوب عمل میکند و تکهتکهشدن حافظه را کاهش میدهد؛ بنابراین کل سیستم کارآمدتر میشود. | |
| PagedAttention تکنیکی است که به یکی دیگر از گلوگاههای مهم استنتاج مدلهای زبانی بزرگ، یعنی مدیریت حافظهی کش KV، میپردازد. همانطور که در [بخش ۱.۸](/course/chapter1/8) گفتیم، مدل هنگام تولید متن، کلیدها و مقادیر توجه (کش KV) را برای هر توکِن تولیدشده ذخیره میکند تا محاسبات تکراری کاهش یابند. کش KV، بهخصوص برای رشتههای طولانی یا چندین درخواست همزمان، میتواند بسیار بزرگ شود. | |
| نوآوری اصلی vLLM در نحوهی مدیریت این کش است: | |
| 1. **صفحهبندی حافظه**: بهجای اینکه کش KV بهصورت یک بلوک بزرگ در نظر گرفته شود، به «صفحههای» با اندازهی ثابت تقسیم میشود (مشابه حافظهی مجازی در سیستمعاملها). | |
| 2. **ذخیرهسازی غیرپیوسته**: لازم نیست صفحهها بهصورت پیوسته در حافظهی GPU ذخیره شوند؛ بنابراین تخصیص حافظه انعطافپذیرتر است. | |
| 3. **مدیریت جدول صفحه**: یک جدول صفحه مشخص میکند کدام صفحهها به کدام رشته تعلق دارند و جستوجو و دسترسی کارآمد را ممکن میکند. | |
| 4. **اشتراکگذاری حافظه**: در عملیاتی مانند نمونهبرداری موازی، صفحههایی که کش KV مربوط به پیام ورودی را ذخیره میکنند میتوانند بین چندین رشته به اشتراک گذاشته شوند. | |
| رویکرد PagedAttention در مقایسه با روشهای سنتی میتواند توان عملیاتی را تا ۲۴ برابر افزایش دهد و برای استقرار مدلهای زبانی بزرگ در محیط تولید تحولی اساسی ایجاد کند. اگر میخواهید دربارهی نحوهی کار PagedAttention عمیقتر مطالعه کنید، میتوانید [راهنمای مستندات vLLM](https://docs.vllm.ai/en/latest/design/kernel/paged_attention.html) را بخوانید. | |
| **llama.cpp** یک پیادهسازی بسیار بهینه از C/C++ است که در ابتدا برای اجرای مدلهای LLaMA روی سختافزارهای مصرفی طراحی شد. این پروژه بر کارایی CPU تمرکز دارد، با امکان شتابدهی GPU، و برای محیطهای دارای منابع محدود ایدئال است. llama.cpp از تکنیکهای کوانتیزهسازی برای کاهش اندازه و نیازمندیهای حافظهی مدل استفاده میکند و در عین حفظ عملکرد خوب، کرنلهای بهینهشدهای برای معماریهای مختلف CPU ارائه میدهد و از مدیریت پایهی کش KV برای تولید کارآمد توکِن پشتیبانی میکند. | |
| کوانتیزهسازی در llama.cpp دقت وزنهای مدل را از ممیز شناور ۳۲بیتی یا ۱۶بیتی به قالبهای کمدقتتری مانند اعداد صحیح ۸بیتی (INT8)، ۴بیتی یا حتی پایینتر کاهش میدهد. این کار مصرف حافظه را بهطور چشمگیری کاهش میدهد و سرعت استنتاج را با افت کیفیتی اندک افزایش میدهد. | |
| ویژگیهای کلیدی کوانتیزهسازی در llama.cpp عبارتاند از: | |
| 1. **سطوح متعدد کوانتیزهسازی**: از کوانتیزهسازی ۸بیتی، ۴بیتی، ۳بیتی و حتی ۲بیتی پشتیبانی میکند | |
| 2. **قالب GGML/GGUF**: از قالبهای سفارشی تِنسور استفاده میکند که برای استنتاج کوانتیزهشده بهینه شدهاند | |
| 3. **دقت ترکیبی**: میتواند سطوح مختلف کوانتیزهسازی را روی بخشهای مختلف مدل اعمال کند | |
| 4. **بهینهسازیهای ویژهی سختافزار**: مسیرهای کد بهینهشده برای معماریهای مختلف CPU (AVX2، AVX-512، NEON) دارد | |
| این رویکرد اجرای مدلهای دارای میلیاردها پارامتر را روی سختافزارهای مصرفی با حافظهی محدود ممکن میکند و برای استقرارهای محلی و دستگاههای لبهای عالی است. | |
| ### استقرار و یکپارچهسازی | |
| حالا به سراغ تفاوتهای استقرار و یکپارچهسازی میان این چارچوبها برویم. | |
| **TGI** در استقرارهای سازمانی و در مقیاس بزرگ، با قابلیتهای آمادهی تولید خود، عملکردی عالی دارد. این چارچوب پشتیبانی داخلی از Kubernetes دارد و هر چیزی را که برای اجرای محیط تولید نیاز دارید، از جمله پایش با Prometheus و Grafana، مقیاسبندی خودکار و قابلیتهای جامع ایمنی، در اختیار میگذارد. سیستم همچنین شامل ثبت گزارش در سطح سازمانی و اقدامات حفاظتی مختلفی مانند فیلتر کردن محتوا و محدودسازی نرخ است تا استقرار شما امن و پایدار بماند. | |
| **vLLM** رویکردی انعطافپذیرتر و سازگارتر با توسعهدهندگان برای استقرار دارد. هستهی آن با پایتون ساخته شده و میتواند بهسادگی جایگزین API شرکت OpenAI در برنامههای موجود شما شود. این چارچوب بر ارائهی عملکرد خام تمرکز دارد و میتوان آن را مطابق نیازهای خاص شما سفارشی کرد. vLLM برای مدیریت کلاسترها بهخوبی با Ray کار میکند و وقتی به عملکرد بالا و سازگاری نیاز دارید، انتخابی عالی است. | |
| **llama.cpp** سادگی و قابلیت حمل را در اولویت قرار میدهد. پیادهسازی سرور آن سبک است و میتواند روی طیف گستردهای از سختافزارها، از سرورهای قدرتمند تا لپتاپهای مصرفی و حتی برخی دستگاههای همراه ردهبالا اجرا شود. با وابستگیهای حداقلی و هستهی سادهی C/C++، استقرار آن در محیطهایی که نصب چارچوبهای پایتونی دشوار است آسان است. سرور، ضمن حفظ ردپای بسیار کوچکتر منابع نسبت به راهکارهای دیگر، یک API سازگار با OpenAI ارائه میدهد. | |
| ## شروع کار | |
| بیایید نحوهی استفاده از این چارچوبها برای استقرار مدلهای زبانی بزرگ را بررسی کنیم و از نصب و راهاندازی پایه شروع کنیم. | |
| ### نصب و راهاندازی پایه | |
| نصب و استفاده از TGI آسان است و یکپارچهسازی عمیقی با اکوسیستم هاگینگفِیس دارد. | |
| ابتدا سرور TGI را با Docker اجرا کنید: | |
| ```sh | |
| docker run --gpus all \ | |
| --shm-size 1g \ | |
| -p 8080:80 \ | |
| -v ~/.cache/huggingface:/data \ | |
| ghcr.io/huggingface/text-generation-inference:latest \ | |
| --model-id HuggingFaceTB/SmolLM2-360M-Instruct | |
| ``` | |
| سپس با استفاده از InferenceClient هاگینگفِیس با آن تعامل کنید: | |
| ```python | |
| from huggingface_hub import InferenceClient | |
| # Initialize client pointing to TGI endpoint | |
| client = InferenceClient( | |
| model="http://localhost:8080", # URL to the TGI server | |
| ) | |
| # Text generation | |
| response = client.text_generation( | |
| "Tell me a story", | |
| max_new_tokens=100, | |
| temperature=0.7, | |
| top_p=0.95, | |
| details=True, | |
| stop_sequences=[], | |
| ) | |
| print(response.generated_text) | |
| # For chat format | |
| response = client.chat_completion( | |
| messages=[ | |
| {"role": "system", "content": "You are a helpful assistant."}, | |
| {"role": "user", "content": "Tell me a story"}, | |
| ], | |
| max_tokens=100, | |
| temperature=0.7, | |
| top_p=0.95, | |
| ) | |
| print(response.choices[0].message.content) | |
| ``` | |
| یا میتوانید از کلاینت OpenAI استفاده کنید: | |
| ```python | |
| from openai import OpenAI | |
| # Initialize client pointing to TGI endpoint | |
| client = OpenAI( | |
| base_url="http://localhost:8080/v1", # Make sure to include /v1 | |
| api_key="not-needed", # TGI doesn't require an API key by default | |
| ) | |
| # Chat completion | |
| response = client.chat.completions.create( | |
| model="HuggingFaceTB/SmolLM2-360M-Instruct", | |
| messages=[ | |
| {"role": "system", "content": "You are a helpful assistant."}, | |
| {"role": "user", "content": "Tell me a story"}, | |
| ], | |
| max_tokens=100, | |
| temperature=0.7, | |
| top_p=0.95, | |
| ) | |
| print(response.choices[0].message.content) | |
| ``` | |
| llama.cpp نصب و استفادهی آسانی دارد، به وابستگیهای کمی نیاز دارد و از استنتاج روی CPU و GPU پشتیبانی میکند. | |
| ابتدا llama.cpp را نصب و بسازید: | |
| ```sh | |
| # Clone the repository | |
| git clone https://github.com/ggerganov/llama.cpp | |
| cd llama.cpp | |
| # Build the project | |
| make | |
| # Download the SmolLM2-1.7B-Instruct-GGUF model | |
| curl -L -O https://huggingface.co/HuggingFaceTB/SmolLM2-1.7B-Instruct-GGUF/resolve/main/smollm2-1.7b-instruct.Q4_K_M.gguf | |
| ``` | |
| سپس سرور را اجرا کنید (با سازگاری با API شرکت OpenAI): | |
| ```sh | |
| # Start the server | |
| ./server \ | |
| -m smollm2-1.7b-instruct.Q4_K_M.gguf \ | |
| --host 0.0.0.0 \ | |
| --port 8080 \ | |
| -c 4096 \ | |
| --n-gpu-layers 0 # Set to a higher number to use GPU | |
| ``` | |
| با استفاده از InferenceClient هاگینگفِیس با سرور تعامل کنید: | |
| ```python | |
| from huggingface_hub import InferenceClient | |
| # Initialize client pointing to llama.cpp server | |
| client = InferenceClient( | |
| model="http://localhost:8080/v1", # URL to the llama.cpp server | |
| token="sk-no-key-required", # llama.cpp server requires this placeholder | |
| ) | |
| # Text generation | |
| response = client.text_generation( | |
| "Tell me a story", | |
| max_new_tokens=100, | |
| temperature=0.7, | |
| top_p=0.95, | |
| details=True, | |
| ) | |
| print(response.generated_text) | |
| # For chat format | |
| response = client.chat_completion( | |
| messages=[ | |
| {"role": "system", "content": "You are a helpful assistant."}, | |
| {"role": "user", "content": "Tell me a story"}, | |
| ], | |
| max_tokens=100, | |
| temperature=0.7, | |
| top_p=0.95, | |
| ) | |
| print(response.choices[0].message.content) | |
| ``` | |
| یا میتوانید از کلاینت OpenAI استفاده کنید: | |
| ```python | |
| from openai import OpenAI | |
| # Initialize client pointing to llama.cpp server | |
| client = OpenAI( | |
| base_url="http://localhost:8080/v1", | |
| api_key="sk-no-key-required", # llama.cpp server requires this placeholder | |
| ) | |
| # Chat completion | |
| response = client.chat.completions.create( | |
| model="smollm2-1.7b-instruct", # Model identifier can be anything as server only loads one model | |
| messages=[ | |
| {"role": "system", "content": "You are a helpful assistant."}, | |
| {"role": "user", "content": "Tell me a story"}, | |
| ], | |
| max_tokens=100, | |
| temperature=0.7, | |
| top_p=0.95, | |
| ) | |
| print(response.choices[0].message.content) | |
| ``` | |
| vLLM نصب و استفادهی آسانی دارد و هم با API شرکت OpenAI سازگار است و هم رابط بومی پایتون دارد. | |
| ابتدا سرور سازگار با OpenAI vLLM را اجرا کنید: | |
| ```sh | |
| python -m vllm.entrypoints.openai.api_server \ | |
| --model HuggingFaceTB/SmolLM2-360M-Instruct \ | |
| --host 0.0.0.0 \ | |
| --port 8000 | |
| ``` | |
| سپس با استفاده از InferenceClient هاگینگفِیس با آن تعامل کنید: | |
| ```python | |
| from huggingface_hub import InferenceClient | |
| # Initialize client pointing to vLLM endpoint | |
| client = InferenceClient( | |
| model="http://localhost:8000/v1", # URL to the vLLM server | |
| ) | |
| # Text generation | |
| response = client.text_generation( | |
| "Tell me a story", | |
| max_new_tokens=100, | |
| temperature=0.7, | |
| top_p=0.95, | |
| details=True, | |
| ) | |
| print(response.generated_text) | |
| # For chat format | |
| response = client.chat_completion( | |
| messages=[ | |
| {"role": "system", "content": "You are a helpful assistant."}, | |
| {"role": "user", "content": "Tell me a story"}, | |
| ], | |
| max_tokens=100, | |
| temperature=0.7, | |
| top_p=0.95, | |
| ) | |
| print(response.choices[0].message.content) | |
| ``` | |
| یا میتوانید از کلاینت OpenAI استفاده کنید: | |
| ```python | |
| from openai import OpenAI | |
| # Initialize client pointing to vLLM endpoint | |
| client = OpenAI( | |
| base_url="http://localhost:8000/v1", | |
| api_key="not-needed", # vLLM doesn't require an API key by default | |
| ) | |
| # Chat completion | |
| response = client.chat.completions.create( | |
| model="HuggingFaceTB/SmolLM2-360M-Instruct", | |
| messages=[ | |
| {"role": "system", "content": "You are a helpful assistant."}, | |
| {"role": "user", "content": "Tell me a story"}, | |
| ], | |
| max_tokens=100, | |
| temperature=0.7, | |
| top_p=0.95, | |
| ) | |
| print(response.choices[0].message.content) | |
| ``` | |
| ### تولید پایهی متن | |
| بیایید نمونههایی از تولید متن با این چارچوبها را بررسی کنیم: | |
| ابتدا TGI را با پارامترهای پیشرفته مستقر کنید: | |
| ```sh | |
| docker run --gpus all \ | |
| --shm-size 1g \ | |
| -p 8080:80 \ | |
| -v ~/.cache/huggingface:/data \ | |
| ghcr.io/huggingface/text-generation-inference:latest \ | |
| --model-id HuggingFaceTB/SmolLM2-360M-Instruct \ | |
| --max-total-tokens 4096 \ | |
| --max-input-length 3072 \ | |
| --max-batch-total-tokens 8192 \ | |
| --waiting-served-ratio 1.2 | |
| ``` | |
| برای تولید انعطافپذیر متن از InferenceClient استفاده کنید: | |
| ```python | |
| from huggingface_hub import InferenceClient | |
| client = InferenceClient(model="http://localhost:8080") | |
| # Advanced parameters example | |
| response = client.chat_completion( | |
| messages=[ | |
| {"role": "system", "content": "You are a creative storyteller."}, | |
| {"role": "user", "content": "Write a creative story"}, | |
| ], | |
| temperature=0.8, | |
| max_tokens=200, | |
| top_p=0.95, | |
| ) | |
| print(response.choices[0].message.content) | |
| # Raw text generation | |
| response = client.text_generation( | |
| "Write a creative story about space exploration", | |
| max_new_tokens=200, | |
| temperature=0.8, | |
| top_p=0.95, | |
| repetition_penalty=1.1, | |
| do_sample=True, | |
| details=True, | |
| ) | |
| print(response.generated_text) | |
| ``` | |
| یا از کلاینت OpenAI استفاده کنید: | |
| ```python | |
| from openai import OpenAI | |
| client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed") | |
| # Advanced parameters example | |
| response = client.chat.completions.create( | |
| model="HuggingFaceTB/SmolLM2-360M-Instruct", | |
| messages=[ | |
| {"role": "system", "content": "You are a creative storyteller."}, | |
| {"role": "user", "content": "Write a creative story"}, | |
| ], | |
| temperature=0.8, # Higher for more creativity | |
| ) | |
| print(response.choices[0].message.content) | |
| ``` | |
| در llama.cpp هنگام اجرای سرور میتوانید پارامترهای پیشرفته را تنظیم کنید: | |
| ```sh | |
| ./server \ | |
| -m smollm2-1.7b-instruct.Q4_K_M.gguf \ | |
| --host 0.0.0.0 \ | |
| --port 8080 \ | |
| -c 4096 \ # Context size | |
| --threads 8 \ # CPU threads to use | |
| --batch-size 512 \ # Batch size for prompt evaluation | |
| --n-gpu-layers 0 # GPU layers (0 = CPU only) | |
| ``` | |
| از InferenceClient استفاده کنید: | |
| ```python | |
| from huggingface_hub import InferenceClient | |
| client = InferenceClient(model="http://localhost:8080/v1", token="sk-no-key-required") | |
| # Advanced parameters example | |
| response = client.chat_completion( | |
| messages=[ | |
| {"role": "system", "content": "You are a creative storyteller."}, | |
| {"role": "user", "content": "Write a creative story"}, | |
| ], | |
| temperature=0.8, | |
| max_tokens=200, | |
| top_p=0.95, | |
| ) | |
| print(response.choices[0].message.content) | |
| # For direct text generation | |
| response = client.text_generation( | |
| "Write a creative story about space exploration", | |
| max_new_tokens=200, | |
| temperature=0.8, | |
| top_p=0.95, | |
| repetition_penalty=1.1, | |
| details=True, | |
| ) | |
| print(response.generated_text) | |
| ``` | |
| یا برای تولید، با کنترل پارامترهای نمونهبرداری، از کلاینت OpenAI استفاده کنید: | |
| ```python | |
| from openai import OpenAI | |
| client = OpenAI(base_url="http://localhost:8080/v1", api_key="sk-no-key-required") | |
| # Advanced parameters example | |
| response = client.chat.completions.create( | |
| model="smollm2-1.7b-instruct", | |
| messages=[ | |
| {"role": "system", "content": "You are a creative storyteller."}, | |
| {"role": "user", "content": "Write a creative story"}, | |
| ], | |
| temperature=0.8, # Higher for more creativity | |
| top_p=0.95, # Nucleus sampling probability | |
| frequency_penalty=0.5, # Reduce repetition of frequent tokens | |
| presence_penalty=0.5, # Reduce repetition by penalizing tokens already present | |
| max_tokens=200, # Maximum generation length | |
| ) | |
| print(response.choices[0].message.content) | |
| ``` | |
| همچنین میتوانید برای کنترل بیشتر از کتابخانهی بومی llama.cpp استفاده کنید: | |
| ```python | |
| # Using llama-cpp-python package for direct model access | |
| from llama_cpp import Llama | |
| # Load the model | |
| llm = Llama( | |
| model_path="smollm2-1.7b-instruct.Q4_K_M.gguf", | |
| n_ctx=4096, # Context window size | |
| n_threads=8, # CPU threads | |
| n_gpu_layers=0, # GPU layers (0 = CPU only) | |
| ) | |
| # Format prompt according to the model's expected format | |
| prompt = """<|im_start|>system | |
| You are a creative storyteller. | |
| <|im_end|> | |
| <|im_start|>user | |
| Write a creative story | |
| <|im_end|> | |
| <|im_start|>assistant | |
| """ | |
| # Generate response with precise parameter control | |
| output = llm( | |
| prompt, | |
| max_tokens=200, | |
| temperature=0.8, | |
| top_p=0.95, | |
| frequency_penalty=0.5, | |
| presence_penalty=0.5, | |
| stop=["<|im_end|>"], | |
| ) | |
| print(output["choices"][0]["text"]) | |
| ``` | |
| برای استفادهی پیشرفته از vLLM میتوانید از InferenceClient استفاده کنید: | |
| ```python | |
| from huggingface_hub import InferenceClient | |
| client = InferenceClient(model="http://localhost:8000/v1") | |
| # Advanced parameters example | |
| response = client.chat_completion( | |
| messages=[ | |
| {"role": "system", "content": "You are a creative storyteller."}, | |
| {"role": "user", "content": "Write a creative story"}, | |
| ], | |
| temperature=0.8, | |
| max_tokens=200, | |
| top_p=0.95, | |
| ) | |
| print(response.choices[0].message.content) | |
| # For direct text generation | |
| response = client.text_generation( | |
| "Write a creative story about space exploration", | |
| max_new_tokens=200, | |
| temperature=0.8, | |
| top_p=0.95, | |
| details=True, | |
| ) | |
| print(response.generated_text) | |
| ``` | |
| همچنین میتوانید از کلاینت OpenAI استفاده کنید: | |
| ```python | |
| from openai import OpenAI | |
| client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed") | |
| # Advanced parameters example | |
| response = client.chat.completions.create( | |
| model="HuggingFaceTB/SmolLM2-360M-Instruct", | |
| messages=[ | |
| {"role": "system", "content": "You are a creative storyteller."}, | |
| {"role": "user", "content": "Write a creative story"}, | |
| ], | |
| temperature=0.8, | |
| top_p=0.95, | |
| max_tokens=200, | |
| ) | |
| print(response.choices[0].message.content) | |
| ``` | |
| vLLM همچنین یک رابط بومی پایتون با کنترل دقیق ارائه میدهد: | |
| ```python | |
| from vllm import LLM, SamplingParams | |
| # Initialize the model with advanced parameters | |
| llm = LLM( | |
| model="HuggingFaceTB/SmolLM2-360M-Instruct", | |
| gpu_memory_utilization=0.85, | |
| max_num_batched_tokens=8192, | |
| max_num_seqs=256, | |
| block_size=16, | |
| ) | |
| # Configure sampling parameters | |
| sampling_params = SamplingParams( | |
| temperature=0.8, # Higher for more creativity | |
| top_p=0.95, # Consider top 95% probability mass | |
| max_tokens=100, # Maximum length | |
| presence_penalty=1.1, # Reduce repetition | |
| frequency_penalty=1.1, # Reduce repetition | |
| stop=["\n\n", "###"], # Stop sequences | |
| ) | |
| # Generate text | |
| prompt = "Write a creative story" | |
| outputs = llm.generate(prompt, sampling_params) | |
| print(outputs[0].outputs[0].text) | |
| # For chat-style interactions | |
| chat_prompt = [ | |
| {"role": "system", "content": "You are a creative storyteller."}, | |
| {"role": "user", "content": "Write a creative story"}, | |
| ] | |
| formatted_prompt = llm.get_chat_template()(chat_prompt) # Uses model's chat template | |
| outputs = llm.generate(formatted_prompt, sampling_params) | |
| print(outputs[0].outputs[0].text) | |
| ``` | |
| ## کنترل پیشرفتهی تولید | |
| ### انتخاب توکِن و نمونهبرداری | |
| فرایند تولید متن شامل انتخاب توکِن بعدی در هر مرحله است. این فرایند انتخاب را میتوان با پارامترهای مختلف کنترل کرد: | |
| 1. **لوجیتهای خام**: احتمالهای اولیهی خروجی برای هر توکِن | |
| 2. **دما**: میزان تصادفی بودن انتخاب را کنترل میکند (مقدار بیشتر = خلاقیت بیشتر) | |
| 3. **نمونهبرداری Top-p (هستهای)**: توکِنهای برتر تشکیلدهندهی X٪ از جرم احتمال را فیلتر میکند | |
| 4. **فیلتر Top-k**: انتخاب را به k توکِن محتملتر محدود میکند | |
| در اینجا نحوهی پیکربندی این پارامترها را میبینید: | |
| ```python | |
| client.generate( | |
| "Write a creative story", | |
| temperature=0.8, # Higher for more creativity | |
| top_p=0.95, # Consider top 95% probability mass | |
| top_k=50, # Consider top 50 tokens | |
| max_new_tokens=100, # Maximum length | |
| repetition_penalty=1.1, # Reduce repetition | |
| ) | |
| ``` | |
| ```python | |
| # Via OpenAI API compatibility | |
| response = client.completions.create( | |
| model="smollm2-1.7b-instruct", # Model name (can be any string for llama.cpp server) | |
| prompt="Write a creative story", | |
| temperature=0.8, # Higher for more creativity | |
| top_p=0.95, # Consider top 95% probability mass | |
| frequency_penalty=1.1, # Reduce repetition | |
| presence_penalty=0.1, # Reduce repetition | |
| max_tokens=100, # Maximum length | |
| ) | |
| # Via llama-cpp-python direct access | |
| output = llm( | |
| "Write a creative story", | |
| temperature=0.8, | |
| top_p=0.95, | |
| top_k=50, | |
| max_tokens=100, | |
| repeat_penalty=1.1, | |
| ) | |
| ``` | |
| ```python | |
| params = SamplingParams( | |
| temperature=0.8, # Higher for more creativity | |
| top_p=0.95, # Consider top 95% probability mass | |
| top_k=50, # Consider top 50 tokens | |
| max_tokens=100, # Maximum length | |
| presence_penalty=0.1, # Reduce repetition | |
| ) | |
| llm.generate("Write a creative story", sampling_params=params) | |
| ``` | |
| ### کنترل تکرار | |
| هر دو چارچوب راههایی برای جلوگیری از تولید متن تکراری ارائه میدهند: | |
| ```python | |
| client.generate( | |
| "Write a varied text", | |
| repetition_penalty=1.1, # Penalize repeated tokens | |
| no_repeat_ngram_size=3, # Prevent 3-gram repetition | |
| ) | |
| ``` | |
| ```python | |
| # Via OpenAI API | |
| response = client.completions.create( | |
| model="smollm2-1.7b-instruct", | |
| prompt="Write a varied text", | |
| frequency_penalty=1.1, # Penalize frequent tokens | |
| presence_penalty=0.8, # Penalize tokens already present | |
| ) | |
| # Via direct library | |
| output = llm( | |
| "Write a varied text", | |
| repeat_penalty=1.1, # Penalize repeated tokens | |
| frequency_penalty=0.5, # Additional frequency penalty | |
| presence_penalty=0.5, # Additional presence penalty | |
| ) | |
| ``` | |
| ```python | |
| params = SamplingParams( | |
| presence_penalty=0.1, # Penalize token presence | |
| frequency_penalty=0.1, # Penalize token frequency | |
| ) | |
| ``` | |
| ### کنترل طول و رشتههای توقف | |
| میتوانید طول تولید را کنترل کنید و زمان توقف را مشخص کنید: | |
| ```python | |
| client.generate( | |
| "Generate a short paragraph", | |
| max_new_tokens=100, | |
| min_new_tokens=10, | |
| stop_sequences=["\n\n", "###"], | |
| ) | |
| ``` | |
| ```python | |
| # Via OpenAI API | |
| response = client.completions.create( | |
| model="smollm2-1.7b-instruct", | |
| prompt="Generate a short paragraph", | |
| max_tokens=100, | |
| stop=["\n\n", "###"], | |
| ) | |
| # Via direct library | |
| output = llm("Generate a short paragraph", max_tokens=100, stop=["\n\n", "###"]) | |
| ``` | |
| ```python | |
| params = SamplingParams( | |
| max_tokens=100, | |
| min_tokens=10, | |
| stop=["###", "\n\n"], | |
| ignore_eos=False, | |
| skip_special_tokens=True, | |
| ) | |
| ``` | |
| ## مدیریت حافظه | |
| هر دو چارچوب تکنیکهای پیشرفتهی مدیریت حافظه را برای استنتاج کارآمد پیادهسازی میکنند. | |
| TGI از Flash Attention 2 و بتچسازی پیوسته استفاده میکند: | |
| ```sh | |
| # Docker deployment with memory optimization | |
| docker run --gpus all -p 8080:80 \ | |
| --shm-size 1g \ | |
| ghcr.io/huggingface/text-generation-inference:latest \ | |
| --model-id HuggingFaceTB/SmolLM2-1.7B-Instruct \ | |
| --max-batch-total-tokens 8192 \ | |
| --max-input-length 4096 | |
| ``` | |
| llama.cpp از کوانتیزهسازی و چیدمان بهینهی حافظه استفاده میکند: | |
| ```sh | |
| # Server with memory optimizations | |
| ./server \ | |
| -m smollm2-1.7b-instruct.Q4_K_M.gguf \ | |
| --host 0.0.0.0 \ | |
| --port 8080 \ | |
| -c 2048 \ # Context size | |
| --threads 4 \ # CPU threads | |
| --n-gpu-layers 32 \ # Use more GPU layers for larger models | |
| --mlock \ # Lock memory to prevent swapping | |
| --cont-batching # Enable continuous batching | |
| ``` | |
| برای مدلهایی که برای GPU شما بیش از حد بزرگ هستند، میتوانید از تخلیه به CPU استفاده کنید: | |
| ```sh | |
| ./server \ | |
| -m smollm2-1.7b-instruct.Q4_K_M.gguf \ | |
| --n-gpu-layers 20 \ # Keep first 20 layers on GPU | |
| --threads 8 # Use more CPU threads for CPU layers | |
| ``` | |
| vLLM برای مدیریت بهینهی حافظه از PagedAttention استفاده میکند: | |
| ```python | |
| from vllm.engine.arg_utils import AsyncEngineArgs | |
| engine_args = AsyncEngineArgs( | |
| model="HuggingFaceTB/SmolLM2-1.7B-Instruct", | |
| gpu_memory_utilization=0.85, | |
| max_num_batched_tokens=8192, | |
| block_size=16, | |
| ) | |
| llm = LLM(engine_args=engine_args) | |
| ``` | |
| ## منابع | |
| - [مستندات Text Generation Inference](https://huggingface.co/docs/text-generation-inference) | |
| - [مخزن GitHub مربوط به TGI](https://github.com/huggingface/text-generation-inference) | |
| - [مستندات vLLM](https://vllm.readthedocs.io/) | |
| - [مخزن GitHub مربوط به vLLM](https://github.com/vllm-project/vllm) | |
| - [مقالهی PagedAttention](https://arxiv.org/abs/2309.06180) | |
| - [مخزن GitHub مربوط به llama.cpp](https://github.com/ggerganov/llama.cpp) | |
| - [مخزن llama-cpp-python](https://github.com/abetlen/llama-cpp-python) | |
Xet Storage Details
- Size:
- 32.1 kB
- Xet hash:
- acf6088c34aec9b45beb28630ae7059af0ba17ecf25a53f98b7d04adcc75313e
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.