Platform For AI:LLMデプロイ

背景情報

Generative Pre-trained Transformer (GPT) やTongYi Qianwen (Qwen) シリーズのモデルなどのLLMのアプリケーションは、特に推論タスクで大きな注目を集めています。 EASを使用すると、オープンソースのLLMを推論サービスとして簡単にデプロイできます。 サポートされているLLMには、Llama 3、Qwen、Llama 2、ChatGLM、Baichuan、Yi-6B、Mistral-7B、Falcon-7Bが含まれます。 WebUIまたはAPIを使用してモデルを呼び出すだけでなく、LangChainフレームワークを使用してビジネスデータに基づいてカスタム応答を生成することもできます。

• LangChainはである何:

  LangChainは、AI開発者がGPT-4などのLLMを外部データと統合してパフォーマンスを向上させ、リソース利用を最適化できるようにするオープンソースフレームワークです。

• LangChainはいかに働きますか:

  LangChainは、ソースデータ (20ページのPDFファイルなど) をより小さなチャンクに分割し、埋め込みモデル (BGEやtext2vecなど) を使用してチャンクを数値ベクトルに変換し、ベクトルデータベースにベクトルを保存します。

  このように、LLMは、ベクトルデータベース内のデータを使用して応答を生成することができる。 各ユーザクエリについて、LangChainは、ユーザクエリに関連するチャンクをベクトルデータベースから取得し、取得した情報とクエリをプロンプトに含め、プロンプトをLLMに送信して回答を生成します。

前提条件

カスタムモデルをデプロイする場合は、次の前提条件が満たされていることを確認してください。

• モデルファイルと関連する設定ファイルを用意します。 次の図は、モデルファイルのサンプルです。

  config.jsonファイルを構成ファイルに含める必要があります。 Huggingfaceモデル形式に基づいてconfig.jsonファイルを設定する必要があります。 サンプルファイルの詳細については、「config.json」をご参照ください。

• モデルファイルを保存するために、Object Storage Service (OSS) バケットまたはNASファイルシステムが作成されます。 また、モデルファイルをPAIのAIアセットとして登録して、管理やメンテナンスを容易にすることもできます。 OSSバケットの作成方法の詳細については、「OSSコンソールを使用して開始する」をご参照ください。

• モデルファイルと設定ファイルがOSSバケットにアップロードされます。 詳細については、「OSSコンソールを使用して開始する」をご参照ください。

制限事項

• EASによって提供される推論加速エンジンは、以下のモデルのみをサポートする: Qwen2-7b、Qwen1.5 − 1.8b、Qwen1.5 − 7b、Qwen1.5 − 14b、llama3-8b、llama2-7b、llama2-13b、chatglm3-6b、baichuan2-7b、baichuan2-13b、falcon-7b、yi-6b、mistral-7b-instruct-v0.2、gemma-2b-it、gemma-7b-it deepseek-coder-7b-instruct-v1.5。

• LangChainフレームワークは、推論アクセラレーションエンジンではサポートされていません。

LLMをEASにデプロイ

次の配置方法がサポートされています。

EASサービスを呼び出す

web UIを使用したEASサービスの呼び出し

1. デプロイされたサービスを見つけ、[サービスタイプ] 列の [Webアプリの表示] をクリックします。

2. WebUIページで推論パフォーマンスをテストします。

   入力テキストボックスに文を入力し、[送信] をクリックして会話を開始します。 サンプル入力: パーソナルファイナンスの学習プランを提供します。

3. LangChainフレームワークを使用して、独自のビジネスデータをサービスに統合し、ローカルのナレッジベースに基づいてカスタマイズされた回答を生成します。

   1. デプロイしたサービスのWebUIページで、[LangChain] タブをクリックします。

   2. ChatLLM-LangChain-WebUIページの左下隅で、画面の指示に従ってナレッジベースをアップロードします。 TXT、Markdown、DOCX、およびPDFの形式でファイルをアップロードできます。

      たとえば、README.mdファイルをアップロードし、Vectorstoreのナレッジをクリックします。 次の結果は、ファイル内のデータがロードされたことを示します。

   3. アップロードしたデータに関する質問を入力テキストボックスに入力し、[送信] をクリックして会話を開始します。

      サンプル入力: deepspeedのインストール方法

API操作を使用したEASサービスの呼び出し

1. サービスエンドポイントとトークンを取得します。

   1. Elastic Algorithm Service (EAS) ページに移動します。 詳細については、このトピックの「EASにLLMを展開する」を参照してください。

   2. サービスの名前をクリックして、[サービスの詳細] タブに移動します。

   3. [基本情報] セクションで、[呼び出し方法] をクリックします。 表示されるダイアログボックスの [パブリックエンドポイント] タブで、トークンとエンドポイントを取得します。

2. API操作を呼び出して推論を実行するには、次のいずれかの方法を使用します。

   HTTPの使用

   • 非ストリーミングモード

     cURLコマンドが実行されると、クライアントは次のタイプの標準HTTPリクエストを送信します。

     • ストリング要求

       curl $host -H 'Authorization: $authorization' --data-binary @chatllm_data.txt -v

       $authorizationをトークンに置き換えます。 $hostをエンドポイントに置き換えます。 chatllm_data.txtファイルは、プロンプトを含むプレーンテキストファイルです。

     • 構造化リクエスト

       curl $host -H 'Authorization: $authorization' -H "Content-type: application/json" --data-binary @chatllm_data.json -v -H "Connection: close"

       chatllm_data.jsonファイルを使用して推論パラメーターを設定します。 次のサンプルコードは、chatllm_data.jsonファイルの形式例を示しています。

       {
         "max_new_tokens": 4096,
         "use_stream_chat": false,
         "prompt": "How to install it?",
         "system_prompt": "Act like you are programmer with 5+ years of experience.",
         "history": [
           [
             "Can you tell me what's the bladellm?",
             "BladeLLM is an framework for LLM serving, integrated with acceleration techniques like quantization, ai compilation, etc. , and supporting popular LLMs like OPT, Bloom, LLaMA, etc."
           ]
         ],
         "temperature": 0.8,
         "top_k": 10,
         "top_p": 0.8,
         "do_sample": true,
         "use_cache": true
       }

       次の表に、上記のコードのパラメーターを示します。 ビジネス要件に基づいてパラメーターを設定します。

       パラメーター	説明	デフォルト値
       max_new_tokens	出力トークンの最大数。	2048
       use_stream_chat	ストリーミングモードで出力トークンを返すかどうかを指定します。	true
       プロンプト	ユーザープロンプト。	""
       system_prompt	システムプロンプト。	""
       history	対話の歴史。 値はList[Tuple(str, str)] 形式です。	[()]
       temperature	モデル出力のランダム性。 より大きな値は、より高いランダム性を指定する。 値0は固定出力を指定します。 値はFloat型で、0から1の範囲です。	0.95
       top_k	生成された結果から選択された出力の数。	30
       top_p	生成された結果から選択された出力の確率しきい値。 値はFloat型で、0から1の範囲です。	0.8
       do_sample	出力サンプリングを有効にするかどうかを指定します。	true
       use_cache	KVキャッシュを有効にするかどうかを指定します。	true

     Pythonリクエストパッケージに基づいて独自のクライアントを実装することもできます。 例：

     import argparse
     import json
     from typing import Iterable, List
     
     import requests
     
     def post_http_request(prompt: str,
                           system_prompt: str,
                           history: list,
                           host: str,
                           authorization: str,
                           max_new_tokens: int = 2048,
                           temperature: float = 0.95,
                           top_k: int = 1,
                           top_p: float = 0.8,
                           langchain: bool = False,
                           use_stream_chat: bool = False) -> requests.Response:
         headers = {
             "User-Agent": "Test Client",
             "Authorization": f"{authorization}"
         }
         if not history:
             history = [
                 (
                     "San Francisco is a",
                     "city located in the state of California in the United States. \
                     It is known for its iconic landmarks, such as the Golden Gate Bridge \
                     and Alcatraz Island, as well as its vibrant culture, diverse population, \
                     and tech industry. The city is also home to many famous companies and \
                     startups, including Google, Apple, and Twitter."
                 )
             ]
         pload = {
             "prompt": prompt,
             "system_prompt": system_prompt,
             "top_k": top_k,
             "top_p": top_p,
             "temperature": temperature,
             "max_new_tokens": max_new_tokens,
             "use_stream_chat": use_stream_chat,
             "history": history
         }
         if langchain:
             pload["langchain"] = langchain
         response = requests.post(host, headers=headers,
                                  json=pload, stream=use_stream_chat)
         return response
     
     def get_response(response: requests.Response) -> List[str]:
         data = json.loads(response.content)
         output = data["response"]
         history = data["history"]
         return output, history
     
     if __name__ == "__main__":
         parser = argparse.ArgumentParser()
         parser.add_argument("--top-k", type=int, default=4)
         parser.add_argument("--top-p", type=float, default=0.8)
         parser.add_argument("--max-new-tokens", type=int, default=2048)
         parser.add_argument("--temperature", type=float, default=0.95)
         parser.add_argument("--prompt", type=str, default="How can I get there?")
         parser.add_argument("--langchain", action="store_true")
     
         args = parser.parse_args()
     
         prompt = args.prompt
         top_k = args.top_k
         top_p = args.top_p
         use_stream_chat = False
         temperature = args.temperature
         langchain = args.langchain
         max_new_tokens = args.max_new_tokens
     
         host = "<EAS service public endpoint>"
         authorization = "<EAS service public token>"
     
         print(f"Prompt: {prompt!r}\n", flush=True)
         # System prompts can be included in the requests. 
         system_prompt = "Act like you are programmer with \
                     5+ years of experience."
     
         # Dialogue history can be included in the requests. The client manages the history to implement multi-round dialogues. In most cases, the information from the previous round of dialogue is used. The information is in the List[Tuple(str, str)] format. 
         history = []
         response = post_http_request(
             prompt, system_prompt, history,
             host, authorization,
             max_new_tokens, temperature, top_k, top_p,
             langchain=langchain, use_stream_chat=use_stream_chat)
         output, history = get_response(response)
         print(f" --- output: {output} \n --- history: {history}", flush=True)
     
     # The server returns a JSON response that includes the inference result and dialogue history. 
     def get_response(response: requests.Response) -> List[str]:
         data = json.loads(response.content)
         output = data["response"]
         history = data["history"]
         return output, history

     次のパラメータに注意してください。

     • hostパラメーターをサービスエンドポイントに設定します。

     • authorizationパラメーターをサービストークンに設定します。

   • ストリーミングモード

     ストリーミングモードでは、HTTP SSEメソッドが使用されます。 サンプルコード：

     import argparse
     import json
     from typing import Iterable, List
     
     import requests
     
     
     def clear_line(n: int = 1) -> None:
         LINE_UP = '\033[1A'
         LINE_CLEAR = '\x1b[2K'
         for _ in range(n):
             print(LINE_UP, end=LINE_CLEAR, flush=True)
     
     
     def post_http_request(prompt: str,
                           system_prompt: str,
                           history: list,
                           host: str,
                           authorization: str,
                           max_new_tokens: int = 2048,
                           temperature: float = 0.95,
                           top_k: int = 1,
                           top_p: float = 0.8,
                           langchain: bool = False,
                           use_stream_chat: bool = False) -> requests.Response:
         headers = {
             "User-Agent": "Test Client",
             "Authorization": f"{authorization}"
         }
         if not history:
             history = [
                 (
                     "San Francisco is a",
                     "city located in the state of California in the United States. \
                     It is known for its iconic landmarks, such as the Golden Gate Bridge \
                     and Alcatraz Island, as well as its vibrant culture, diverse population, \
                     and tech industry. The city is also home to many famous companies and \
                     startups, including Google, Apple, and Twitter."
                 )
             ]
         pload = {
             "prompt": prompt,
             "system_prompt": system_prompt,
             "top_k": top_k,
             "top_p": top_p,
             "temperature": temperature,
             "max_new_tokens": max_new_tokens,
             "use_stream_chat": use_stream_chat,
             "history": history
         }
         if langchain:
             pload["langchain"] = langchain
         response = requests.post(host, headers=headers,
                                  json=pload, stream=use_stream_chat)
         return response
     
     
     def get_streaming_response(response: requests.Response) -> Iterable[List[str]]:
         for chunk in response.iter_lines(chunk_size=8192,
                                          decode_unicode=False,
                                          delimiter=b"\0"):
             if chunk:
                 data = json.loads(chunk.decode("utf-8"))
                 output = data["response"]
                 history = data["history"]
                 yield output, history
     
     
     if __name__ == "__main__":
         parser = argparse.ArgumentParser()
         parser.add_argument("--top-k", type=int, default=4)
         parser.add_argument("--top-p", type=float, default=0.8)
         parser.add_argument("--max-new-tokens", type=int, default=2048)
         parser.add_argument("--temperature", type=float, default=0.95)
         parser.add_argument("--prompt", type=str, default="How can I get there?")
         parser.add_argument("--langchain", action="store_true")
         args = parser.parse_args()
     
         prompt = args.prompt
         top_k = args.top_k
         top_p = args.top_p
         use_stream_chat = True
         temperature = args.temperature
         langchain = args.langchain
         max_new_tokens = args.max_new_tokens
     
         host = ""
         authorization = ""
     
         print(f"Prompt: {prompt!r}\n", flush=True)
         system_prompt = "Act like you are programmer with \
                     5+ years of experience."
         history = []
         response = post_http_request(
             prompt, system_prompt, history,
             host, authorization,
             max_new_tokens, temperature, top_k, top_p,
             langchain=langchain, use_stream_chat=use_stream_chat)
     
         for h, history in get_streaming_response(response):
             print(
                 f" --- stream line: {h} \n --- history: {history}", flush=True)
     

     次のパラメータに注意してください。

     • hostパラメーターをサービスエンドポイントに設定します。

     • authorizationパラメーターをサービストークンに設定します。

   WebSocketの使用

   WebSocketプロトコルは、ダイアログ履歴を効率的に処理できます。 WebSocketメソッドを使用してサービスに接続し、1回以上のダイアログを実行できます。 サンプルコード：

   import os
   import time
   import json
   import struct
   from multiprocessing import Process
   
   import websocket
   
   round = 5
   questions = 0
   
   
   def on_message_1(ws, message):
       if message == "<EOS>":
           print('pid-{} timestamp-({}) receives end message: {}'.format(os.getpid(),
                 time.time(), message), flush=True)
           ws.send(struct.pack('!H', 1000), websocket.ABNF.OPCODE_CLOSE)
       else:
           print("{}".format(time.time()))
           print('pid-{} timestamp-({}) --- message received: {}'.format(os.getpid(),
                 time.time(), message), flush=True)
   
   
   def on_message_2(ws, message):
       global questions
       print('pid-{} --- message received: {}'.format(os.getpid(), message))
       # end the client-side streaming
       if message == "<EOS>":
           questions = questions + 1
           if questions == 5:
               ws.send(struct.pack('!H', 1000), websocket.ABNF.OPCODE_CLOSE)
   
   
   def on_message_3(ws, message):
       print('pid-{} --- message received: {}'.format(os.getpid(), message))
       # end the client-side streaming
       ws.send(struct.pack('!H', 1000), websocket.ABNF.OPCODE_CLOSE)
   
   
   def on_error(ws, error):
       print('error happened: ', str(error))
   
   
   def on_close(ws, a, b):
       print("### closed ###", a, b)
   
   
   def on_pong(ws, pong):
       print('pong:', pong)
   
   # stream chat validation test
   def on_open_1(ws):
       print('Opening Websocket connection to the server ... ')
       params_dict = {}
       params_dict['prompt'] = """Show me a golang code example: """
       params_dict['temperature'] = 0.9
       params_dict['top_p'] = 0.1
       params_dict['top_k'] = 30
       params_dict['max_new_tokens'] = 2048
       params_dict['do_sample'] = True
       raw_req = json.dumps(params_dict, ensure_ascii=False).encode('utf8')
       # raw_req = f"""To open a Websocket connection to the server: """
   
       ws.send(raw_req)
       # end the client-side streaming
   
   
   # multi-round query validation test
   def on_open_2(ws):
       global round
       print('Opening Websocket connection to the server ... ')
       params_dict = {"max_new_tokens": 6144}
       params_dict['temperature'] = 0.9
       params_dict['top_p'] = 0.1
       params_dict['top_k'] = 30
       params_dict['use_stream_chat'] = True
       params_dict['prompt'] = "Hello! "
       params_dict = {
           "system_prompt":
           "Act like you are programmer with 5+ years of experience."
       }
       raw_req = json.dumps(params_dict, ensure_ascii=False).encode('utf8')
       ws.send(raw_req)
       params_dict['prompt'] = "Please write a sorting algorithm in Python."
       raw_req = json.dumps(params_dict, ensure_ascii=False).encode('utf8')
       ws.send(raw_req)
       params_dict['prompt'] = "Please convert the programming language to Java."
       raw_req = json.dumps(params_dict, ensure_ascii=False).encode('utf8')
       ws.send(raw_req)
       params_dict['prompt'] = "Please introduce yourself."
       raw_req = json.dumps(params_dict, ensure_ascii=False).encode('utf8')
       ws.send(raw_req)
       params_dict['prompt'] = "Please summarize the dialogue above."
       raw_req = json.dumps(params_dict, ensure_ascii=False).encode('utf8')
       ws.send(raw_req)
   
   
   # Langchain validation test.
   def on_open_3(ws):
       global round
       print('Opening Websocket connection to the server ... ')
   
       params_dict = {}
       # params_dict['prompt'] = """To open a Websocket connection to the server: """
       params_dict['prompt'] = """Can you tell me what's the MNN?"""
       params_dict['temperature'] = 0.9
       params_dict['top_p'] = 0.1
       params_dict['top_k'] = 30
       params_dict['max_new_tokens'] = 2048
       params_dict['use_stream_chat'] = False
       params_dict['langchain'] = True
       raw_req = json.dumps(params_dict, ensure_ascii=False).encode('utf8')
       ws.send(raw_req)
   
   
   authorization = ""
   host = "ws://" + ""
   
   
   def single_call(on_open_func, on_message_func, on_clonse_func=on_close):
       ws = websocket.WebSocketApp(
           host,
           on_open=on_open_func,
           on_message=on_message_func,
           on_error=on_error,
           on_pong=on_pong,
           on_close=on_clonse_func,
           header=[
               'Authorization: ' + authorization],
       )
   
       # setup ping interval to keep long connection.
       ws.run_forever(ping_interval=2)
   
   
   if __name__ == "__main__":
       for i in range(5):
           p1 = Process(target=single_call, args=(on_open_1, on_message_1))
           p2 = Process(target=single_call, args=(on_open_2, on_message_2))
           p3 = Process(target=single_call, args=(on_open_3, on_message_3))
   
           p1.start()
           p2.start()
           p3.start()
   
           p1.join()
           p2.join()
           p3.join()

   次のパラメータに注意してください。

   • authorizationパラメーターをサービストークンに設定します。

   • hostパラメーターをサービスエンドポイントに設定します。エンドポイントのhttpプレフィックスをwsに置き換えます。

   • use_stream_chatパラメーターを使用して、クライアントがストリーミングモードで出力を生成するかどうかを指定します。 デフォルト値は True です。

   • マルチラウンドダイアログを実装するには、上記のコードのon_open_2関数を参照してください。

よくある質問

別のオープンソースLLMに切り替えるにはどうすればよいですか?

以下の手順を実行します。

1. Elastic Algorithm Service (EAS) ページで、更新するサービスを見つけ、[操作] 列の [更新] をクリックします。

2. 別のオープンソースLLMに切り替えます。

   • シナリオベースのモデル配置

     [LLMデプロイ] ページで、[モデルタイプ] を目的のLLMに設定し、[デプロイ] をクリックします。

   • カスタムモデルの配置

     [サービスのデプロイ] ページで、[コマンド] および [ノードタイプ] パラメーターを変更し、[デプロイ] をクリックします。 次の表に、さまざまなモデルのパラメーター設定を示します。

     名前	コマンド	推奨仕様
     Qwen2-7b	python webui/webui_server.py -- port=8000 -- model-path=Qwen/Qwen2-7B-Instrict	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (32 GB)
     Qwen2-72b	python webui/webui_server.py -- port=8000 -- model-path=Qwen/Qwen2-72B-Instrict	2 × NVIDIA A100 (80 GB) 4 × NVIDIA A100 (40 GB) 8 × NVIDIA V100 (32 GB)
     Qwen2-57b-A14b	python webui/webui_server.py -- port=8000 -- model-path=Qwen/Qwen2-57B-A14B-Instrict	2 × NVIDIA A100 (80 GB) 4 × NVIDIA A100 (40 GB) 4 × NVIDIA V100 (32 GB)
     Qwen1.5-1.8b	python webui/webui_server.py -- port=8000 -- model-path=Qwen/Qwen1.5-1.8B-チャット	1 × NVIDIA T4 1 × NVIDIA V100 (16 GB) 1 × GU30 1 × NVIDIA A10
     Qwen1.5-7b	python webui/webui_server.py -- port=8000 -- model-path=Qwen/Qwen1.5-7B-チャット	1 × GU30 1 × NVIDIA A10
     Qwen1.5-14b	python webui/webui_server.py -- port=8000 -- model-path=Qwen/Qwen1.5-14B-チャット	1 × NVIDIA V100 (32 GB) 1 × NVIDIA A100 (40 GB) 1 × NVIDIA A100 (80 GB) 2 × GU30 2 × NVIDIA A10
     Qwen1.5-32b	python webui/webui_server.py -- port=8000 -- model-path=Qwen/Qwen1.5-32B-チャット	1 × NVIDIA A100 (80 GB) 4 × NVIDIA V100 (32 GB)
     Qwen1.5-72b	python webui/webui_server.py -- port=8000 -- model-path=Qwen/Qwen1.5-72B-チャット	8 × NVIDIA V100 (32 GB) 2 × NVIDIA A100 (80 GB) 4 × NVIDIA A100 (40 GB)
     Qwen1.5-110b	python webui/webui_server.py -- port=8000 -- model-path=Qwen/Qwen1.5-110B-チャット	8 × NVIDIA A100 (40 GB) 4 × NVIDIA A100 (80 GB)
     llama3-8b	python webui/webui_server.py -- port=8000 -- model-path=/huggingface/meta-Llama-3-8B-Instruct/ -- model-type=llama3	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (32 GB)
     llama3-70b	python webui/webui_server.py -- port=8000 -- model-path=/huggingface/meta-Llama-3-70B-Instruct/ -- model-type=llama3	2 × NVIDIA A100 (80 GB) 4 × NVIDIA A100 (40 GB) 8 × NVIDIA V100 (32 GB)
     Llama2-7b	python webui/webui_server.py -- port=8000 -- model-path=meta-llama/Llama-2-7b-chat-hf	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (32 GB)
     Llama2-13b	python webui/webui_server.py -- port=8000 -- model-path=meta-llama/Llama-2-13b-chat-hf	1 × NVIDIA V100 (32 GB) 2 × GU30 2 × NVIDIA A10
     llama2-70b	python webui/webui_server.py -- port=8000 -- model-path=meta-llama/Llama-2-70b-chat-hf	8 × NVIDIA V100 (32 GB) 2 × NVIDIA A100 (80 GB) 4 × NVIDIA A100 (40 GB)
     chatglm3-6b	python webui/webui_server.py -- port=8000 -- model-path=THUDM/chatglm3-6b	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (16 GB) 1 × NVIDIA V100 (32 GB)
     baichuan2-7b	python webui/webui_server.py -- port=8000 -- model-path=baichuan-inc/Baichuan2-7B-Chat	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (32 GB)
     baichuan2-13b	python webui/webui_server.py -- port=8000 -- model-path=baichuan-inc/Baichuan2-13B-Chat	2 × GU30 2 × NVIDIA A10 1 × NVIDIA V100 (32 GB)
     falcon-7b	python webui/webui_server.py -- port=8000 -- model-path=tiiuae/falcon-7b-instruct	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (32 GB)
     falcon-40b	python webui/webui_server.py -- port=8000 -- model-path=tiiuae/falcon-40b-instruct	8 × NVIDIA V100 (32 GB) 2 × NVIDIA A100 (80 GB) 4 × NVIDIA A100 (40 GB)
     falcon-180b	python webui/webui_server.py -- port=8000 -- model-path=tiiuae/falcon-180B-chat	8 × NVIDIA A100 (80 GB)
     Yi-6b	python webui/webui_server.py -- port=8000 -- model-path=01-ai/Yi-6B-Chat	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (16 GB) 1 × NVIDIA V100 (32 GB)
     Yi-34b	python webui/webui_server.py -- port=8000 -- model-path=01-ai/Yi-34B-Chat	4 × NVIDIA V100 (16 GB) 1 × NVIDIA A100 (80 GB) 4 × NVIDIA A10
     mistral-7b-instruct-v0.2	python webui/webui_server.py -- port=8000 -- model-path=mistralai/Mistral-7B-Instruct-v0。2	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (32 GB)
     mixtral-8x7b-instruct-v0.1	python webui/webui_server.py -- port=8000 -- model-path=mistralai/Mixtral-8x7B-Instruct-v0。1	4 × NVIDIA A100 (80 GB)
     gemma-2b-it	python webui/webui_server.py -- port=8000 -- model-path=google/gemma-2b-it	1 × NVIDIA T4 1 × NVIDIA V100 (16 GB) 1 × GU30 1 × NVIDIA A10
     gemma-7b-it	python webui/webui_server.py -- port=8000 -- model-path=google/gemma-7b-it	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (32 GB)
     deepseek-coder-7b-instruct-v1.5	python webui/webui_server.py -- port=8000 -- model-path=deepseek-ai/deepseek-coder-7b-instruct-v1。5	1 × GU30 1 × NVIDIA A10 1 × NVIDIA V100 (32 GB)
     deepseek-coder-33b指示	python webui/webui_server.py -- port=8000 -- model-path=deepseek-ai/deepseek-coder-33b-指示	1 × NVIDIA A100 (80 GB) 2 × NVIDIA A100 (40 GB) 4 × NVIDIA V100 (32 GB)
     deepseek-v2ライト	python webui/webui_server.py -- port=8000 -- model-path=deepseek-ai/DeepSeek-V2-Lite-Chat	1 × NVIDIA A10 1 × NVIDIA A100 (40 GB) 1 × NVIDIA L20

関連ドキュメント

EASを使用して、LLMおよびRAG (Retrieval-Augmented Generation) と統合されたダイアログサービスをデプロイできます。 LangChainを使用してビジネスデータを統合した後、WebUIまたはAPI操作を使用してモデルの推論機能を検証できます。 詳細については、「RAGベースのLLMチャットボット」をご参照ください。