update readme

README.md

@@ -32,6 +32,7 @@ In this repo, you can figure out:
 * Details about the quantization models, including GPTQ and KV cache quantization.
 * Statistics of inference performance, including speed and memory.
 * Tutorials on finetuning, including full-parameter tuning, LoRA, and Q-LoRA.
+* Instructions on deployment, with the example of vLLM and FastChat.
 * Instructions on building demos, including WebUI, CLI demo, etc.
 * Introduction to DashScope API service, as well as the instructions on building an OpenAI-style API for your model.
 * Information about Qwen for tool use, agent, and code interpreter
@@ -307,7 +308,24 @@ response, _ = model.chat(tokenizer, "我马上迟到了，怎么做才能不迟
 print(response)
 ```
 
-<br>
+### CPU
+
+To deploy our models on CPU, we strongly advise you to use [qwen.cpp](https://github.com/QwenLM/qwen.cpp), which is a pure C++ implementation of Qwen and tiktoken. Check the repo for more details!
+
+Also, it is also simple to directly run the model on CPU, which requires your specification of device:
+
+```python
+model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="cpu", trust_remote_code=True).eval()
+```
+
+However, it is likely that you suffer from extremely low inference efficiency.
+
+### Multiple GPUs
+
+If you suffer from lack of GPU memory and you would like to run the model on more than 1 GPU, you can directly use the default loading method, which is now supported by Transformers. The previous method based on `utils.py` is deprecated.
+
+However, though this method is simple, the efficiency of the native pipeline parallelism is low. We advise you to use vLLM with FastChat and please read the section for deployment.
+<br><br>
 
 ## Quantization
 
@@ -517,13 +535,9 @@ We also profile the peak GPU memory usage for encoding 2048 tokens as context (a
         <td align="center">Int4</td><td align="center">13.01</td><td align="center">21.79</td>
     </tr>
 </table>
-
-
 <br>
 
 
-
-
 ## Finetuning
 
 ### Usage
@@ -627,6 +641,7 @@ merged_model.save_pretrained(new_model_directory, max_shard_size="2048MB", safe_
 
 Note: For multi-GPU training, you need to specify the proper hyperparameters for distributed training based on your machine. Besides, we advise you to specify your maximum sequence length with the argument `--model_max_length`, based on your consideration of data, memory footprint, and training speed.
 
+
 ### Profiling of Memory and Speed
 We profile the GPU memory and training speed of both LoRA (LoRA (emb) refers to training the embedding and output layer, while LoRA has no trainable embedding and output layer) and Q-LoRA in the setup of single-GPU training. In this test, we experiment on a single A100-SXM4-80G GPU, and we use CUDA 11.8 and Pytorch 2.0. Flash attention 2 is applied. We uniformly use a batch size of 1 and gradient accumulation of 8. We profile the memory (GB) and speed (s/iter) of inputs of different lengths, namely 256, 512, 1024, 2048, 4096, and 8192. We also report the statistics of full-parameter finetuning with Qwen-7B on 2 A100 GPUs. We only report the statistics of 256, 512, and 1024 tokens due to the limitation of GPU memory. The statistics are listed below:
 
@@ -661,7 +676,39 @@ We profile the GPU memory and training speed of both LoRA (LoRA (emb) refers to
         <td>Q-LoRA</td><td align="center">18.7G / 5.3s/it</td><td align="center">18.4G / 6.3s/it</td><td align="center">18.9G / 8.2s/it</td><td align="center">19.9G / 11.8s/it</td><td align="center">23.0G / 20.1s/it</td><td align="center">27.9G / 38.3s/it</td>
     </tr>
 </table>
+<br>
+
+## Deployment
+
+### vLLM 
+For deployment and fast inference, we suggest using vLLM with FastChat. Install the packages first:
+```bash
+pip install vllm fastchat
+```
+Or you can install them from source by `git clone` and `pip install -e .`. We advise you to read their documents if you meet problems in installation. 
 
+To run Qwen with vLLM and FastChat, you need to first launch a controller by:
+```bash
+python -m fastchat.serve.controller
+```
+
+Then you can launch the model worker, which means loading your model for inference. For single GPU inference, you can directly run:
+```bash
+python -m fastchat.serve.vllm_worker --model-path $model_path --trust-remote-code
+```
+However, if you hope to run the model on multiple GPUs for faster inference or larger memory, you can use tensor parallelism supported by vLLM. Suppose you run the model on 4 GPUs, the command is shown below:
+```bash
+python -m fastchat.serve.vllm_worker --model-path $model_path --trust-remote-code --tensor-parallel-size 4
+```
+
+After launching your model worker, you can launch a web demo or an OpenAI API as you like. For web demo, run the following command:
+```bash
+python -m fastchat.serve.gradio_web_server
+```
+For OpenAI API, check the documentation of our OpenAI API for installation first. Then run the command:
+```bash
+python -m fastchat.serve.openai_api_server --host localhost --port 8000
+```
 <br>
 
 ## Demo
@@ -813,24 +860,7 @@ print(response.choices[0].message.content)
 **Function calling** is also supported (but only when `stream=False` for the moment). See the [example usage](examples/function_call_examples.py) here.
 <br><br>
 
-## Deployment
-
-### CPU
 
-To deploy our models on CPU, we strongly advise you to use [qwen.cpp](https://github.com/QwenLM/qwen.cpp), which is a pure C++ implementation of Qwen and tiktoken. Check the repo for more details!
-
-Also, it is also simple to directly run the model on CPU, which requires your specification of device:
-
-```python
-model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="cpu", trust_remote_code=True).eval()
-```
-
-However, it is likely that you suffer from extremely low inference efficiency.
-
-### Multiple GPUs
-
-If you suffer from lack of GPU memory and you would like to run the model on more than 1 GPU, you can directly use the default loading method, which is now supported by Transformers. The previous method based on `utils.py` is deprecated.
-<br><br>
 
 ## Tool Usage
 

README_CN.md

@@ -28,8 +28,9 @@
 
 * 快速上手Qwen-Chat教程，玩转大模型推理
 * 量化模型相关细节，包括GPTQ和KV cache量化
-* 推理性能数据，包括推理速度和显存占用。
+* 推理性能数据，包括推理速度和显存占用
 * 微调的教程，帮你实现全参数微调、LoRA以及Q-LoRA
+* 部署教程，以vLLM和FastChat为例
 * 搭建Demo的方法，包括WebUI和CLI Demo
 * 搭建API的方法，我们提供的示例为OpenAI风格的API
 * 更多关于Qwen在工具调用、Code Interpreter、Agent方面的内容
@@ -297,7 +298,25 @@ print(response)
 response, _ = model.chat(tokenizer, "我马上迟到了，怎么做才能不迟到", history=None)
 print(response)
 ```
-<br>
+
+### CPU
+
+我们推荐你使用 [qwen.cpp](https://github.com/QwenLM/qwen.cpp) 来实现CPU部署和推理。qwen.cpp是Qwen和tiktoken的C++实现。你可以点击链接进入repo了解详情。
+
+当然，直接在CPU上运行模型也是可以的，示例如下：
+
+```python
+model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="cpu", trust_remote_code=True).eval()
+```
+
+但是，这样的推理效率大概率会非常低。
+
+### 多GPU
+
+如果你遇到显存不足的问题而希望使用多张GPU进行推理，可以使用上述的默认的使用方法读取模型。此前提供的脚本`utils.py`已停止维护。
+
+尽管这个方法很简单，但它的效率相对较低。我们建议使用vLLM和FastChat并请阅读部署章节。
+<br><br>
 
 
 ## 量化
@@ -643,6 +662,39 @@ merged_model.save_pretrained(new_model_directory, max_shard_size="2048MB", safe_
 
 <br>
 
+## 部署
+
+### vLLM
+如希望部署及加速推理，我们建议你使用vLLM和FastChat。首先安装相应的代码库：
+```bash
+pip install vllm fastchat
+```
+你也可以通过`git clone`和`pip install -e .`的方式通过源码安装。如果遇到安装问题，请阅读它们的官方文档。
+
+使用vLLM和FastChat运行Qwen之前，首先启动一个controller：
+```bash
+python -m fastchat.serve.controller
+```
+
+然后启动model worker读取模型。如使用单卡推理，运行如下命令：
+```bash
+python -m fastchat.serve.vllm_worker --model-path $model_path --trust-remote-code
+```
+然而，如果你希望使用多GPU加速推理或者增大显存，你可以使用vLLM支持的模型并行机制。假设你需要在4张GPU上运行你的模型，命令如下所示：
+```bash
+python -m fastchat.serve.vllm_worker --model-path $model_path --trust-remote-code --tensor-parallel-size 4
+```
+
+启动model worker后，你可以启动一个web demo或者OpenAI API。启动web demo的命令如下：
+```bash
+python -m fastchat.serve.gradio_web_server
+```
+使用OpenAI API前，请阅读我们的API章节配置好环境，然后运行如下命令：
+```bash
+python -m fastchat.serve.openai_api_server --host localhost --port 8000
+```
+<br>
+
 ## Demo
 
 ### Web UI
@@ -792,24 +844,6 @@ print(response.choices[0].message.content)
 该接口也支持函数调用（**Function Calling**），但暂时仅限 `stream=False` 时能生效。用法见[函数调用示例](examples/function_call_examples.py)。
 <br><br>
 
-## 部署
-
-### CPU
-
-我们推荐你使用 [qwen.cpp](https://github.com/QwenLM/qwen.cpp) 来实现CPU部署和推理。qwen.cpp是Qwen和tiktoken的C++实现。你可以点击链接进入repo了解详情。
-
-当然，直接在CPU上运行模型也是可以的，示例如下：
-
-```python
-model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="cpu", trust_remote_code=True).eval()
-```
-
-但是，这样的推理效率大概率会非常低。
-
-### 多GPU
-
-如果你遇到显存不足的问题而希望使用多张GPU进行推理，可以使用上述的默认的使用方法读取模型。此前提供的脚本`utils.py`已停止维护。
-<br><br>
 
 ## 工具调用
 

README_FR.md

@@ -32,6 +32,7 @@ Dans la repo, vous pouvez trouver:
 * Détails sur les modèles de quantization, y compris GPTQ et la quantization de KV cache.
 * Statistiques sur les performances de l'inférence, y compris la vitesse et la mémoire.
 * Tutoriels sur le finetuning, y compris le finetuning de paramètres complets, LoRA, et Q-LoRA.
+* Instructions de déploiement, avec l'exemple de vLLM et FastChat.
 * Instructions sur la création de démos, y compris WebUI, démo CLI, etc.
 * Introduction au service API de DashScope, ainsi que les instructions pour construire une API de type OpenAI pour votre modèle.
 * Informations sur Qwen pour l'utilisation d'outils, d'agents et code interpreter.
@@ -307,7 +308,24 @@ response, _ = model.chat(tokenizer, "我马上迟到了，怎么做才能不迟
 print(response)
 ```
 
-<br>
+### CPU
+
+Pour déployer nos modèles sur CPU, nous vous conseillons vivement d'utiliser [qwen.cpp](https://github.com/QwenLM/qwen.cpp), qui est une implémentation purement C++ de Qwen et de tiktoken. Consultez le repo pour plus de détails!
+
+Il est simple d'exécuter directement le modèle sur le CPU, ce qui nécessite la spécification de votre appareil:
+
+```python
+model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="cpu", trust_remote_code=True).eval()
+```
+
+Cependant, il est probable que vous souffriez d'une efficacité d'inférence extrêmement faible.
+
+### Plusieurs GPU
+
+Si vous souffrez d'un manque de mémoire GPU et que vous souhaitez exécuter le modèle sur plus d'un GPU, vous pouvez utiliser directement la méthode de chargement par défaut, qui est maintenant supportée par Transformers. La méthode précédente basée sur `utils.py` est obsolète.
+
+Cependant, bien que cette méthode soit simple, l'efficacité du parallélisme natif du pipeline est faible. Nous vous conseillons d'utiliser vLLM avec FastChat et de lire la section relative au déploiement.
+<br><br>
 
 ## Quantization
 
@@ -660,7 +678,39 @@ Nous profilons la mémoire du GPU et la vitesse d'apprentissage de LoRA (LoRA (e
         <td>Q-LoRA</td><td align="center">18.7G / 5.3s/it</td><td align="center">18.4G / 6.3s/it</td><td align="center">18.9G / 8.2s/it</td><td align="center">19.9G / 11.8s/it</td><td align="center">23.0G / 20.1s/it</td><td align="center">27.9G / 38.3s/it</td>
     </tr>
 </table>
+<br>
+
+## Déploiement
+
+### vLLM 
+Pour le déploiement et l'inférence rapide, nous suggérons d'utiliser vLLM avec FastChat. Installez d'abord les paquets:
+```bash
+pip install vllm fastchat
+```
+Ou vous pouvez les installer à partir des sources par `git clone` et `pip install -e .`. Nous vous conseillons de lire leurs documents si vous rencontrez des problèmes lors de l'installation.
+
+Pour faire fonctionner Qwen avec vLLM et FastChat, vous devez d'abord lancer un contrôleur par:
+```bash
+python -m fastchat.serve.controller
+```
 
+Ensuite, vous pouvez lancer le travailleur de modèle, ce qui signifie charger votre modèle pour l'inférence. Pour l'inférence sur un seul GPU, vous pouvez directement lancer:
+```bash
+python -m fastchat.serve.vllm_worker --model-path $model_path --trust-remote-code
+```
+Cependant, si vous souhaitez exécuter le modèle sur plusieurs GPU pour une inférence plus rapide ou une mémoire plus importante, vous pouvez utiliser le parallélisme tensoriel pris en charge par vLLM. Supposons que vous exécutiez le modèle sur 4 GPU, la commande est présentée ci-dessous:
+```bash
+python -m fastchat.serve.vllm_worker --model-path $model_path --trust-remote-code --tensor-parallel-size 4
+```
+
+Après avoir lancé votre model worker, vous pouvez lancer une démo web ou une API OpenAI comme vous le souhaitez. Pour la démo web, exécutez la commande suivante:
+```bash
+python -m fastchat.serve.gradio_web_server
+```
+Pour l'API OpenAI, consultez d'abord la documentation de notre API OpenAI pour l'installation. Exécutez ensuite la commande:
+```bash
+python -m fastchat.serve.openai_api_server --host localhost --port 8000
+```
 <br>
 
 ## Démo
@@ -812,24 +862,6 @@ print(response.choices[0].message.content)
 **Function calling** est aussi supporté (mais seulement quand `stream=False` pour le moment). Voir [l'exemple d'utilisation](examples/function_call_examples.py) ici.
 <br><br>
 
-## Déploiement
-
-### CPU
-
-Pour déployer nos modèles sur CPU, nous vous conseillons vivement d'utiliser [qwen.cpp](https://github.com/QwenLM/qwen.cpp), qui est une implémentation purement C++ de Qwen et de tiktoken. Consultez le repo pour plus de détails!
-
-Il est simple d'exécuter directement le modèle sur le CPU, ce qui nécessite la spécification de votre appareil:
-
-```python
-model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="cpu", trust_remote_code=True).eval()
-```
-
-Cependant, il est probable que vous souffriez d'une efficacité d'inférence extrêmement faible.
-
-### Plusieurs GPU
-
-Si vous souffrez d'un manque de mémoire GPU et que vous souhaitez exécuter le modèle sur plus d'un GPU, vous pouvez utiliser directement la méthode de chargement par défaut, qui est maintenant supportée par Transformers. La méthode précédente basée sur `utils.py` est obsolète.
-<br><br>
 
 ## Utilisation des outils
 

README_JA.md

@@ -36,6 +36,7 @@ Qwen-7B**と**Qwen-14B**の**Qwen**シリーズと、**Qwen-7B-Chat**と**Qwen-1
 * Qwenのクイックスタート。
 * 量子化モデルの詳細（使用量、メモリ、推論速度など）。比較のために、BF16モデルの統計も提供します。
 * フルパラメーターチューニング、LoRA、Q-LoRAを含む、微調整に関するチュートリアル。
+* vLLMとFastChatを例に、デプロイメントについて説明します。
 * WebUI、CLIデモなど、デモの構築に関する説明。
 * あなたのモデルのためのOpenAIスタイルのAPIを構築する手順。
 * ツール使用、エージェント、コードインタプリタの Qwen の詳細。
@@ -301,7 +302,26 @@ print(response)
 response, _ = model.chat(tokenizer, "我马上迟到了，怎么做才能不迟到", history=None)
 print(response)
 ```
-<br>
+
+### CPU
+
+Qwenとtiktokenの純粋なC++実装である [qwen.cpp](https://github.com/QwenLM/qwen.cpp) を使用することを強くお勧めします。詳細はレポを確認してください！
+
+また、CPU上でモデルを直接実行することも簡単ですが、その場合はデバイスの指定が必要です：
+
+
+```python
+model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="cpu", trust_remote_code=True).eval()
+```
+
+ただし、推論効率が極端に低下する可能性があります。
+
+### 複数のGPU
+
+GPUメモリ不足に悩まされ、1つ以上のGPUでモデルを実行したい場合、Transformersでサポートされるようになったデフォルトのロード方法を直接使うことができます。以前の `utils.py` に基づく方法は非推奨です。
+
+しかし、この方法は簡単ですが、ネイティブ・パイプライン並列の効率は低いです。FastChatでvLLMを使用することをお勧めします。
+<br><br>
 
 ## 量子化
 
@@ -645,7 +665,39 @@ merged_model.save_pretrained(new_model_directory, max_shard_size="2048MB", safe_
         <td>Q-LoRA</td><td align="center">18.7G / 5.3s/it</td><td align="center">18.4G / 6.3s/it</td><td align="center">18.9G / 8.2s/it</td><td align="center">19.9G / 11.8s/it</td><td align="center">23.0G / 20.1s/it</td><td align="center">27.9G / 38.3s/it</td>
     </tr>
 </table>
+<br>
+
+## デプロイ
+
+### vLLM 
+デプロイメントと高速推論のためには、FastChatとvLLMを使用することをお勧めします。まずパッケージをインストールしてください：
+```bash
+pip install vllm fastchat
+```
+または、`git clone` と `pip install -e .` を使ってソースからインストールすることもできます。インストールに問題がある場合は、それぞれのドキュメントを読むことを勧める。
+
+QwenをvLLMとFastChatで実行するには、まず以下の方法でコントローラを起動する必要があります：
+```bash
+python -m fastchat.serve.controller
+```
 
+それからmodel workerを起動し、推論のためにモデルをロードします。シングルGPU推論の場合は、直接実行できます：
+```bash
+python -m fastchat.serve.vllm_worker --model-path $model_path --trust-remote-code
+```
+しかし、より高速な推論や大容量メモリーのために複数のGPUでモデルを実行したい場合は、vLLMがサポートするテンソル並列を使用することができます。モデルを4GPUで実行するとすると、コマンドは以下のようになります：
+```bash
+python -m fastchat.serve.vllm_worker --model-path $model_path --trust-remote-code --tensor-parallel-size 4
+```
+
+Model workerを起動したら、Web デモや OpenAI API を好きなように起動できます。ウェブデモの場合は、以下のコマンドを実行します：
+```bash
+python -m fastchat.serve.gradio_web_server
+```
+OpenAI APIについては、まずOpenAI APIのドキュメントをチェックして、インストールしてください。次にコマンドを実行します：
+```bash
+python -m fastchat.serve.openai_api_server --host localhost --port 8000
+```
 <br>
 
 ## デモ
@@ -797,26 +849,6 @@ print(response.choices[0].message.content)
 **Function Calling** もサポートされています(ただし、今のところ `stream=False` の場合のみ)。使用例](examples/function_call_examples.py) を参照してください。
 <br><br>
 
-## デプロイ
-
-### CPU
-
-Qwenとtiktokenの純粋なC++実装である [qwen.cpp](https://github.com/QwenLM/qwen.cpp) を使用することを強くお勧めします。詳細はレポを確認してください！
-
-また、CPU上でモデルを直接実行することも簡単ですが、その場合はデバイスの指定が必要です：
-
-
-```python
-model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="cpu", trust_remote_code=True).eval()
-```
-
-ただし、推論効率が極端に低下する可能性があります。
-
-### 複数のGPU
-
-GPUメモリ不足に悩まされ、1つ以上のGPUでモデルを実行したい場合、Transformersでサポートされるようになったデフォルトのロード方法を直接使うことができます。以前の `utils.py` に基づく方法は非推奨です。
-<br><br>
-
 ## ツールの使用
 
 Qwen-7B-Chat は、API、データベース、モデルなど、ツールの利用に特化して最適化されており、ユーザは独自の Qwen-7B ベースの LangChain、エージェント、コードインタプリタを構築することができます。ツール利用能力を評価するための評価[ベンチマーク](eval/EVALUATION.md)では、Qwen-7B は安定した性能に達しています。