<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kazuhiro Yamasaki on Medium]]></title>
        <description><![CDATA[Stories by Kazuhiro Yamasaki on Medium]]></description>
        <link>https://medium.com/@kyamasaki?source=rss-f8c9d9365fc7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*M223VgWs8CYJJIfb</url>
            <title>Stories by Kazuhiro Yamasaki on Medium</title>
            <link>https://medium.com/@kyamasaki?source=rss-f8c9d9365fc7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 15:54:28 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kyamasaki/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Triton Inference Server のバッチ サイズを紐解く]]></title>
            <link>https://medium.com/nvidiajapan/triton-inference-server-batchsize-demystified-ja-241eda69fece?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/241eda69fece</guid>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Fri, 05 Aug 2022 05:42:23 GMT</pubDate>
            <atom:updated>2022-08-05T05:42:23.418Z</atom:updated>
            <content:encoded><![CDATA[<p>みなさま Medium ではご無沙汰しております。NVIDIA の山崎です。同時に公開した <a href="https://developer-blogs.nvidia.com/ja-jp/triton-inference-server-june-2022-release-overview/">Triton Inference Server 2022 年 6 月のリリース概要</a>はご覧いただけましたでしょうか。この記事の中で、このバージョンから自動生成される設定ファイルのデフォルト挙動が変わる旨について言及しました。変更内容としては、dyamic batching がデフォルトで有効になるというものですが、一方でデプロイ可能なモデルに何か制約がつくのか? そもそも Triton のバッチ サイズ関連の設定ってどうなってるの? など、疑問を持たれているかもしれません。この記事では、そうした疑問を少しでも解消すべく、Triton におけるバッチ サイズの設定について詳細な説明を試みます。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*-i2g8lLdKCLyzZjuhxZXaQ.png" /></figure><h3>長くて読む気がしない人に贈るバッチ サイズ周りの設定ポイント</h3><ul><li>設定のことなんて考えたくない<br>→ 冒頭で言及している設定の自動生成機能を利用 (=Triton 起動時に --strict-model-config=false オプションを指定)</li><li>手っ取り早く任意のバッチ サイズを扱いたい<br>→ モデルのエクスポート時に可変バッチ (=バッチ次元に -1) を設定し、 max_batch_size は指定せず、dims の先頭を -1 にする</li><li>複数のリクエストからバッチを構成したい<br>→ やはりモデルのエクスポート時、バッチ サイズが可変になるよう設定しておき、 max_batch_size に想定している最大バッチ サイズを設定し、dims からバッチ次元を除外してテンソル形状を定義し、dynamic_batchingを設定する</li></ul><p>なお上記、後述しますがバックエンドによって (特に TorchScript 利用時は) 条件が緩和される方向の例外があったりするため、最終的には多少実験していただくことを推奨します。</p><h3>Triton で指定可能なバッチ サイズ関連の設定</h3><p>そもそも「バッチ サイズ」といえば、多くの場合、複数のデータをまとめて処理する際のデータの個数を指し、入力されるテンソルの最初の次元で扱われるものです。画像認識であればまとめて処理される画像の枚数、文書分類であれば分類対象のドキュメントの数、といった具合です。こうしたまとめて実行されるデータの数は、オフライン推論であれば固定することが比較的容易である一方、オンライン推論では様々なサイズを考慮する必要があり、バッチ サイズを固定することは好ましくない場合があります。</p><p>こうした状況をサポートするべく、Triton には様々な設定が存在しています。記事執筆時点で は、バッチ関連の主な設定として以下のものがあります。</p><ul><li><a href="https://github.com/triton-inference-server/server/blob/r22.06/docs/model_configuration.md#maximum-batch-size">max_batch_size</a></li><li><a href="https://github.com/triton-inference-server/server/blob/r22.06/docs/model_configuration.md#inputs-and-outputs">dims</a></li><li><a href="https://github.com/triton-inference-server/server/blob/r22.06/docs/model_configuration.md#preferred-batch-sizes">dynamic_batching の </a><a href="https://github.com/triton-inference-server/server/blob/r22.06/docs/model_configuration.md#preferred-batch-sizes">preferred_batch_size</a></li></ul><p>max_batch_size には、許容する最大のバッチ サイズを 1 以上の値で指定します。ゼロ、もしくは指定しないことも可能です。</p><p>dims には、入出力テンソルの形状を指定します。-1 を指定すると、その次元は可変長となります。バッチ サイズという点では、主に先頭要素を -1 にするかどうかがポイントとなります。また詳細は後述しますが、max_batch_size を指定する場合、dims の先頭要素はバッチの次元ではなくなるケースがほとんどです。</p><p>preferred_batch_size は、後述する dynamic batching を利用する際のバッチ サイズを制御するための設定です。主に TensorRT で複数のバッチ サイズ向けに最適化されている状況で利用されることが想定されており、特定のバッチ サイズが特に性能向上に寄与する場合に指定することが推奨されます。これが設定されている場合、Triton のスケジューラは指定されている中から最大のサイズでバッチを構成し、推論実行しようとします。なお、この設定が指定されていない場合は、max_batch_size 以下の最大サイズでバッチを構成して推論します。</p><p>またこれらに加えて、実際にはモデル保存時の設定も関連します。たとえば、TensorFlow 利用時の SavedModel であれば <a href="https://www.tensorflow.org/api_docs/python/tf/TensorSpec">tf.TensorSpec</a> などを利用した signature の指定であったり、PyTorch を ONNX にエクスポートする場合であれば <a href="https://pytorch.org/docs/stable/onnx.html#torch.onnx.export">torch.onnx.export</a> に渡す args や dynamic_axes などです。</p><p>このように、バッチ サイズに関する設定には主に max_batch_size、dims、dynamic_batching の preferred_batch_size、およびモデル保存時の設定の 4 つの要素が存在しています。ではこれらはどのように関連しているのでしょうか。</p><h3>max_batch_size と dims: default scheduler の場合</h3><p>まず max_batch_size と dims についてです。何をおいても押さえておくべきポイントとして、「max_batch_size 未指定もしくは 0 が指定される場合、デフォルトでは、クライアントから送信できるテンソルは dims と一致する形状のみ」というものがあります。たとえば画像分類モデルなどで、(224, 224, 3) というテンソルを入力として受け取るモデルを考えます。このとき、Triton 側に以下のような設定を入れた場合、</p><pre>max_batch_size: 0<br>...<br>input [{<br>...<br>    dims: [224, 224, 3]<br>...</pre><p>複数の画像をまとめて送信することはできず、Triton 側での推論は常にバッチ サイズ 1 相当の状況で実行されることになります。加えて、モデルのエクスポート時に一次元目をバッチの次元として指定していた場合、上記の設定ではモデルロード自体に失敗します。(注: 後述しますがバックエンドによっては通るものもあります)</p><p>では dims にバッチの次元に相当する値を入れる場合どうなるでしょうか。この場合も原則として、クライアント側のリクエストには dims と一致する形状のテンソルのみが許容されます。一方で先に述べたとおり、-1 を指定し可変長として扱うことで、任意のバッチ サイズのリクエストを送信することはできます。たとえば以下のような設定です。</p><pre>...<br>input [{<br>...<br>    dims: [-1, 224, 224, 3]<br>...</pre><p>これにより、クライアント側で複数データを扱う必要のある状況はカバーされます。ただし、この指定を行うためには、モデルのエクスポート時に先頭次元が -1 で可変長を仮定している必要があります。(注: こちらもバックエンドによっては、エクスポート時に固定サイズを前提としていても問題なく動くケースがあります)</p><p>とはいえ実利用を考えた場合、上記の設定では問題になるケースがあると想像できます。特に指定をしない場合、Triton では <a href="https://github.com/triton-inference-server/server/blob/r22.06/docs/model_configuration.md#default-scheduler">default scheduler</a> が利用されます。ここまで述べてきたような max_batch_size を設定しないケースでは、この default scheduler が利用され、リクエストごとに推論実行されます。しかし Triton を利用するような状況では、多数のクライアントが独立してリクエストを送信してくることがほとんどで、リクエストごとに推論実行するのはあまり効率的ではありません。そこで、Triton には性能向上のための重要な機構として、<a href="https://github.com/triton-inference-server/server/blob/r22.06/docs/model_configuration.md#dynamic-batcher">dynamic batcher</a> が存在します。</p><h3>max_batch_size と dims: dynamic batcher の場合</h3><p>詳細はこの記事の範囲から外れるため割愛しますが、dynamic batcher は複数のリクエストから動的にバッチを構成し、複数のリクエストを束ねて推論実行する機構です。有効化するためには、設定に dynamic_batching: {}という記述を追加する必要があります。このとき注意すべきポイントとして、max_batch_size が未指定のままだとリクエストごとに推論する動作は変わらない、というものがあります。</p><p>そこで通常は max_batch_size に 1 以上の値を指定し、dynamic batching が機能するように設定することが推奨されます。注意すべきは、dims の先頭にはバッチ次元を指定「しない」という点です。max_batch_size を指定すると、Triton 側では、最終的な推論時の入力テンソルの形状を [-1] + dims として扱います。そのため dims の先頭にバッチ サイズ相当の値が入っている場合、Triton は、余分な次元が一つ増えたテンソルが入力されると仮定して処理を進め、エラーとなります。たとえば先の例であれば、以下のように設定を変更することになります。</p><pre>max_batch_size: 32<br>...<br>input [{<br>...<br>    dims: [224, 224, 3]<br>...</pre><p>ほとんど最初の例と同じですが、max_batch_size の値だけが異なります。これにより、クライアントからは任意のサイズのバッチを送信できるようになります。なおこの場合も、モデルをエクスポートする際、可変バッチ サイズに対応するように指定しておく必要があります。(注: これもバックエンドによります)</p><p>さらに加えて dynamic_batching を指定することで、複数のリクエストをひとつに束ねて推論実行できるようになります。例えば以下のように設定を追加します。</p><pre>dynamic_batching: {}</pre><p>ただしこの場合デフォルトでは待ち時間が 0 のため、運良く近いタイミングで複数リクエストが同時にサーバーへ到着するか、推論の実行時間が長いことで多数のリクエストがキューに滞留しない限り、シーケンシャルに推論が実行されます。確実に複数のリクエストを一つのバッチに束ねるには、max_queue_delay_microseconds をほどよい値に設定することが重要となります。例えば以下のような値です。</p><pre>dynamic_batching: {<br>  # Wait for up to 10 msec.<br>  max_queue_delay_microseconds: 10000<br>}</pre><p>実際には <a href="https://github.com/triton-inference-server/server/blob/r22.06/docs/perf_analyzer.md">Performance Analyzer</a> や <a href="https://github.com/triton-inference-server/model_analyzer">Model Analyzer</a> などを利用して調整することが推奨されます。こうしたチューニングの指針は <a href="https://github.com/triton-inference-server/server/blob/r22.06/docs/model_configuration.md#recommended-configuration-process">Recommended Configuration Process</a> などを参照ください。また、実際に構成されたバッチ サイズを知りたい場合、起動時オプションの --log-verbose=1 を指定して出力されるログから拾う方法と、<a href="https://github.com/triton-inference-server/server/blob/r22.06/docs/metrics.md">metrics</a> を利用する方法があります。詳細は割愛しますが、”Inference Count (nv_inference_count)” と “Execution Count (nv_inference_exec_count)” を組み合わせることで、実際に実行された平均バッチ サイズを計算できます。</p><h3>preferred_batch_size を考慮する必要のある場合</h3><p>最後に preferred_batch_size です。前述した通り、TensorRT のように特定のバッチ サイズで特に強く最適化されてる、という場合に考慮する必要のあるパラメータです。基本的には max_batch_size に類似の設定とみなしてよく、例えば以下のように記述すると、バッチ サイズ 1 もしくは 2 で推論実行しようと試みます。</p><pre>dynamic_batching: {<br>  preferred_batch_size: [1, 2]<br>}</pre><p>なお、特に TensorRT を利用する場合、固定バッチ サイズを前提とするモデルでも問題なく動作する「ことがある」点には注意が必要です。preferred_batch_size を利用する場合に特に発生しやすくなると予想されますが、たとえばバッチ サイズ 2 を前提とするモデルに対して、preferred_batch_size: [1] を設定する状況を考えます。このとき、複数のクライアントからバッチ サイズ 1 でリクエストが送信されると、たまたま同時に 2 つ以上のリクエストが到着した場合には、バッチ サイズ 2 で推論実行されるため成功しますが、多くの場合バッチ サイズ 1 で推論実行が走ります。しかしながら、モデルが前提とするバッチ サイズと異なるため、サイズの不一致でエラーが発生してしまい、多数のリクエストが失敗することになります。</p><p>こうした点から、dynamic batching を利用する場合、モデルのエクスポート時に可変サイズに対応するよう設定することが推奨されます。一方で、あまりバッチ サイズを気にしなくてよいこともあります。それはどういう場合でしょうか。</p><h3>バックエンドごとの違い</h3><p>ここまでの内容で、モデル エクスポート時に可変バッチ サイズに対応するよう設定する必要のある条件として以下の条件があることがわかります。</p><ul><li>dims の先頭にバッチ サイズとして -1 を設定するケース</li><li>max_batch_size に 1 以上の値を設定するケース</li><li>preferred_batch_size を設定するケース</li></ul><p>いずれのパターンも、任意のサイズのバッチを扱う必要のある状況です。一方で、バックエンド、すなわちフレームワークによってはこの制限が緩和される場合があります。ここではモデル エクスポート時のバッチ サイズの扱いと、各種設定との関係を議論します。今回は対象とする主要なバックエンドとして、以下の 4 つを取り上げます。</p><ul><li>TensorFlow (ここでは SavedModel を対象とします)</li><li>PyTorch</li><li>ONNX Runtime</li><li>TensorRT</li></ul><p>はじめに、おおまかに状況を整理すると以下のようになります。なお、いずれも max_batch_size の指定は dims と整合している必要があります。(たとえば、max_batch_size を指定しない場合、dims の先頭が -1 にならなくてはダメ、など)</p><figure><img alt="各バックエンドとmax_batch_sizeおよびdimsの間の関係" src="https://cdn-images-1.medium.com/max/1024/0*tjTOrbCO9cxzYqmx" /></figure><p>上記の表からもわかる通り、SavedModel および ONNX が最も厳格です。バッチ サイズを固定したモデルに対して以下の設定を行う場合、モデル ロード自体に失敗します。</p><ul><li>dims の先頭に -1 を指定 (e.g., dims: [-1, 224, 224, 3])</li><li>dims の先頭がモデル エクスポート時のバッチ サイズと一致しない (e.g., バッチ サイズ 1 向けのモデルに対して、dims: [4, 224, 224, 3])</li><li>max_batch_size に 1 以上の値を指定</li></ul><p>したがってこれら 2 つのバックエンドを利用する場合、モデルの定義と設定の整合性には特に注意する必要があります。また冒頭で述べた、自動生成される設定を利用する場合、固定バッチ サイズのモデルではうまく dynamic batching が動作しない (=クライアント側でバッチ サイズを気にする必要が生じて嬉しくない) ためか、デフォルトで dynamic batching が有効化される動作は無効になります。</p><p>次に厳格なのが TensorRT です。SavedModel や ONNX と異なり、固定バッチ サイズのモデルでも dims の先頭要素に -1 を指定したり、max_batch_size に 1 以上の値を指定できる点があります。ただしこの場合も、クライアント側のリクエストのバッチ サイズは、モデルが想定しているバッチ サイズと一致する必要がある点や、max_batch_size はモデルのバッチ サイズと一致させる必要がある点に注意が必要です。また、dims の先頭を -1 にしてモデルを可変バッチ サイズに対応させる場合にも若干注意が必要です。TensorRT で可変バッチ サイズに対応するためには、<a href="https://docs.nvidia.com/deeplearning/tensorrt/developer-guide/index.html#work_dynamic_shapes">Dynamic Shapes</a> という機能を使用するのですが、これは一定範囲内のバッチ サイズに対応する機能のため、無制限に任意のサイズを与えることはできません。たとえば、対応可能な最小バッチ サイズを 1、最適化ターゲットを 16、最大バッチ サイズを 32、というように設定します。すると、この最大サイズとして設定された 32 を超える大きなバッチを与えようとするとエラーが発生してしまうため、注意が必要となります。</p><p>最後に最も寛容なのが PyTorch で、厳密には TorchScript を利用する場合、最も制限が緩くなります。モデル エクスポートにどういった example_inputs を指定したかによらず、dims の先頭に任意のサイズを指定可能ですし、max_batch_size も任意の値を指定可能です。もちろん、dims の先頭に 1 以上の値を指定した場合はクライアント側のバッチ サイズもそれに限定されますが、それ以外の場合は基本的に任意のサイズのバッチを利用可能です。</p><h3>まとめ</h3><p>Triton Inference Server における、バッチ サイズの扱いについて細かく見てきました。設定可能な項目が多いことで混乱しやすい点ではありますが、モデルをエクスポートする際の設定と、max_batch_size をどう指定するかがひとつのカギになるかと思います。典型的な用途のためには、max_batch_size に想定する最大サイズを設定し、dims にはバッチ次元を除いたテンソル形状を指定、さらに dynamic_batching: {} を設定すれば OK です。もし設定自体を考えるのが大変という場合は、Triton の起動時オプションである --strict-model-config=false をご活用ください。本記事が、今後の Triton 活用の助けになれば幸いです。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=241eda69fece" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/triton-inference-server-batchsize-demystified-ja-241eda69fece">Triton Inference Server のバッチ サイズを紐解く</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Triton Inference Server 2022 年 1 月のリリース概要]]></title>
            <link>https://medium.com/nvidiajapan/triton-inference-server-jan-2022-release-overview-f2f6cb862d73?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/f2f6cb862d73</guid>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[deep-learning]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Thu, 17 Mar 2022 05:36:17 GMT</pubDate>
            <atom:updated>2022-03-17T05:36:17.116Z</atom:updated>
            <content:encoded><![CDATA[<p>みなさまこんにちは。NVIDIA の山崎です。毎月恒例 Triton Inference Server のリリース内容について、概要をお届けします。例によって、そもそも「Triton Inference Server って何?」という方は、以下の記事などをご確認ください。</p><ul><li><a href="https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2">GPU に推論を: Triton Inference Server でかんたんデプロイ</a></li><li><a href="https://medium.com/nvidiajapan/nvidia-triton-inference-server-on-jetson-da4279ff9544">NVIDIA Triton Inference Server を使用したエッジでの AI モデルの展開の簡素化</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*hceyK3rQQxXEtluY" /></figure><h3>What’s New in 2.18.0 (NGC 22.01)</h3><p>リリースノート本体は <a href="https://github.com/triton-inference-server/server/releases/tag/v2.18.0">https://github.com/triton-inference-server/server/releases/tag/v2.18.0</a> です。1 月のリリースには以下の機能や改善などが含まれています。</p><ul><li><a href="https://github.com/triton-inference-server/server/blob/v2.18.0/docs/build.md#cpu-only-container">CPU-only コンテナーのビルド</a>が、TensorFlow2 に対応しました</li><li>ONNX Runtime バックエンドと TensorRT バックエンドで、<a href="https://github.com/triton-inference-server/server/blob/v2.18.0/docs/architecture.md#implicit-state-management">正式に暗黙の状態管理が利用可能に</a>なりました</li><li>暗黙の状態管理で、<a href="https://github.com/triton-inference-server/server/blob/v2.18.0/docs/architecture.md#state-initialization">初期状態として利用する定数を指定可能</a>になりました</li><li>PyTorch および TensorFlow バックエンドが、AWS Inferentia でのバッチ実行に対応しました</li><li>Jetson 上で、PyTorch および Python バックエンドが利用可能になりました</li><li><a href="https://github.com/triton-inference-server/server/blob/v2.18.0/docs/perf_analyzer.md">Performance Analyzer</a> と <a href="https://github.com/triton-inference-server/model_analyzer">Model Analyzer</a> が、ARM に対応しました</li></ul><p>今回は比較的小粒なアップデートです。</p><p>暗黙の状態管理については、<a href="https://medium.com/nvidiajapan/triton-inference-server-nov-2021-release-overview-e346752b75b0">2021 年 11 月のリリース概要</a>でも少し触れていましたが、シーケンス データの処理を行う際に必要となる、中間状態の管理を Triton 内部で行ってくれるという機能になります。以前の記事でも書いた通り、これまでもある程度は中間状態を制御してくれていたのですが、より使いやすくなった、という位置づけです。またあわせて、初期状態はユーザー側での指定が可能になっていますので、暗黙に管理されるとは言っても、ある程度の制御はできるようです。</p><h3>What’s New に言及されていないアップデート</h3><p>そのほか、以下の内容が公開されています。</p><ul><li><a href="https://github.com/triton-inference-server/common/blob/b1ef9c176d4f7c72d11d612a9fbc27f64a7f864f/protobuf/model_config.proto#L402-L408">Optional な入力</a>が実験的に導入され始めたようです</li><li><a href="https://github.com/triton-inference-server/server/blob/v2.18.0/docs/protocol/extension_statistics.md">統計情報 API</a> で、キャッシュを考慮するかが明示され、キャッシュ関連の統計値も取れるようになったようです</li></ul><p>Optional な入力は、入力テンソルを選択的に送信する (or しない) ことができるようにする機能のようです。ただし、現時点では対応バックエンドがないため、将来的に利用可能になる可能性がある、という段階です。(正確には、identity backend のみ実装済みです)</p><p>統計情報 API のキャッシュ対応は、既存の統計値の中で、推論リクエストの success 数や queue での待ち時間などだけが、キャッシュ関連の数字を合計したものに変更される、ということのようです。</p><p>また今回のリリースについては、特に NGC のコンテナで CUDA が 11.6 に更新されたため、ドライバーの更新が必要になるケースがある点にご注意ください。詳細は <a href="https://docs.nvidia.com/deeplearning/triton-inference-server/release-notes/rel_22-01.html#rel_22-01">Triton Inference Server Release 22.01</a> の “Driver Requirements” に、</p><blockquote>Release 22.01 is based on NVIDIA CUDA 11.6.0, which requires NVIDIA Driver release 510 or later. However, if you are running on a Data Center GPU (for example, T4 or any other Tesla board), you may use NVIDIA driver release 418.40 (or later R418), 440.33 (or later R440), 450.51 (or later R450), 460.27 (or later R460), or 470.57 (or later R470).</blockquote><p>と記載されている通り、</p><ul><li>原則として、バージョン 510 以降が必要 (注. 環境によっては、以下の互換性パッケージで動作することもあります)</li><li>ただし、データセンター向け GPU については、418.40 (またはそれ以降の R418)、440.33 (またはそれ以降の R440)、450.51 (またはそれ以降の R450)、460.27 (またはそれ以降の R460) および 470.57 (またはそれ以降の R470) であれば、互換性パッケージなどにより動作</li></ul><p>という状況です。互換性関連の詳細は、<a href="https://docs.nvidia.com/deploy/cuda-compatibility/index.html#cuda-application-compatibility">CUDA Application Compatibility</a> や <a href="https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#cuda-compatibility-and-upgrades">CUDA Compatibility and Upgrades</a>、<a href="https://docs.nvidia.com/datacenter/tesla/cuda-drivers-support/index.html#introduction">NVIDIA CUDA and Drivers Support</a> をご確認ください。</p><h3>まとめ</h3><p>今月は、機能追加としては大きなものがありませんでしたが、NGC のコンテナー イメージの CUDA バージョンが上がっているので、実行環境との整合性を気にしていただかなくてはならない点が大きな変更だったでしょうか。3 月末には <a href="https://www.nvidia.com/ja-jp/gtc/?ncid=GTC-NVKYAMASAKI">GTC</a> も予定されていますので、来月以降、また大型のアップデートが走りそうな予感がします。最新状況が気になる方は、ぜひ GTC にもご参加ください。</p><p>その他、疑問点や問題点がある場合、随時コメントなどいただければ幸いです！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f2f6cb862d73" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/triton-inference-server-jan-2022-release-overview-f2f6cb862d73">Triton Inference Server 2022 年 1 月のリリース概要</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Triton Inference Server 2021 年 12 月のリリース概要]]></title>
            <link>https://medium.com/nvidiajapan/triton-inference-server-dec-2021-release-overview-e59010fedb2f?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e59010fedb2f</guid>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[gpu]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Thu, 27 Jan 2022 04:17:43 GMT</pubDate>
            <atom:updated>2022-03-29T23:31:33.361Z</atom:updated>
            <content:encoded><![CDATA[<p>あけましておめでとうございます。NVIDIA の山崎です。今年も早速、毎月恒例となってきました Triton Inference Server のリリース内容について、概要をお届けします。例によって、そもそも「Triton Inference Server って何?」という方は、以下の記事などをご確認ください。</p><ul><li><a href="https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2">GPU に推論を: Triton Inference Server でかんたんデプロイ</a></li><li><a href="https://medium.com/nvidiajapan/nvidia-triton-inference-server-on-jetson-da4279ff9544">NVIDIA Triton Inference Server を使用したエッジでの AI モデルの展開の簡素化</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*iW9SlgTClq9dmAky" /></figure><h3>What’s New in 2.17.0 (NGC 21.12)</h3><p>リリース ノート本体は <a href="https://github.com/triton-inference-server/server/releases/tag/v2.17.0">https://github.com/triton-inference-server/server/releases/tag/v2.17.0</a> です。今月のリリースには以下の機能や改善などが含まれています。</p><ul><li><a href="https://github.com/triton-inference-server/server/blob/v2.17.0/deploy/mlflow-triton-plugin">MLflow plugin</a> による、MLflow との連携強化</li><li>TorchTRT サポートのプレビュー リリース</li><li><a href="https://github.com/triton-inference-server/python_backend/tree/r21.12/inferentia#readme">AWS Inferentia サポート</a>の改善</li><li>Model Analyzer 実行時メッセージの改善</li><li>ONNX Runtime バックエンドのバージョン更新 (1.10.0 に)</li></ul><p>今月の目玉は、なんといっても MLflow まわりの連携強化でしょうか。</p><p>MLflow は、多くの方がご存じの通り、機械学習を利用するアプリケーションのデプロイや実験管理などに広く用いられているツールです。当然、デプロイ用のツールということで Triton と連携させたくなるのですが、残念ながらこれまで、うまく連携させられない状況が続いていました。今回のリリースでは、<a href="https://www.mlflow.org/docs/latest/plugins.html">MLflow の plugin 機能</a>を利用して MLflow のコマンド経由で Triton による推論を実行できるようになりました。(もちろん、モデルのデプロイなども対象です)</p><p>具体的な手順は<a href="https://github.com/triton-inference-server/server/tree/v2.17.0/deploy/mlflow-triton-plugin">ドキュメント</a>を参照いただければと思いますが、Triton のサーバー プロセスを別に起動しておく必要がある点を除けば、比較的簡単に利用できるようになっているようです。</p><p>一方、まだリリースしたばかりということで、いくつか気を付けていただくポイントが残っています。</p><ul><li>MLflow 自体が先日更新されたことに伴い、Triton プラグインがうまく動作しないケースがあるようです。MLFlow 起因であることが疑われるエラーの発生時には、<a href="https://github.com/triton-inference-server/server/tree/v2.17.0/deploy/mlflow-triton-plugin#installation">プラグインのインストール</a>後、 pip install mlflow==1.22.0 などでバージョンを 1.22.0 に戻すとうまくいく場合があります。</li><li>ドキュメントには明記されていませんが、モデルを MLFlow へ publish する際、環境変数 MLFLOW_TRACKING_URI を設定する前提となっています。このとき、ローカル ストレージを指定すると未サポートである旨を示すエラーが発生するため、例えば export MLFLOW_TRACKING_URI=sqlite:////opt/mlruns.db のように SQLite などを指定する必要があります。</li><li>同様にモデルの publish 時、 publish_model_to_mlflow.py に渡す引数 --model_directory は、末尾にスラッシュが入っているとうまく動作しないようです (おそらくバグ)。そのため、ディレクトリを指定する場合でも、末尾にスラッシュをつけないようご注意ください。</li><li>このプラグインが Triton とやり取りするための環境変数である TRITON_URL および TRITON_MODEL_REPO についても、それぞれ以下の点にご注意ください。<br>1. TRITON_URL に URL スキームを入れるとうまく動かない (これもおそらくバグ) ので、たとえば localhost:8000 のように記述<br>2. TRITON_MODEL_REPO には、Triton のサーバー プロセスが --model-repository で参照する先を指定 (= プラグインは TRITON_MODEL_REPO に対してモデル ファイルをコピーしたりアップロードしたりするので、Triton から見える場所ならローカル ストレージでも、Amazon S3 でもなんでも大丈夫なはずです)</li></ul><p>TorchTRT サポートについては、「そもそもそれなあに?」という方が多いかもしれません。TorchTRT 自体については “<a href="https://medium.com/nvidiajapan/torch-tensorrt-japanese-20648d64d62">Torch-TensorRT を使用して GPU 上の PyTorch の推論性能を向上する</a>” に概要が書かれていますが、PyTorch の世界のまま TensorRT による最適化を適用できる機構です。この最適化後のモデルを、Triton でも通常の TorchScript と同じように利用できるようになる、というのが今回のリリースに含まれている、ということになります。これにより、PyTorch のモデルを簡単に、より高速に実行できるようになります。</p><h3>What’s New に言及されていないアップデート</h3><p>そのほか、以下の内容がすでに公開されています。</p><ul><li>Ragged Batching に関する<a href="https://github.com/triton-inference-server/server/blob/v2.17.0/docs/ragged_batching.md">ドキュメント</a>追加</li><li><a href="https://www.nvidia.com/ja-jp/data-center/products/fleet-command/">Fleet Command</a> 向け <a href="https://github.com/triton-inference-server/server/tree/v2.17.0/deploy/fleetcommand">Helm Chart のサンプル</a>追加</li></ul><p>Ragged Batching という機能自体は、以前から Triton で実装済みであったり、TensorFlow や PyTorch にも類似の概念があるため馴染みのある方もいらっしゃるかもしれません。要は、異なる形状のテンソルをまとめて扱えるようにする、というものです。わかりやすい用途としては、文字列などで入力が可変長になるケースです。</p><p>Triton では Dynamic Batching を有効にすることで、細切れのリクエストを一つにまとめて実行できるようになります。一方で、前述のような形状の違うデータが同時に来た場合、一つのバッチにはまとめられず、別々に実行されることになります。これにより、実行効率の低下などが発生する可能性があるのですが、Ragged Batching を利用することで、解消できる場合があります。詳細は<a href="https://github.com/triton-inference-server/server/blob/v2.17.0/docs/ragged_batching.md">ドキュメント</a>を参照していただければと思いますが、 config.pbtxt の input に allow_ragged_batch: true を指定するのと、 batch_input という新しい設定を追加すれば OK のようです。(もちろん、モデル側が対応していることも必要ですが……)</p><h3>まとめ</h3><p>今月は比較的大きめのアップデートが走っていました。デプロイが大変そうで利用をためらっていた、という方は、ぜひこの機会にお試しいただければと思います。またドキュメント等の整備も順次進行していますので、使い方がよくわからず断念していた機能などがある場合、定期的にチェックしていただければ！</p><p>その他、疑問点や問題点がある場合、随時コメントなどいただければ幸いです！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e59010fedb2f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/triton-inference-server-dec-2021-release-overview-e59010fedb2f">Triton Inference Server 2021 年 12 月のリリース概要</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Triton Inference Server 2021 年 11 月のリリース概要]]></title>
            <link>https://medium.com/nvidiajapan/triton-inference-server-nov-2021-release-overview-e346752b75b0?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/e346752b75b0</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[nvidia]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Thu, 27 Jan 2022 04:16:56 GMT</pubDate>
            <atom:updated>2022-03-29T23:32:23.022Z</atom:updated>
            <content:encoded><![CDATA[<p>みなさま、こんにちは。NVIDIA の山崎です。毎月恒例となってきました、Triton Inference Server のリリース内容について、共有させてください。例によって、そもそも「Triton Inference Server って何?」という方は、以下の記事などをご確認ください。</p><ul><li><a href="https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2">GPU に推論を: Triton Inference Server でかんたんデプロイ</a></li><li><a href="https://medium.com/nvidiajapan/nvidia-triton-inference-server-on-jetson-da4279ff9544">NVIDIA Triton Inference Server を使用したエッジでの AI モデルの展開の簡素化</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*g0URQVdPtW1o9aax" /></figure><h3>What’s New in 2.16.0 (NGC 21.11)</h3><p>リリース ノート本体は <a href="https://github.com/triton-inference-server/server/releases/tag/v2.16.0">https://github.com/triton-inference-server/server/releases/tag/v2.16.0</a> です。今月のリリースには以下の機能や改善などが含まれています。</p><ul><li>FIL (Forest Inference Library) backend で、 categorical feature がサポートされるようになりました (<a href="https://github.com/triton-inference-server/fil_backend/tree/r21.11#categorical-feature-support">https://github.com/triton-inference-server/fil_backend/tree/r21.11#categorical-feature-support</a>)</li><li>Jetson 向けのサンプルが追加されました (<a href="https://github.com/triton-inference-server/server/tree/v2.16.0/docs/examples/jetson">https://github.com/triton-inference-server/server/tree/v2.16.0/docs/examples/jetson</a>)</li><li>Inferentia サポートの PoC が完了しました (<a href="https://github.com/triton-inference-server/python_backend/tree/r21.11/inferentia#readme">https://github.com/triton-inference-server/python_backend/tree/r21.11/inferentia#readme</a>)</li><li>ARM CPU でも Model analyzer が利用可能になりました</li></ul><p>今月は小粒なアップデートという感じですが、<a href="https://github.com/triton-inference-server/server/blob/v2.16.0/docs/examples/jetson">Jetson 向けのサンプル</a>では、Jetson 上で Triton Inference Server をみなさんのアプリケーションに「組み込んで」使う方法が記述されていますし、AWS ユーザの方は Inferentia サポートに興味をお持ちいただけるかもしれません。なお今回のリリースで検証された Inferentia サポートは、Python バックエンドを用いて実施されています。</p><h3>What’s New に言及されていないアップデート</h3><p>今月は 2 つの小規模アップデートです。</p><ul><li>Vertex AI との連携に向けた機能が追加されました</li><li><a href="https://github.com/triton-inference-server/server/blob/v2.16.0/docs/model_configuration.md#sequence-batcher">Sequence batcher</a> 利用時に、中間状態の管理が暗黙的に行えるようになりました</li></ul><p>すでに Amazon SageMaker とは連携可能になっているのですが (参考: <a href="https://aws.amazon.com/jp/blogs/machine-learning/deploy-fast-and-scalable-ai-with-nvidia-triton-inference-server-in-amazon-sagemaker/">Deploy fast and scalable AI with NVIDIA Triton Inference Server in Amazon SageMaker — AWS Machine Learning Blog</a>) 、今回のリリースには Vertex AI との連携を見据えたものと思われる対応 (<a href="https://github.com/triton-inference-server/server/commit/ab2d0990c8e8e33cc08e096102d946769e60980a">Add Vertex AI endpoint (#3466)</a>) が含まれています。まだドキュメントなどに明記されていないため変更の可能性はありますが、より多くの環境で Triton を利用できるようになることが想定されます。</p><p>後者のアップデートは、たとえば音声認識のような、ストリーム的にデータが逐次与えられる状況で、中間状態 (例: RNN における隠れ状態など) を管理する必要がある場合に便利な機能です。これまでは、モデル側で中間状態を明示的に管理する必要があり、若干煩雑でした。今回のアップデートにより、中間状態を示すテンソルと、その入出力に関する対応関係を設定に記述しておくと、Triton Inference Server が中間状態を暗黙的に管理してくれるようになります。結果、系列データの推論を行う際、直前の要素から出力された中間状態が、次の要素の計算時に入力として扱われるようになります。詳細は、<a href="https://github.com/triton-inference-server/common/blob/main/protobuf/model_config.proto">model_config.proto</a> の <a href="https://github.com/triton-inference-server/common/blob/17a4f658ecc74f389d8cf84e2075a04583799396/protobuf/model_config.proto#L1266-L1295">message State</a> や <a href="https://github.com/triton-inference-server/common/blob/17a4f658ecc74f389d8cf84e2075a04583799396/protobuf/model_config.proto#L1412-L1422">repeated State state = 5;</a> などをご確認ください。なお、現時点では一部のバックエンドでのみサポートされているようで、確認した範囲では ONNX では動作するものの、Python バックエンドでは動作しないようです。また、こちらもドキュメントに明記されていないため、将来的に変更される可能性がある点、ご注意ください。</p><h3>まとめ</h3><p>今月の更新は比較的小規模でしたが、利用可能な環境を増やすための対応や、ユーザビリティを上げるための改善などが含まれていました。引き続き、様々な環境、様々なモデルの推論を、より簡単に、より高速に実行できるようにするための取り組みが行われます。皆様のアプリケーションをデプロイする環境としてご検討いただければ幸いです。</p><p>ご意見ご質問など、お気軽にコメントいただければと思います！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e346752b75b0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/triton-inference-server-nov-2021-release-overview-e346752b75b0">Triton Inference Server 2021 年 11 月のリリース概要</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Triton Inference Server FIL バックエンドによる tree-based アルゴリズムのデプロイ — 入門編 -]]></title>
            <link>https://medium.com/nvidiajapan/intro-to-fil-backend-and-tree-model-deployment-on-triton-inference-server-5a84a41f0b92?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/5a84a41f0b92</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Thu, 18 Nov 2021 03:48:12 GMT</pubDate>
            <atom:updated>2021-11-18T03:52:51.805Z</atom:updated>
            <content:encoded><![CDATA[<h3>Triton Inference Server FIL バックエンドによる tree-based アルゴリズムのデプロイ - 入門編 -</h3><p>みなさま、こんにちは。NVIDIA の山崎です。さて、先日開催された GTC ではキーノートにて、NVIDIA CEO の Jensen Huang から様々なアップデートが発表されました。その中で「ディープラーニング以外の、(一部の) 機械学習手法も GPU で高速推論できるようにしていく」という言及があったことにお気づきの方はいらっしゃるでしょうか。この記事では、そうしたディープラーニング「ではない」手法を Triton Inference Server にデプロイする方法のうち、tree-based なアルゴリズムを高速化する <a href="https://github.com/triton-inference-server/fil_backend">FIL (Forest Inference Library) バックエンド</a>について解説します。なお、「入門編」と銘打っていますが、以降の記事が執筆されるかどうかは、アクセス数などで決まりますのでよろしくお願いいたします。</p><p>例によって、そもそも「Triton Inference Server って何?」という方は、日本語では以下の記事をご確認ください。</p><ul><li><a href="https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2">GPU に推論を: Triton Inference Server でかんたんデプロイ</a></li><li><a href="https://medium.com/nvidiajapan/nvidia-triton-inference-server-on-jetson-da4279ff9544">NVIDIA Triton Inference Server を使用したエッジでの AI モデルの展開の簡素化</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*vXo9bRmLKGcsMhy9" /></figure><h3>FIL (Forest Inference Library) とは?</h3><p><a href="https://github.com/rapidsai/cuml/tree/branch-21.12/python/cuml/fil">FIL (Forest Inference Library)</a> は、RAPIDS cuML の内部に導入された、軽量かつフレキシブルな tree-based アルゴリズム向けの GPU 推論ライブラリです。Random Forest や XGBoost、あるいは LightGBM など、メジャーなアルゴリズムやライブラリをサポートしており、特にバッチ的に推論を実行する際に高速な動作をする点が特徴です。そのほか、モデルのパーサーとして <a href="https://github.com/dmlc/treelite">Treelite</a> をサポートしており、scikit-learn や cuML で学習して保存した pickle ファイルを Treelite バイナリ フォーマットに変換すれば、統一された API で扱える点も大きな特徴です。なお、XGBoost や LightGBM については、それぞれ独自フォーマットが存在していますが、FIL ではこれらもサポートしています。</p><p>細かな情報やさらなる詳細は <a href="https://medium.com/rapids-ai/rapids-forest-inference-library-prediction-at-100-million-rows-per-second-19558890bc35">RAPIDS Forest Inference Library: Prediction at 100 million rows per second</a> や <a href="https://developer.nvidia.com/blog/sparse-forests-with-fil/">Sparse Forests with FIL</a> などもご覧いただければと思いますが、一例として、<a href="https://github.com/rapidsai/cuml/tree/branch-21.12/python/cuml/fil#benchmarks-and-performance-notes">Benchmarks and performance notes — rapidsai/cuml</a> には、以下のようなベンチマークの結果が掲載されています。一定程度の規模で、FIL が高速に動作することを確認いただけるかと思います。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*5_J1Dxx7vKm4E7JZ" /></figure><p>一方、前述の通りバッチで処理する際に最高の性能を達成するという点で、FIL を単体でデプロイしようとすると、どうしてもシーケンシャル アクセス的な実装になってしまい、性能面でのアドバンテージを得られにくくなるという現実があるかと思います。</p><p>こうした背景のもと、Triton Inference Server で FIL を利用できるよう、バックエンドが開発されています。</p><h3>FIL バックエンドを使ってモデルをデプロイするために</h3><p>ご存じの通り、Triton Inference Server には<a href="https://github.com/triton-inference-server/server/blob/main/docs/architecture.md#models-and-schedulers">リクエスト キューなどのスケジューリング機構</a>が存在しており、<a href="https://github.com/triton-inference-server/server/blob/main/docs/model_configuration.md#dynamic-batcher">dynamic batcher</a> などと組み合わせることによって、前述したような「FIL をバッチ的に利用する」という実装が容易になります。基本的なモデル デプロイの流れは、ディープラーニングの各フレームワークを利用する場合と同様、既定のディレクトリ構造に従って、設定ファイル (config.pbtxt) と、一定のフォーマットに従ったバイナリ ファイルを配置すれば OK というものです。FIL バックエンドの場合は、前述の通り、</p><ul><li>Treelite バイナリ フォーマット</li><li>XGBoost 独自形式</li><li>LightGBM 独自形式</li></ul><p>がサポートされています。</p><p>さて、後者 2 つの XGBoost と LightGBM は、モデル保存の方法に関する疑問は特にないかと思います。一方、最初の Treelite については馴染みがない方も多いのではないでしょうか。Treelite バイナリ フォーマットに変換する必要があるのは、scikit-learn や cuML を直接利用してモデルを pickle 形式に保存した場合です。基本的には FIL バックエンドのリポジトリに、ユーティリティとしてモデル変換用のスクリプト (scikit-learn: <a href="https://github.com/triton-inference-server/fil_backend/blob/main/scripts/convert_sklearn">fil_backend/scripts/convert_sklearn</a>, cuML: <a href="https://github.com/triton-inference-server/fil_backend/blob/main/scripts/convert_cuml.py">fil_backend/scripts/convert_cuml.py</a>) が準備されていますので、これを利用するのが一番簡単だと思います。また cuML の場合は、直接変換する API (e.g., <a href="https://docs.rapids.ai/api/cuml/stable/api.html#cuml.ensemble.RandomForestClassifier.convert_to_treelite_model">RandomForestClassifier.convert_to_treelite_model()</a>) が存在するため、ユーザー側で明示的に実行して保存する、というやり方もあります。いずれかの手段で、FIL バックエンドがサポートする形式のモデル ファイルを準備することが必要です。<br>(注1: Triton Inference Server の NGC コンテナー イメージを利用する場合、同梱されている Treelite のバージョンと同じバージョンの Treelite で変換する必要があります。)<br>(注2: cuML については、cuML 環境に入っている Treelite のバージョンを手動で変更してモデルの保存や変換を行うと、Triton 側にモデルを移動させた際にバージョン不整合のエラーが出ることがあります。cuML のインストール時に、バージョンが揃っていることを確認してください。)</p><p>続いて、設定ファイルを作成します。基本的な項目は、そのほかのディープラーニング フレームワークを利用する場合と同様なのですが、大きな違いとして parameters の記述が必要な点が挙げられます。</p><p><a href="https://github.com/triton-inference-server/fil_backend#configuration">triton-inference-server/fil_backend#configuration</a> には一例として、以下のような設定例が記載されています。以下の設定の前には backend:&quot;fil&quot; が指定され、バックエンドが FIL であることはあらかじめ与えられているのですが、それに加え、配置されているバイナリ ファイルがどのライブラリや形式か (=model_type)、出力をスコアで出すか (=predict_proba) など、ライブラリの動作を規定する設定が可能になっています。</p><pre>parameters [<br>  {<br>    key: &quot;model_type&quot;<br>    value: { string_value: &quot;xgboost&quot; }<br>  },<br>  {<br>    key: &quot;predict_proba&quot;<br>    value: { string_value: &quot;true&quot; }<br>  },<br>  {<br>    key: &quot;output_class&quot;<br>    value: { string_value: &quot;true&quot; }<br>  },<br>  {<br>    key: &quot;threshold&quot;<br>    value: { string_value: &quot;0.5&quot; }<br>  },<br>  {<br>    key: &quot;algo&quot;<br>    value: { string_value: &quot;ALGO_AUTO&quot; }<br>  },<br>  {<br>    key: &quot;storage_type&quot;<br>    value: { string_value: &quot;AUTO&quot; }<br>  },<br>  {<br>    key: &quot;blocks_per_sm&quot;<br>    value: { string_value: &quot;0&quot; }<br>  },<br>  {<br>    key: &quot;threads_per_tree&quot;<br>    value: { string_value: &quot;1&quot; }<br>  },<br>  {<br>    key: &quot;transfer_threshold&quot;<br>    value: { string_value: &quot;0&quot; }<br>  }<br>]</pre><p>とはいえ、基本的な設定はここまでで完了で、あとはいつも通り実行すれば OK です。</p><h3>実際に動かしてみる</h3><p>FIL バックエンドを利用する場合も、Triton Inference Server の起動コマンドは通常通りで大丈夫です。例えば以下の通り。</p><pre>docker run \<br>  --gpus=all \<br>  --rm \<br>  -p 8000:8000 \<br>  -p 8001:8001 \<br>  -p 8002:8002 \<br>  -v $PATH_TO_MODEL_REPO_DIR:/models \<br>  nvcr.io/nvidia/tritonserver:21.10-py3 \<br>  tritonserver \<br>  --model-repository=/models</pre><p>クライアント側の実装も、ディープラーニング フレームワークを利用する場合と全く同一で、例えば以下のようになります。</p><pre>import numpy as np<br>import tritonclient.http as triton_http</pre><pre># HTTP クライアントを準備<br>http_client = triton_http.InferenceServerClient(<br>    url=args.url, verbose=False, concurrency=12<br>)</pre><pre># サンプルデータを生成<br>features = 4<br>samples = 8_192<br>data = np.random.rand(samples, features).astype(&quot;float32&quot;)</pre><pre># Triton の入出力オブジェクトを生成<br>triton_input_http = triton_http.InferInput(<br>    &quot;input__0&quot;, (samples, features), &quot;FP32&quot;<br>)<br>triton_input_http.set_data_from_numpy(data, binary_data=True)<br>triton_output_http = triton_http.InferRequestedOutput(<br>    &quot;output__0&quot;, binary_data=True<br>)</pre><pre># 推論リクエストを送信<br>response_for_cpu = http_client.infer(<br>    cpu_modelname,<br>    model_version=&quot;1&quot;,<br>    inputs=[triton_input_http],<br>    outputs=[triton_output_http],<br>)<br>response_for_gpu = http_client.infer(<br>    gpu_modelname,<br>    model_version=&quot;1&quot;,<br>    inputs=[triton_input_http],<br>    outputs=[triton_output_http],<br>)</pre><pre># 結果を numpy array で取得<br>result_cpu = response_for_cpu.as_numpy(&quot;output__0&quot;)<br>result_gpu = response_for_gpu.as_numpy(&quot;output__0&quot;)</pre><pre># CPU と GPU で (ほぼ) 同じ結果になるか確認<br>np.testing.assert_almost_equal(result_cpu, result_gpu, decimal=decimal)<br>totaldiff = np.sum(np.abs(result_cpu - result_gpu))<br>print(result_cpu[:10])<br>print(result_gpu[:10])<br>print(f&quot;total difference = {totaldiff}&quot;)</pre><p>これを実際に動かしてみると以下のようになります。</p><pre>python client.py --url ${YOUR_TRITON_IP}:8000 --cpu-modelname cuml_cpu_rfc --gpu-modelname cuml_rfc --comparison-decimal 7<br>[[0.14999998 0.85      ]<br> [0.02499998 0.975     ]<br> [0.35000002 0.65      ]<br> [0.125      0.875     ]<br> [0.07499999 0.925     ]<br> [0.14999998 0.85      ]<br> [0.17500001 0.825     ]<br> [0.375      0.625     ]<br> [0.17500001 0.825     ]<br> [0.27499998 0.725     ]]<br>[[0.14999998 0.85      ]<br> [0.02499998 0.975     ]<br> [0.34999996 0.65000004]<br> [0.125      0.875     ]<br> [0.07499999 0.925     ]<br> [0.14999998 0.85      ]<br> [0.17500001 0.825     ]<br> [0.375      0.625     ]<br> [0.17500001 0.825     ]<br> [0.27499998 0.725     ]]<br>total difference = 0.0001093149185180664</pre><p>このとき、 cuml_rfc は cuML の RandomForestClassifier を素直に Treelite で変換したモデルをデプロイしたもので、 cuml_cpu_rfc は cuml_rfc の設定ファイルの中で instance_group の kind を KIND_GPU から KIND_CPU に変更したものです。それ以外は同一で、デプロイしているモデル自体も同じものです。これはつまり、設定ファイルを一行変えるだけで、デバイス切り替えができている、ということになります。</p><h3>まとめ</h3><p>この記事では、tree-based アルゴリズムを高速に GPU 上で実行するための機構としての FIL と、リクエストを集約して効率的に実行するための Triton Inference Server FIL バックエンドについて紹介しました。既存のモデルにユーティリティ スクリプトを適用し、設定ファイルを書けば、GPU による高速化の恩恵を受けることができるようになります。</p><p>もう一押し実行を高速化したいけど手間をかけたくない、という方には、新しい選択肢になる機能ではないでしょうか。もし興味をお持ちいただけましたら、ぜひ一度お試しください。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5a84a41f0b92" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/intro-to-fil-backend-and-tree-model-deployment-on-triton-inference-server-5a84a41f0b92">Triton Inference Server FIL バックエンドによる tree-based アルゴリズムのデプロイ — 入門編 -</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Triton Inference Server 2021 年 10 月のリリース概要]]></title>
            <link>https://medium.com/nvidiajapan/triton-inference-server-oct-2021-release-overview-833e69d40453?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/833e69d40453</guid>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Tue, 16 Nov 2021 04:09:10 GMT</pubDate>
            <atom:updated>2021-11-16T04:09:10.319Z</atom:updated>
            <content:encoded><![CDATA[<p>みなさまこんにちは。NVIDIA の山崎です。先日の GTC ではキーノートなど、ご覧いただけましたでしょうか? まだだよ、という方は、ぜひこの機会にご覧いただければ幸いです (YouTube にレコーディングが残っています: <a href="https://www.nvidia.com/gtc/keynote/">https://www.nvidia.com/gtc/keynote/</a>)。さて今日は毎月恒例 (にしたい) Triton Inference Server のリリース内容について、共有させてください。例によって、そもそも「Triton Inference Server って何?」という方は、日本語では以下の記事をご確認ください。</p><ul><li><a href="https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2">GPU に推論を: Triton Inference Server でかんたんデプロイ</a></li><li><a href="https://medium.com/nvidiajapan/nvidia-triton-inference-server-on-jetson-da4279ff9544">NVIDIA Triton Inference Server を使用したエッジでの AI モデルの展開の簡素化</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*BENUltWhJ8zR_RuZ" /></figure><h3>What’s New in 2.15.0 (NGC 21.10)</h3><p>リリース ノート本体は <a href="https://github.com/triton-inference-server/server/releases/tag/v2.15.0">https://github.com/triton-inference-server/server/releases/tag/v2.15.0</a> です。今月のリリースには以下の機能や改善などが含まれています。</p><ul><li><a href="https://github.com/triton-inference-server/server/blob/v2.15.0/docs/rate_limiter.md">Rate limiter</a> が利用可能になりました</li><li>サーバ サイドのアーキテクチャである ARM SBSA 向け対応がベータ リリースされました</li><li>Windows 向けビルドに HTTP サポートが含まれるようになりました</li><li>推論リクエストのキャッシュが (ベータ) サポートされました</li><li><a href="https://github.com/triton-inference-server/server/blob/v2.15.0/docs/protocol/extension_sequence.md">シーケンス ID に文字列が使える</a>ようになりました</li><li>Container composer tool が <a href="https://github.com/triton-inference-server/server/blob/v2.15.0/docs/compose.md#cpu-only-container-composition">CPU-only コンテナーの作成をサポート</a>しました (注: いろいろ制約があります……)</li></ul><p>上記の中で気になるものをピックアップしてみます。</p><h3>「Rate limiter が利用可能に」</h3><p>Rate limiter はその名の通り、モデル インスタンスへのリクエスト レートを調整する機能です。同様の機構として、dynamic batcher には <a href="https://github.com/triton-inference-server/server/blob/v2.15.0/docs/model_configuration.md#priority-levels">priority_level</a> を指定できます。こちらは、ある 1 つのモデルに対して送信されるリクエストの中で優先度をどのように決定するか、に使われます。これに対して rate limiter は、複数のモデルにまたがって優先度が調整されます。</p><p>詳細は <a href="https://github.com/triton-inference-server/server/blob/v2.15.0/docs/rate_limiter.md">Rate Limiter</a> をご確認いただければと思いますが、rate limiter を利用するためには、tritonserver 起動時に--rate-limit オプションを指定する必要があることと、config.pbtxt の instance_group.rate_limiter を設定する必要がある点、ご注意ください。</p><h3>「推論リクエストのキャッシュ (ベータ リリース)」</h3><p>まだベータ版ということで、将来的に変更の可能性がある点に、ご注意ください。</p><p>この機能では、入力を</p><ol><li>モデル名</li><li>モデル バージョン</li><li>入力テンソル (name, shape, datatype and tensor data)</li></ol><p>で区別して、推論結果を保持します。保持されるのは出力テンソル (name, shape, datatype and tensor data) です。キャッシュに保持されている過去のリクエストと一致する入力が与えられたとき、Triton は、モデルの実行をスキップしてレスポンスを返すようになります。</p><p>有効にするためには、 tritonserver コマンド実行時に --response-cache-byte-size オプションへ非負の値を渡し、キャッシュを有効にしたいモデルの設定 (= config.pbtxt) に以下を追加します。</p><pre>response_cache {<br>    enable: True<br>}</pre><p>これにより、--response-cache-byte-size オプションに渡されたサイズ分、CPU メモリ上にキャッシュ用の領域を確保します。この確保された領域は、キャッシュが有効化されている全モデルの全リクエストで共有されます。キャッシュの存在判定自体は、入力から計算されるハッシュ ベースで行われます。キャッシュがあふれる場合、いまのところ LRU (<a href="https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)">英語版 Wikipedia</a> / <a href="https://ja.wikipedia.org/wiki/%E3%82%AD%E3%83%A3%E3%83%83%E3%82%B7%E3%83%A5%E3%82%A2%E3%83%AB%E3%82%B4%E3%83%AA%E3%82%BA%E3%83%A0#%E4%BE%8B">日本語版 Wikipedia</a> ) で置き換えが行われえます。</p><p>なお、ドキュメント整備がまだ追い付いていないようで、v2.15.0 タグなどに詳細な説明が存在していません。確認する際は main ブランチなどの、以下のページをそれぞれご確認ください。</p><ul><li><a href="https://github.com/triton-inference-server/server/blob/main/docs/model_configuration.md#response-cache-beta">Model Configuration — Response Cache (beta)</a></li><li><a href="https://github.com/triton-inference-server/server/blob/main/docs/response_cache.md">Triton Response Cache (beta)</a></li></ul><p>そのほか、上記のページには現時点の制限事項も記述されていますので、こちらも併せてご確認ください。(<a href="https://github.com/triton-inference-server/server/blob/main/docs/response_cache.md#known-limitations">Triton Response Cache (beta) — Known Limitations</a>)</p><h3>「Container composer tool が CPU-only コンテナーの作成をサポート」</h3><p>以前から、Triton Inference Server のコンテナー イメージは NGC から提供されていたのですが、サポートしているバックエンドすべてを含む形で配布されていたため、サイズが大きいという課題がありました。最近、TensorFlow バックエンドのみ、PyTorch バックエンドのみ、といった小さいコンテナーも利用できるようになっていますが、それ以外のバックエンドだけを利用したいケースもあると思います。そうした目的のため、<a href="https://github.com/triton-inference-server/server/blob/v2.15.0/compose.py">compose.py</a> というスクリプトが提供されており、これを利用することで必要なバックエンドのみを含む、小さなコンテナー イメージを比較的容易に作成できるようになっていました。(詳細は <a href="https://github.com/triton-inference-server/server/blob/v2.15.0/docs/compose.md">Customize Triton Container</a> をご確認ください)</p><p>一方、これまでは GPU が使えるコンテナーのみが対象で、CPU-only の環境に限定したコンテナー作成には使えませんでした。これが、今回のアップデートで CPU-only のコンテナーを作成できるようになっています。詳細は <a href="https://github.com/triton-inference-server/server/blob/v2.15.0/docs/compose.md#cpu-only-container-composition">Customize Triton Container — CPU only container composition</a> に記載されていますが、基本的には、compose.py を実行する際に付けていた --enable-gpu を外すだけで OK です。ただしいくつかの制限があるようで、特に、現状サポートされるバックエンドが onnxruntime と openvino および python の各バックエンドのみである点は注意が必要かと思います。</p><p>(と、本当はここまでで言及を終えたかったのですが、どうやらまだベース イメージとなるべき NGC コンテナー イメージがリリースされていないようで、現時点では不完全な状況のようです。CPU-only コンテナーを作成したい場合、まだ <a href="https://github.com/triton-inference-server/server/blob/v2.15.0/build.py">build.py</a> を使ってゼロからコンテナーをビルドする必要があります。詳細は <a href="https://github.com/triton-inference-server/server/blob/v2.15.0/docs/build.md">Building Triton</a> をご確認ください。)</p><h3>What’s New に言及されていないアップデート</h3><p>今月は主に 2 つです。</p><ul><li>HTTP で通信する場合に、圧縮オプションが利用可能になりました</li><li>ONNX への自動最適化対象に、OpenVINO が正式に追加されました</li></ul><p>前者は、Triton クライアント SDK を利用して HTTP プロトコルで推論リクエストを送信する際に、圧縮オプションを選択可能になる、というものです。これにより、通信時のパケットサイズを削減できる場合があります。詳細は <a href="https://github.com/triton-inference-server/server/blob/v2.15.0/docs/inference_protocols.md#compression">Inference Protocols and APIs — HTTP Options — Compression</a> と <a href="https://github.com/triton-inference-server/client/tree/main#compression">Client Library APIs — HTTP Options — Compression</a> を参照ください。</p><p>また後者は、Triton のサーバー側で自動的に各種最適化を実行する対象として、OpenVINO が正式に追加された、というものになります。もともと TensorRT などについては、ユーザ側での事前最適化を省略し、サーバー側で最適化を実行するオプションがありました。今回その対象に、OpenVINO も追加された、というアップデートになります。</p><h3>まとめ</h3><p>今月は rate limiter や リクエストのキャッシュ、そのほか圧縮オプションのサポートなど、性能を調整するために重要な更新がいくつか追加されています。また実用上、コンテナー イメージのサイズが小さくなることが重要です。その観点で CPU-only コンテナーについて composer tool のサポートが追加された点も (まだ制限は多いものの) 大きいかと思います。</p><p>今月の追加分に限らず、何か疑問点や問題等ありましたら、お気軽にコメントいただければと思います！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=833e69d40453" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/triton-inference-server-oct-2021-release-overview-833e69d40453">Triton Inference Server 2021 年 10 月のリリース概要</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Triton Inference Server におけるパイプライン化と Business Logic Scripting (BLS)]]></title>
            <link>https://medium.com/nvidiajapan/pipeline-and-bls-on-triton-inference-server-492576d1a2d1?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/492576d1a2d1</guid>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[deployment]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Thu, 04 Nov 2021 03:01:57 GMT</pubDate>
            <atom:updated>2021-11-04T03:01:57.044Z</atom:updated>
            <content:encoded><![CDATA[<p>みなさまこんにちは。仕事が忙しいときに限って妙に筆が乗ることってありますよね。エヌビディアの山崎です。この記事では、先日公開した <a href="https://medium.com/nvidiajapan/triton-inference-server-sept-2021-release-overview-151a7c2c52d3">9 月のリリース概要</a>で言及している、Business Logic Scripting (BLS) について少し深堀りをしたいと思います。例によって「Triton とはいったい……？」という方は、以下の記事をご覧ください。</p><ul><li><a href="https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2">GPU に推論を: Triton Inference Server でかんたんデプロイ</a></li><li><a href="https://medium.com/nvidiajapan/nvidia-triton-inference-server-on-jetson-da4279ff9544">NVIDIA Triton Inference Server を使用したエッジでの AI モデルの展開の簡素化</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*2kUSHIk6vZsJVtN-" /></figure><h3>サーバー サイドでの推論を構成する要素</h3><p>まずはじめに、サーバー側におけるディープラーニングの推論について振り返ってみたいと思います。サーバー サイドで推論を実行する場合、おおまかには以下の図のような構成になることが多いのではないでしょうか。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IHdNrHxORF-0FXBZ" /></figure><p>このとき、多くのモデルは何らかの前処理や後処理を必要とします。いずれも端末側で処理することが可能だったり、フロントエンド サーバー上で実行可能だったりするものの、一方で速度などを考慮すると、バックエンドの API サーバー上で実行したくなるケースも多々あることでしょう。また、端末側に組み込んでしまうと、更新が大変になるという問題も想定されますし、モデルと前後処理は密接に関わることもあるため、分離して管理することが好ましくないケースも想定されます。それ以外にも、モデルを多段で連結して最終結果を得るような利用方法も考えられます。</p><p>こうした背景から、前処理や後処理などは、サーバー側にまとめてデプロイしたくなります。まとめてデプロイされた前処理や後処理は、当然本体となるモデルの前後に呼び出されることになるのですが、たとえば 1 つの処理を 1 つの Python スクリプトとしてデプロイするタイプのサーバー ライブラリで、スクリプト 1 つに API のエンドポイントを 1 つ作るような挙動をするものを考えてみます。すると以下の図のように、前処理、推論処理、後処理、と、3 回リクエストを送ることになってしまい、明らかに非効率です。(注: もちろん 1 つのスクリプトに全部まとめる、ということも可能ですが、ここではそういった実装については目をつぶる……のではなく、1 つのコンポーネントが肥大化することを防止したい、というような場合を考えることにします)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9nz6PyP53BKlZ6eF" /></figure><p>こうした非効率さを取り除くため、多くのサービング ライブラリでは、処理のパイプライン化をサポートする機構が準備されており、Triton Inference Server も同様にパイプライン化の機能を提供しています。</p><h3>サーバー サイドでのパイプライン化</h3><p>Triton Inference Server では、“Ensemble model” という名前でパイプライン化の機能が提供されています。この機能を利用することによって、サーバー サイドで実行した前処理の結果を、そのまま後続の推論処理に引き渡し、連続的に処理を実行することが可能になります。イメージは以下の図のとおりです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/461/0*UxjWCsU-tuvu77vm" /></figure><p>Triton Inference Server が提供するパイプライン化の機能を利用する場合、パイプライン用に設定ファイルを 1 つ追加すれば OK で、簡単に利用できます。さらなる詳細は<a href="https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2">以前の記事</a>の「パイプライン化」や、<a href="https://github.com/triton-inference-server/server/blob/v2.14.0/docs/architecture.md#ensemble-models">公式ドキュメントの “Ensemble Models”</a> をご覧いただければと思いますが、重要な制約として「DAG (Directed Acyclic Graph) にならないケースはサポートされない」というものがあります。</p><h3>DAG にならない場合: BLS で実現</h3><p>「DAG にならない場合」というのは、一例として「ループを含む場合」が挙げられます。”Acyclic” という単語が示すとおり、循環が発生してしまうものは Ensemble model ではサポートされません。一方で処理によっては、ループを利用できると実装が楽になるケースもありそうです。そうした場合、たとえば従来であれば、Python バックエンドで実装された前処理の内側から、明示的に HTTP や gRPC のリクエストをモデルへ投げる必要がありました。しかしこれでは、無駄に通信を発生させてしまうため、せっかくサーバー サイドでパイプライン化したメリットを捨てることになります。こうした無駄を削減するために、今回 BLS が導入されました。</p><p>具体的な使い方などは <a href="https://github.com/triton-inference-server/python_backend/tree/r21.09#business-logic-scripting-beta">Python Backend - Business Logic Scripting (beta)</a> が詳しいですが、ここでは概要について簡単に紹介したいと思います。上記の参考リンクからもわかる通り、BLS におけるパイプラインは、Python バックエンドで Python のコードによって制御することが想定されています。用途としては、前述の通りループを含むような場合に加え、if-else のような条件分岐、データ依存の制御フロー、そのほか、モデル実行と関連づいているカスタム ロジックなどが対象です。</p><p>たとえば対話エージェントのようなものの実装を行う際に、入力された文章が「挨拶」か「質問」かを分類モデルによって判定し、その結果に応じて、「雑談応答のモデル」を実行するか、「質問応答のモデル」を実行するか切り替える、という状況を考えてみます。この場合、従来であれば以下の図のように、まず入力文章の分類モデルに推論リクエストを送り、レスポンスを見て、再度適切なモデルに推論リクエストを送る、という二段階の処理が必要になります。なお実際には、これらの前処理として文字列のトークン化を先に実施しておき、トークンのみを推論リクエストに乗せて送信することになります。また、トークンを文字列に戻すなどの処理を行う必要性から、テキスト生成部分は Ensemble Models によってパイプライン化されているケースが多いと思われます。(注: この場合、事前のトークン化も Triton Inference Server 上で実行される可能性があり、その場合はさらに一回、余分にリクエストを送信することになります。なかなか大変です。)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ov9Dp937XIhiT2Nt" /></figure><p>しかし BLS を利用することで、これらすべてをサーバー上で完結させることができるようになります。イメージは以下の図のようになります。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*K8cPBQNoDbJyPPuX" /></figure><p>このとき、BLS では全体を統括する制御ロジックを実装することになります。実装例は以下の通りです。</p><pre>import numpy as np<br>import triton_python_backend_utils as pb_utils</pre><pre>class TritonPythonModel:<br>...<br>    def exec_request(self, model_name, input_tensor, output_name):<br>        # 推論リクエストの生成<br>        inference_request = pb_utils.InferenceRequest(<br>            model_name=model_name,<br>            requested_output_names=[output_name],<br>            inputs=[input_tensor])<br>        # リクエストの実行<br>        inference_response = inference_request.exec()<br>        if inference_response.has_error():<br>            # エラー発生時は例外を上げる<br>            raise pb_utils.TritonModelException(<br>                inference_response.error().message())<br>        # 戻り値のテンソルを取得して返す<br>        output_tensor = pb_utils.get_output_tensor_by_name(<br>            inference_response, output_name)<br>        return output_tensor<br></pre><pre>    def execute(self, requests):<br>        responses = []<br>        for request in requests:<br>            # 入力テキストの取得<br>            texts_tensor = pb_utils.get_input_tensor_by_name(<br>                request, &#39;texts&#39;)</pre><pre>            # トークン化<br>            tokens_tensor = self.exec_request(<br>                self.tokenizer_name, texts_tensor, &#39;tokens&#39;)<br>            tokens_tensor_array = tokens_tensor.as_numpy()</pre><pre>            # 推論リクエスト (Intent classification)<br>            intents_tensor = self.exec_request(<br>                self.classifier_name, tokens_tensor, &#39;intents&#39;)<br><br>            # 推論リクエスト (Chat generation or Question-Answer)<br>            intents = intents_tensor.as_numpy()<br>            greeting_index_list = np.where(intents == 0)<br>            qa_index_list = np.where(intents == 1)<br>            greeting_reply_tokens_tensor = self.exec_request(<br>                self.chat_model_name,<br>                pb_utils.Tensor(<br>                    &#39;tokens&#39;,<br>                    np.array(<br>                        tokens_tensor_array[greeting_index_list],<br>                        dtype=tokens_tensor_array.dtype<br>                )),<br>                &#39;generated_chat_tokens&#39;)<br>            qa_reply_tokens_tensor = self.exec_request(<br>                self.qa_model_name,<br>                pb_utils.Tensor(<br>                    &#39;tokens&#39;,<br>                    np.array(<br>                        tokens_tensor_array[qa_index_list],<br>                        dtype=tokens_tensor_array.dtype<br>                )),<br>                &#39;generated_answer_tokens&#39;)<br>...<br>            # トークンを文字列に戻す<br>            reply_texts_tensor = self.exec_request(<br>                self.detokenizer_name,<br>                pb_utils.Tensor(<br>                    &#39;tokens&#39;, reply_tokens_tensor_array),<br>                &#39;texts&#39;)</pre><pre>            # 結果を作成<br>            replies = pb_utils.Tensor(<br>                &#39;replies&#39;, reply_texts_tensor.as_numpy())<br>            inference_response = pb_utils.InferenceResponse(<br>                output_tensors=[replies])<br>            responses.append(inference_response)<br>        return responses</pre><p>重要なポイントは以下の点です。</p><ul><li>triton_python_backend_utils.InferenceRequest クラスのオブジェクトに、対象となるモデル名、入力テンソル、必要とする出力テンソル名、を指定してリクエストを生成</li><li>triton_python_backend_utils.InferenceRequet.exec() で、リクエストを実行</li><li>triton_python_backend_utils.get_output_tensor_by_name() で、名前を指定して結果のテンソルを取得</li><li>複数の出力をまとめて取りたい場合は、triton_python_backend_utils.InferenceResponse.output_tensors() でも OK</li></ul><p>また、上記の例では # 推論リクエスト (Chat generation or Question-Answer) の箇所で、直前のモデルからの出力を使って、次の処理の分岐を行っています。intents の値が、0 の場合は雑談応答モデルを、1 の場合は質問応答モデルを、それぞれ呼び出すようになっています。このように、データによって処理を分岐させるような場合、BLS が有効に機能します。</p><p>なお、この応答生成部分については、それぞれ入力されるデータに依存関係がないため、並列に実行することができます。そういった用途 (を含む効率的な実行) のために、非同期 API もサポートされています。非同期化のために必要なことは以下の通りです。</p><ul><li>エントリー ポイントとなるクラス TritonPythonModel の execute() に async キーワードを追加</li><li>リクエストの実行を、 triton_python_backend_utils.InferenceRequest.exec() から triton_python_backend_utils.InferenceRequest.async_exec() に変更</li><li>さらに、戻り値の awaitable オブジェクトをリストなどに保持</li><li>asyncio を使って、リクエストの戻り値に対して await asyncio.gather() して、すべての結果が返ってくるのを待つ</li></ul><p>実際のサンプルについては <a href="https://github.com/triton-inference-server/python_backend/tree/r21.09/examples/bls">“BLS Example”</a> などをご覧ください。</p><h3>まとめ</h3><p>複雑な処理パイプラインを実装するための、Business Logic Scripting (BLS) について紹介しました。通常は Ensemble model の範囲内で収まるケースが大半だとは思いますが、ループ、条件分岐やそのほか複数のモデルを統合するようなカスタム ロジックが必要な場合に、有効な機能になるのではないでしょうか。</p><p>興味をお持ちいただけましたら、ぜひ一度、<a href="https://ngc.nvidia.com/catalog/containers/nvidia:tritonserver">NGC</a> から Triton Inference Server のコンテナー イメージをダウンロードしてお試しください！</p><h3>再度の宣伝</h3><p>そしてしつこく宣伝です。<a href="https://medium.com/nvidiajapan/triton-inference-server-sept-2021-release-overview-151a7c2c52d3">前回の記事</a>でも触れましたが、11 月 8 日より<a href="https://www.nvidia.com/ja-jp/gtc/">秋の GTC</a> が開催されます。GPU を利用した推論は <a href="https://events.rainfocus.com/widget/nvidia/nvidiagtc/sessioncatalog?search.topic=16246413645860212MnD">Topic &gt; ”Deep Learning — Inference”</a> などで確認できます。少しでも興味をお持ちいただけたら、<a href="https://www.nvidia.com/ja-jp/gtc/?ncid=GTC-NVKYAMASAKI">https://www.nvidia.com/ja-jp/gtc/?ncid=GTC-NVKYAMASAKI</a> から参加登録を、ぜひ！よろしくお願いします！！</p><h3>余談</h3><p>今回も資料の素材として、ヒューマンピクトグラム2.0 (<a href="https://pictogram2.com/">https://pictogram2.com/</a>) のピクトさんを利用しています。いつも大変助かっています。ありがとうございます。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=492576d1a2d1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/pipeline-and-bls-on-triton-inference-server-492576d1a2d1">Triton Inference Server におけるパイプライン化と Business Logic Scripting (BLS)</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Triton Inference Server 9 月のリリース概要]]></title>
            <link>https://medium.com/nvidiajapan/triton-inference-server-sept-2021-release-overview-151a7c2c52d3?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/151a7c2c52d3</guid>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[gpu]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Thu, 14 Oct 2021 03:26:15 GMT</pubDate>
            <atom:updated>2021-10-14T07:58:55.656Z</atom:updated>
            <content:encoded><![CDATA[<p>一部の方はご無沙汰しております。その他の方ははじめまして。NVIDIA の山崎です。</p><p>最近にわかに盛り上がりを見せている (と信じている) Triton Inference Server ですが、実はひっそりと毎月アップデートがリリースされていました。お気づきでしたでしょうか。今月から、リリース ノートの概要と、リリース ノートに書かれていないけど面白い追加機能など、毎月紹介していきます。そもそも「Triton Inference Server って何？」という方は、日本語では以下の記事が参考になるかと思います。</p><ul><li><a href="https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2">GPU に推論を: Triton Inference Server でかんたんデプロイ</a></li><li><a href="https://medium.com/nvidiajapan/nvidia-triton-inference-server-on-jetson-da4279ff9544">NVIDIA Triton Inference Server を使用したエッジでの AI モデルの展開の簡素化</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*-i2g8lLdKCLyzZjuhxZXaQ.png" /></figure><h3>What’s New in 2.14.0 (NGC 21.09)</h3><p>リリース ノート本体は <a href="https://github.com/triton-inference-server/server/releases/tag/v2.14.0">https://github.com/triton-inference-server/server/releases/tag/v2.14.0</a> です。今月のリリースには以下の機能や改善などが含まれています。</p><ul><li><a href="https://github.com/triton-inference-server/python_backend/tree/r21.09#business-logic-scripting-beta">Business Logic Scripting (BLS)</a> が “full featured” ベータ リリースされました</li><li><a href="https://github.com/triton-inference-server/client/tree/r21.09/src/java">Java 向けのクライアント ライブラリ</a>がベータ リリースされました</li><li>Triton クラッシュ時の stack trace が改善されました</li><li>(Python の) クライアント ライブラリが PyPI から直接ダウンロードできるようになりました</li><li>TensorRT バックエンドがオプションになりました。不要な場合は <a href="https://github.com/triton-inference-server/server/blob/v2.14.0/docs/compose.md">compose utility</a> で外せます</li><li>Model analyzer 周りにいくつかの改善 (Triton C API へのプロファイリング＆ GPU デバイス ID の指定) が入っています</li></ul><p>上記のうち特に気になるものをピックアップします。</p><h4>「Business Logic Scripting (BLS) の “full featured” ベータ リリース」</h4><p>BLS 自体は 21.08 から導入された機能で、<a href="https://github.com/triton-inference-server/server/blob/main/docs/architecture.md#ensemble-models">Ensemble Models</a> でサポートされない (できない)、複雑なパイプライン構築をサポートします (詳細は後日別記事にて)。21.08 時点では、いくつかの機能が制限されていたのですが、21.09 で全機能が公開されています。この 21.09 で追加された機能は、主に inference_request.async_exec() などの非同期 API となります。</p><h4>「(Python の) クライアント ライブラリが PyPI から直接ダウンロードできるように」</h4><p>これまでも pip を使ってクライアント ライブラリをインストールできていたのですが、正式に PyPI へ登録されたようです。最新版だけではなく、過去のバージョンも登録されたよう (<a href="https://pypi.org/project/tritonclient/#history">https://pypi.org/project/tritonclient/#history</a>) ですので、適宜活用していただくとよさそうです。</p><h4>「TensorRT バックエンドがオプションに」</h4><p>これまでの Triton では、コンテナー形式で配布される場合、すべてのバックエンドが含まれた形でのみの提供となっていました。しかし 21.08 の更新で <a href="https://github.com/triton-inference-server/server/blob/v2.14.0/docs/compose.md">Container Composition Utility</a> がリリースされ、特定のバックエンドのみを含むコンテナーを選択的に作成できるようになっていました。また余談ですが、同じタイミングで NGC のコンテナー イメージとして、TensorFlow2 のみ、および PyTorch のみを含むイメージも公開されるようになっています。(参考: <a href="https://github.com/triton-inference-server/server/releases/tag/v2.13.0">前回のリリース ノート</a>) 今回の更新では、TensorRT も、こうしたバックエンドの選択対象として追加されています。</p><h3>What’s New に言及されていないアップデート</h3><p>(毎月のことですが) What’s New には、すべての更新内容が記載されていないことがあります。ここでは、そうした機能などについて簡単に紹介していきます。今月は「<a href="https://github.com/triton-inference-server/python_backend/tree/r21.09#interoperability-and-gpu-support">Python バックエンドの入力テンソルに関する GPU メモリの取り扱い改善</a>」です。</p><p>これまでも、Python バックエンド内部で GPU を利用することはできました。前処理や後処理での活用が主な想定ですが、TensorFlow バックエンドや PyTorch バックエンドで扱いにくい複雑な処理を実装するためにも利用されます。このとき、Python バックエンド内部で各種ディープラーニング フレームワークを呼び出すことになります。(イメージは以下)</p><pre>…<br>import triton_python_backend_utils as pb_utils</pre><pre>class TritonPythonModel:<br>...<br>    def _request_to_torch_tensor(self, req, tensor_name):<br>        t = pb_utils.get_input_tensor_by_name(<br>            req,<br>            tensor_name).as_numpy()<br>        # Moving data from CPU to GPU.<br>        t = torch.from_numpy(t[0].copy()).to(<br>            self.device, non_blocking=True)<br>        return t</pre><pre>    def execute(self, requests):<br>        # NOTE: assuming batchsize of each request is only one.<br>        batch = [self._request_to_torch_tensor(req, &quot;input&quot;) \<br>            for req in requests]<br>        with torch.no_grad():<br>            results = self._model(batch)<br>...</pre><p>このコード例からも分かる通り、入力テンソルは最初、CPU 上に配置されています。それを GPU 上に移動させて、実際の処理を実行することになります。</p><p>これが処理パイプラインの先頭であればこの構造は理解できるものですが、パイプラインの途中にこの Python バックエンドが位置する場合はどうでしょうか。入力テンソルが CPU に配置されているということは、直前のステップが GPU を使っていたかに関係なく、データが一度 CPU に戻されていることを意味します。しかし、連続するステップのどちらも GPU を利用する場合、一度 CPU にデータが戻っているのは無駄です。今回導入された機構を利用すると、Python バックエンドへの入力テンソルの配置を「ある程度」コントロールできるようになります。</p><p>具体的には、以下の設定をモデルの config.pbtxt に追加すれば OK です。</p><pre>parameters: { key: &quot;FORCE_CPU_ONLY_INPUT_TENSORS&quot; value: {string_value:&quot;no&quot;}}</pre><p>パラメーター名の通り、入力テンソルを CPU のみに強制する、という動作を無効化します。Python バックエンドのデフォルト動作はこれまでと変わらず、CPU 上に入力テンソルを配置する、というものですが、上記の設定によって、入力テンソルの配置先を CPU / GPU から Triton が選択するようになります。このとき、どちらのデバイスが使われるかは、先行するステップなどを加味して決定されます。(注: ONNX バックエンドが先行する場合、うまく GPU メモリが利用されないバグがあるようです “<a href="https://github.com/triton-inference-server/onnxruntime_backend/issues/73">ORT backend always returns tensor on CPU #73</a>”)</p><p>また関連する機構として、<a href="https://github.com/dmlc/dlpack">DLPack</a> が利用可能になっています。これにより、Triton 独自の Tensor 型から各フレームワークへのデータ移動を、効率よく実行できるようになっています。詳細は以下をご覧ください。</p><ul><li><a href="https://github.com/triton-inference-server/python_backend/tree/r21.09#pb_utilstensorto_dlpack---pycapsule">pb_utils.Tensor.to_dlpack() -&gt; PyCapsule</a></li><li><a href="https://github.com/triton-inference-server/python_backend/tree/r21.09#pb_utilstensorfrom_dlpack---tensor">pb_utils.Tensor.from_dlpack() -&gt; Tensor</a></li><li><a href="https://github.com/triton-inference-server/python_backend/tree/r21.09#pb_utilstensoris_cpu---bool">pb_utils.Tensor.is_cpu() -&gt; bool</a></li></ul><h3>まとめ</h3><p>今月のリリースでは、処理パイプラインの機能拡張をサポートする BLS と、Python バックエンドでの GPU メモリの取り扱い改善が重要な更新だったかと思います。その他の追加機能も、<a href="https://github.com/triton-inference-server/server/blob/v2.14.0/docs/compose.md">Container Composition Utility</a> は実利用を考える上で重要な機構ではないでしょうか。</p><p>今後も引き続き、毎月新機能などがリリースされていきます。このブログで、タイムリーに内容を紹介できればと思います。なにか不明点やご要望などあれば、お気軽にコメントいただけると大変嬉しいです。</p><h3>宣伝</h3><p>最後にちょっとだけ宣伝です。今年も昨年同様、秋にも GTC が開催されます。500 以上のセッションを準備してお届けします。GPU を利用した推論については、<a href="https://events.rainfocus.com/widget/nvidia/nvidiagtc/sessioncatalog?search.topic=16246413645860212MnD">Topic &gt; ”Deep Learning - Inference” などで確認できます</a>。少しでも興味をお持ちいただけたら、<a href="https://www.nvidia.com/ja-jp/gtc/?ncid=GTC-NVKYAMASAKI">https://www.nvidia.com/ja-jp/gtc/?ncid=GTC-NVKYAMASAKI</a> から参加登録を是非！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=151a7c2c52d3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/triton-inference-server-sept-2021-release-overview-151a7c2c52d3">Triton Inference Server 9 月のリリース概要</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GPU に推論を: Triton Inference Server でかんたんデプロイ]]></title>
            <link>https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd2980514af2</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[nvidia]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Thu, 04 Mar 2021 02:58:23 GMT</pubDate>
            <atom:updated>2022-03-01T03:58:10.529Z</atom:updated>
            <content:encoded><![CDATA[<p>おはようございます / こんにちは / こんばんは / お疲れさまです。エヌビディアの山崎です。みなさんディープラーニング、してますか？今回は、じわじわと認知度が上がってきている (と信じたいところである)、Triton Inference Server について解説しようと思います。一昔前は、若干とっつきにくい感のあるサービング フレームワークでしたが、ずいぶん便利になったということもあり、ぜひ一度お試しいただければ。<br>なおこの記事は、執筆時点の最新版である v2.6.0 を前提として構成されています。</p><h3>忙しい人のためのまとめ</h3><ul><li>Triton Inference Server は GPU の性能を最大限引き出して、オンライン推論を高速実行できるようにするための機構を多数持つ</li><li>さまざまなフォーマットの学習結果をデプロイ可能</li><li>ディープラーニングのフレームワークだけではなく、任意の処理を実行させることも可能 (Python or C++)</li><li>実は CPU だけのマシンでも動く</li></ul><h3>Triton Inference Server とは？</h3><p>集約効率を最大化しつつ、高速低遅延で推論結果を返却できるよう最適化されたサービング フレームワークで、活発に開発が続けられているオープンソース プロジェクトです。<br><a href="https://github.com/triton-inference-server/server">https://github.com/triton-inference-server/server</a><br>過去、TensorRT Inference Server (TRTIS) と呼ばれていたプロジェクトをご存じの方は、リネームされ、開発継続した発展版だとご理解いただいて問題ないかと思います。なお現コードネームである “Triton” は、「とりとん」ではなく「<strong>とらいとん</strong>」と呼んでいただければ幸いです。</p><figure><img alt="Triton Inference Server の全体像" src="https://cdn-images-1.medium.com/max/386/0*OqWplzmgUNlVWhBi" /><figcaption>Triton Inference Server の全体像</figcaption></figure><p>Triton には、GPU の利用率を最大化しながら大量アクセスを上手に捌くために、リクエストキューを利用して動的にバッチ構築する機構が実装されていたり、ひとつの GPU 上で複数のモデルや単一モデルのコピーを並列で動作させられるなど、自前実装しようとすると面倒な機能が大量に実装されています (そのほか、GPU が複数枚搭載されているサーバ向けの機構もありますが今回は割愛)。 ちょっとした検証やデモのために使うもよし、本番の高負荷な環境に投入するもよし、という地味に便利なサービング フレームワークです。</p><p>今回は Triton の使い方の中でも、最も基本的かつ典型的と思われるユースケースに絞って説明をします。より発展的な使い方などについては、のちのち記事化したいと思います。もし「こういうことって可能なの？」などあれば、お気軽にコメント等いただければ幸いです。</p><h3>いちばん基本の使い方</h3><p>なにはともあれ、一度動かしてみましょう。典型的には以下の流れで、学習済みモデルをデプロイします。</p><ul><li>学習済みモデルを、サーバ上にコピー</li><li>設定ファイルを書く</li><li>Triton を起動</li><li>クライアント側を実装</li><li>完！</li></ul><p>…<br>……<br>………<br>…………<br>これだけではなんのことやら、という感じですので、それぞれ簡単に確認していきます。</p><p>まず、学習済みモデルをサーバ上に配置します。このとき、ディレクトリ構造は以下のように、一定の規約に則って作成する点に注意してください。</p><pre>models/<br>├── modelA/<br>│ ├── 1/<br>│ │ └── model/<br>│ │     ├── saved_model.pb<br>│ │     └── variables/<br>│ │           ├── variables.data-00000-of-00001<br>│ │           └── variables.index<br>│ ├── 2/<br>: :<br>│ └── config.pbtxt<br>│<br>├── modelB/<br>: :</pre><p>トップディレクトリ (models) の下に、デプロイしたいモデルごと (modelA や modelB) にディレクトリを作成します。各モデルディレクトリ内には、固定の名前の設定ファイル (config.pbtxt) とバージョンごとのディレクトリを作成します。バージョンごとのディレクトリ名は数字で、1 はじまりが基本となります。</p><p>次に設定ファイルを記述します。Protocol Buffers 形式に従って、テキストファイルとして定義します。以下に一例を示します。</p><pre>name: &quot;modelA&quot;<br>platform: &quot;tensorflow_savedmodel&quot;<br>max_batch_size: 64<br>input [<br>    {<br>        name: &quot;input_1&quot;<br>        data_type: TYPE_FP32<br>        format: FORMAT_NHWC<br>        dims: [ 224, 224, 3 ]<br>    }<br>]<br>output [<br>    {<br>        name: &quot;predictions&quot;<br>        data_type: TYPE_FP32<br>        dims: [ 1000 ]<br>    }<br>]<br>default_model_filename: &quot;model&quot;</pre><p>各項目は以下の内容を設定しています。</p><ul><li>name<br>モデル名を記述。設定ファイルのあるディレクトリ名と一致させる必要があります。</li><li>platform<br>デプロイ対象のモデル形式を記述。上記の例では、TensorFlow の SavedModel なので “tensorflow_savedmodel” としています。その他、TensorRT、ONNX Runtime、TorchScript、Python、DALI などがサポートされています。詳細は、後述のリンクから “Backends” のセクションを参照してください。</li><li>max_batch_size<br>バッチサイズの最大値を指定。モデルの定義によって、可変バッチサイズをサポートしていないことがあるため、0 を指定する (または max_batch_size を記述しない) 場合がある点に注意してください。</li><li>input / output<br>入出力テンソルの情報 (入出力名、データ型、次元など) を指定。入出力の名前は、TensorFlow の SavedModel は、saved_model_cli コマンドを利用すると簡単に確認できます (参考: <a href="https://www.tensorflow.org/guide/saved_model#show_command">https://www.tensorflow.org/guide/saved_model#show_command</a>)。<br>TorchScript の場合、一定の命名規則に従って、入出力に名前が自動付与されます。詳細は以下のページに記述されていますが、一例としてたとえば、”INPUT__0&quot;、”INPUT__1&quot;、”OUTPUT__0&quot;、”OUTPUT__1&quot; のように、”INPUT / OUTPUT” とインデックスを、ふたつのアンダースコアで繋いだ文字列となります。</li><li>default_model_filename<br>デフォルトのモデル名を上書き。各 platform ごとにデフォルトのモデル名 (e.g., TensorRT の場合 “model.plan” など) は設定されていますが、別の名前でデプロイすることもできます。<br>また、GPU の <a href="https://developer.nvidia.com/cuda-gpus">Compute Capability (CC)</a> ごとにファイルを変更することもでき、その場合は ”cc_model_filenames” に対応関係を記述します。このとき、記述されなかった CC の GPU 上で Triton を動かす場合は、前述の “default_model_filename” もしくは初期設定のデフォルト名でモデルをロードしようとします。</li></ul><p>それぞれの項目に関する詳細は、以下のリンクからたどることができます。</p><ul><li>platform の “Backends”<br><a href="https://github.com/triton-inference-server/backend/blob/r20.12/README.md#backends">https://github.com/triton-inference-server/backend/blob/r20.12/README.md#backends</a></li><li>max_batch_size<br><a href="https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_configuration.md#maximum-batch-size">https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_configuration.md#maximum-batch-size</a></li><li>input / output<br><a href="https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_configuration.md#inputs-and-outputs">https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_configuration.md#inputs-and-outputs</a></li><li>Model files<br><a href="https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_repository.md#model-files">https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_repository.md#model-files<br></a><a href="https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto#L1614-L1620">https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto#L1614-L1620</a></li></ul><p>上記の例からも分かる通り、どことなく JSON めいた雰囲気があるので、形式自体は難しくないのですが、各機能をどのように設定内部に書くのか、という点で少し戸惑うかもしれません。以下のページに設定の詳細と、各項目の定義が書かれています。<br><a href="https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_configuration.md">https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_configuration.md</a><br><a href="https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto">https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto</a></p><p>(余談: <a href="https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_configuration.md#auto-generated-model-configuration">https://github.com/triton-inference-server/server/blob/v2.6.0/docs/model_configuration.md#auto-generated-model-configuration</a> には、 --strict-model-config=false を起動時オプションとして付与することで最小限の設定以外は自動推定してくれる、ということが書かれています。モデル定義等にもよりますが、設定ファイルがなくとも動かせるようになるので、まずこちらを試していただいてもよいかもしれません)</p><p>モデルファイルと設定ファイルを配置できたら、Triton の起動準備完了です。Triton 自体をソースコードからビルドしてインストールし、起動、というのも良いのですが、ここではビルド済みの docker コンテナイメージを利用します。以下のページにあるコマンドの通り、<br><a href="https://github.com/triton-inference-server/server/blob/v2.6.0/docs/quickstart.md#run-triton">https://github.com/triton-inference-server/server/blob/v2.6.0/docs/quickstart.md#run-triton</a></p><pre>docker run --gpus=1 --rm -p8000:8000 -p8001:8001 -p8002:8002 \<br>  -v /path/to/models:/models nvcr.io/nvidia/tritonserver:20.12-py3 \<br>    tritonserver --model-repository=/models</pre><p>と実行してみましょう。最終的に、</p><pre>...<br>I0130 14:51:48.867256 1 grpc_server.cc:3979] Started GRPCInferenceService at 0.0.0.0:8001<br>I0130 14:51:48.867676 1 http_server.cc:2717] Started HTTPService at 0.0.0.0:8000<br>I0130 14:51:48.909774 1 http_server.cc:2736] Started Metrics Service at 0.0.0.0:8002</pre><p>のようなログメッセージが出力されれば、起動成功です。コマンドの意味は、以下の通りです。</p><ul><li>-p8000:8000 -p8001:8001 -p8002:8002<br>HTTP / gRPC / metrics のそれぞれにアクセスするために、ポートをホスト側にマッピングしています。Triton の起動時オプションである --http-port、--grpc-port、 --metrics-port で、それぞれのポート番号を変更可能です。</li><li>-v /path/to/models:/models<br>ホスト側で /path/to/models というディレクトリの下にすべてのモデルが配置されていると仮定して、それをコンテナ内の /models としてマウントしています。</li><li>tritonserver --model-repository=/models<br>tritonserver が、Triton の実行バイナリです。 --model-repository で、コンテナ内でのモデルが格納されているディレクトリを指定して、Triton を起動しています。</li></ul><p>なお Triton 自体のオプションを表示したい場合は、(やや面倒ですが) 例えば以下のようにすると標準出力に表示されます。</p><pre>docker run --rm nvcr.io/nvidia/tritonserver:20.12-py3 tritonserver --help<br>...<br>Usage: tritonserver [options]<br>  --help<br>        Print usage<br>...</pre><p>ここまで順調にサーバが起動したように見えるのですが、念のため、HTTP リクエストを送って本当に問題がないか確認してみましょう。Triton は KFServing の Predict Protocol, version 2 に準拠しており、ヘルスチェック用のエンドポイントが提供されています。<br><a href="https://github.com/kubeflow/kfserving/blob/master/docs/predict-api/v2/required_api.md#httprest">https://github.com/kubeflow/kfserving/blob/master/docs/predict-api/v2/required_api.md#httprest</a></p><p>たとえば、</p><pre>curl -v -o - localhost:8000/v2/health/ready</pre><p>のようにリクエストを投げると、</p><pre>...<br>&lt; HTTP/1.1 200 OK<br>&lt; Content-Length: 0<br>&lt; Content-Type: text/plain<br>&lt;<br>* Connection #0 to host localhost left intact</pre><p>という出力が得られます。同様に、各モデルが問題なくロードできているかどうかは、</p><pre>curl -v -o - localhost:8000/v2/models/modelA/ready<br>*   Trying 127.0.0.1...<br>* TCP_NODELAY set<br>* Connected to localhost (127.0.0.1) port 8000 (#0)<br>&gt; GET /v2/models/modelA/ready HTTP/1.1<br>&gt; Host: localhost:8000<br>&gt; User-Agent: curl/7.60.0<br>&gt; Accept: */*<br>&gt;<br>&lt; HTTP/1.1 200 OK<br>&lt; Content-Length: 0<br>&lt; Content-Type: text/plain<br>&lt;<br>* Connection #0 to host localhost left intact</pre><p>のように 200 OK が返却されることで確認できます。<br>(余談 2: 実際には標準以外の API も必要になるため、そうしたものは extension として別途定義されています。<a href="https://github.com/triton-inference-server/server/tree/v2.6.0/docs/protocol">https://github.com/triton-inference-server/server/tree/v2.6.0/docs/protocol</a>)</p><p>最後に、リクエストを投げる側、クライアントを実装します。Triton では HTTP もしくは gRPC を通信用のインタフェースとして提供しています。簡易に動作確認する場合は curl などのコマンドを利用したくなりますが、リクエストに乗せる JSON のフォーマットが定められているため、少々面倒です。そこでここでは、Triton で公式に提供しているクライアント ライブラリを利用することとします。<br><a href="https://github.com/triton-inference-server/server/blob/v2.6.0/docs/client_libraries.md">https://github.com/triton-inference-server/server/blob/v2.6.0/docs/client_libraries.md</a></p><p>インストールの方法には、ソースからの手動ビルド以外に、ビルド済みバイナリ、pip 経由、ビルド済み docker コンテナ イメージが存在します。今回はコンテナを利用してみます。以下のコマンドを実行すると、クライアントライブラリがインストールされたコンテナ内部で、任意の操作が可能になります。</p><pre>docker run -it --rm --net=host nvcr.io/nvidia/tritonserver:20.12-py3-sdk</pre><p>このコンテナには、各種サンプルコードが /workspace/src/clients/python/examples/ などに置かれていますが、ここでは、ステップ バイ ステップで利用方法を説明します。</p><p>まずサーバにリクエストを投げるためのクライアント オブジェクトは、tritonclient.http.InferenceServerClient もしくは tritonclient.grpc.InferenceServerClient を利用して、たとえば以下のように生成します。</p><pre>If protocol == &#39;http&#39;:<br>    import tritonclient.http as client_module<br>    port = 8000<br>elif protocol == &#39;grpc&#39;:<br>    import tritonclient.grpc as client_module<br>    port = 8001<br>with client_module.InferenceServerClient(f&#39;localhost:{port}&#39;) as client:</pre><p>これにより client オブジェクトを介して、サーバへリクエストを投げられるようになります。次に、リクエストの入出力を定義します。それぞれ、tritonclient.http.InferInput / tritonclient.grpc.InferInput および tritonclient.http.InferRequestedOutput / tritonclient.grpc.InferRequestedOutput を使って定義します。以下はその一例です。</p><pre>inputs = [<br>    client_module.InferInput(<br>       &#39;input_1&#39;,<br>        images.shape,<br>        np_to_triton_dtype(images.dtype)),<br>]<br>inputs[0].set_data_from_numpy(images)</pre><pre>outputs = [<br>    client_module.InferRequestedOutput(&#39;predictions&#39;),<br>]</pre><p>このとき、np_to_triton_dtype() は tritonclient.utils に定義されている関数で、images はリクエストに含めたいデータの numpy.ndarray です。推論リクエスト自体は以下の関数呼び出しにより実行されます。</p><pre>response = client.infer(<br>    &#39;modelA&#39;,<br>    inputs,<br>    request_id=str(1),<br>    outputs=outputs)</pre><p>レスポンスは以下のようにすると、numpy の ndarray 形式で取得できます。</p><pre>predictions = response.as_numpy(&#39;predictions&#39;)</pre><p>このクライアントライブラリはこの他、</p><ul><li>非同期リクエスト</li><li>ヘルスチェック API</li><li>サーバ / モデルメタデータ API</li><li>モデル制御 API</li></ul><p>など、定義済みのサーバ側インタフェースを一通り提供しています。</p><h3>モデルの並列実行</h3><p>ここまでの内容で、基本的なモデルの API 化が可能になりました。通常 API サーバには、多数のリクエストが送信されます。一方みなさんご存知の通り、GPU はシーケンシャルに実行するより、並列に多数の処理を実行するほうが効率的なことが多いです。素直な API サーバの実装では、到着順に GPU へ処理を流し、結果が得られたものからレスポンスを返すことになります。しかしこれでは、GPU の高い並列性能を活かしきることができません。</p><p>そこで Triton では、モデルの並列実行をサポートする仕組みを提供しています。ひとつは、ここまでで説明してきた様々なモデルを同時にデプロイできるという仕組みの延長で、デプロイ済みのモデルはいずれも並列実行されます。これに加えて、それぞれのモデルについても、設定を加えることで複数のコピーを並列に実行できるようになります。これによって、大量のリクエストが送信された場合でも、遅延を大幅に悪化させるような事態を防ぐことができるようになります。</p><p>設定例は以下のとおりです。</p><pre>instance_group [<br>  {<br>    count: 2<br>    kind: KIND_GPU<br>  }<br>]</pre><p>(詳細: <a href="https://github.com/triton-inference-server/server/blob/master/docs/model_configuration.md#instance-groups">https://github.com/triton-inference-server/server/blob/master/docs/model_configuration.md#instance-groups</a> &amp; <a href="https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto#L133-L235">https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto#L133-L235</a>)</p><p>イメージは以下の図のように、あるモデルに対して複数のコピー (インスタンスと呼んでいます) を準備しておき、多数のリクエストが来たら、適宜空いているインスタンスに割り当てて処理を並列実行する、というものです。</p><figure><img alt="モデル並列実行の例" src="https://cdn-images-1.medium.com/max/668/0*UpRxeLaX5FAU9Wis" /><figcaption>モデル並列実行の例</figcaption></figure><p>この図の例は、ResNet50 のインスタンスが 12 個設定されている状況で、並列に 14 リクエストが送信されると、最初の 12 リクエストが即座に並列実行され、2 つのリクエストが先行する 12 リクエストの処理待ちに入っている、というシナリオになります。</p><h3>Dynamic batching</h3><p>モデルの並列実行に加えて、Triton が提供するもう一つの重要な機能が、dyanmic batching です。これはリクエストをキューイングし、動的にバッチを構成する機構で、こちらも設定だけで有効にできます。具体的には、各モデルの config.pbtxt に以下のような記述を追加するだけで OK です。</p><pre>dynamic_batching {<br>    preferred_batch_size: [ 4 ]<br>    max_queue_delay_microseconds: 10000<br>}</pre><p>(詳細: <a href="https://github.com/triton-inference-server/server/blob/master/docs/model_configuration.md#dynamic-batcher">https://github.com/triton-inference-server/server/blob/master/docs/model_configuration.md#dynamic-batcher</a> &amp; <a href="https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto#L974-L1047">https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto#L974-L1047</a>)</p><p>この設定は、以下の図のようなイメージです。複数のリクエストが連続的にサーバへ到着し、サーバ側には 2 つのモデルインスタンスが存在する状況を考えます。Dynamic batching を設定していない場合、それぞれのリクエストは到着順に独立して処理されます。そのため、仮に GPU の能力が余っていて、遅れて到着したリクエストを同時処理する余裕があっても、先着のリクエストが処理を終えるまで、待たされることになります。</p><p>一方、dynamic batching が有効な状況では、以下の図のように、指定された時間 (設定中の max_queue_delay_microseconds) 内に到着したリクエストは、サーバ側で指定されたサイズの範囲 (設定中の preferred_batch_size) で一つにまとめられ、同時に処理されます。これにより、平均待ち時間を削減しつつ、GPU の使用効率を向上させることが可能になります。</p><figure><img alt="複数のリクエストが連続して到着する例" src="https://cdn-images-1.medium.com/max/970/0*NTEpw8spC5gW0GyX" /><figcaption>複数のリクエストが連続して到着する例</figcaption></figure><figure><img alt="Dynamic batching による割り当て例" src="https://cdn-images-1.medium.com/max/959/0*JEagHx_CMLJzM2Fz" /><figcaption>Dynamic batching による割り当て例</figcaption></figure><h3>パイプライン化</h3><p>単一のファイルから構成されるモデルをデプロイする場合には、ここまでの内容で概ね十分なのですが、一方、複数のモデルを連結させたい場合や、前処理や後処理で独自の処理を記述したい場合もあるかと思います。そうした用途向けに、モデルをパイプライン化する機構も、Triton では提供されます。</p><p>(名前が紛らわしいとよく言われているというか私も紛らわしいと思っているのですが、) Triton のドキュメントで “Ensemble Models” と呼ばれている機能が、モデルをパイプライン化する機能になります。<br>(詳細: <a href="https://github.com/triton-inference-server/server/blob/master/docs/architecture.md#ensemble-models">https://github.com/triton-inference-server/server/blob/master/docs/architecture.md#ensemble-models</a> &amp; <a href="https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto#L1280-L1335">https://github.com/triton-inference-server/server/blob/v2.6.0/src/core/model_config.proto#L1280-L1335</a>)</p><p>具体的には以下のように、パイプライン化したいモデルを列挙し、個々のモデルの入出力を記述するだけで処理を連結してくれるというものです。</p><pre>ensemble_scheduling {<br>  step [<br>    {<br>      model_name: &quot;image_preprocess_model&quot;<br>      model_version: -1<br>      input_map {<br>        key: &quot;RAW_IMAGE&quot;<br>        value: &quot;IMAGE&quot;<br>      }<br>      output_map {<br>        key: &quot;PREPROCESSED_OUTPUT&quot;<br>        value: &quot;preprocessed_image&quot;<br>      }<br>    },<br>    {<br>    ...</pre><p>実際には、さらに以下の作業が必要です。</p><ul><li>上記 ensemble_scheduling を含むひとつの config.pbtxt を作成し、ひとつの独立したモデルとして config.pbtxt とディレクトリ 1/ の入ったディレクトリを作成<br>(config.pbtxt は platform: “ensemble” としておく)</li><li>各ステップに相当するモデルは、それぞれ独立したモデルとして配置</li></ul><p>上記の例は、以下のイメージ図の前処理部分に相当する設定です。このように、前処理を途中で分岐させ、複数の後続処理を同時に処理させるようなことも可能です。</p><figure><img alt="パイプラインの分岐例" src="https://cdn-images-1.medium.com/max/461/0*KN4iEVCYVtCXnn86" /><figcaption>パイプラインの分岐例</figcaption></figure><p>また別の例として以下のように、途中の処理をバイパスして出力を後続の処理に渡すこともできます。</p><figure><img alt="パイプラインのバイパス例" src="https://cdn-images-1.medium.com/max/1024/0*oGvsaIDpFRDbrsl2" /><figcaption>パイプラインのバイパス例</figcaption></figure><h3>各種バックエンド</h3><p>パイプライン化の中で、前処理や後処理としての独自処理について言及していました。Triton では、一般的なフレームワークを含め、各処理系をバックエンドとして定義しています。<br>(詳細: <a href="https://github.com/triton-inference-server/backend/blob/r20.12/README.md#backends">https://github.com/triton-inference-server/backend/blob/r20.12/README.md#backends</a>)<br>この中で、独自処理を実装する際に特に重要なのが、C/C++ と Python のバックエンドです。ここでは Python バックエンドについて、少し説明をしておきます。</p><p>Python バックエンドも、基本的なデプロイの流れは他のフレームワークベースのバックエンドと同様です。</p><ol><li>config.pbtxt を記述</li><li>モデルファイルを配置</li></ol><p>大きな違いは以下のふたつです。</p><ul><li>backend: “python” とする (platform を記述してはならない)</li><li>モデルファイルとして model.py を各バージョンディレクトリの下に置く</li></ul><p>モデルファイルである model.py の書き方は公式のドキュメント (<a href="https://github.com/triton-inference-server/python_backend/tree/r20.12#usage">https://github.com/triton-inference-server/python_backend/tree/r20.12#usage</a>) を見ていただくほうが良いのですが、主に以下の仕様を満たせば、概ねなんでもできます。</p><ul><li>ファイル名は model.py にする</li><li>model.py の中に TritonPythonModel クラスを定義し、initialize / execute / finalize の三つのメソッドを定義</li><li>execute からの返却値は、入力のリストと同じ長さを保つ必要がある</li></ul><p>(余談 3: 「概ねなんでもできます」は、たとえば補助情報を得るために外部 DB への通信を走らせたり、パスを適切に通すことでモジュール化しておいたスクリプトをロードしたり、等々)<br>(余談 4: 主に custom backend 向けの機能として、config.pbtxt に独自のパラメータを定義できたりもします。これを使うと、静的な情報をリクエストに乗せなくとも、モデルに渡すことができるようになります)</p><h3>CPU のみのマシンで動かすには</h3><p>ここまでの内容 (を含む、多くの機能) は、CPU しかないマシンでも利用することができます。コンテナの起動コマンドを以下のように — gpus オプションのない形に変更し、</p><pre>docker run --rm -p8000:8000 -p8001:8001 -p8002:8002 \<br>  -v /path/to/models:/models nvcr.io/nvidia/tritonserver:20.12-py3 \<br>    tritonserver --model-repository=/models</pre><p>(詳細: <a href="https://github.com/triton-inference-server/server/blob/v2.6.0/docs/quickstart.md#run-on-cpu-only-system">https://github.com/triton-inference-server/server/blob/v2.6.0/docs/quickstart.md#run-on-cpu-only-system</a>)</p><p>instance_group を未設定 (=デフォルト) もしくは、その中の kind を以下のように KIND_CPU に変更すると、GPU のないマシンでも、Triton を利用することができます。</p><pre>instance_group [<br>  {<br>    count: 1<br>    kind: KIND_CPU<br>  }<br>]</pre><p>デバッグ用途、検証用途、CPU からの移行準備として、さまざまに活用できるのではないでしょうか。</p><h3>その他実装されている機能</h3><p>ここまででも十分長くなってしまっているのですが、実際のところ、全部を把握しきれないレベルで機能が実装されています。紹介したもの以外にも、以下のような機能が存在しています。</p><ul><li>モデル制御 API<br>デプロイされたモデルを、動的にロードしたりアンロードしたりすることができます。</li><li>ストリーミング API<br>系列データに対する、ストリーミング処理のための機構です。RNN のような、直前の状態を利用して処理するタイプのモデルで活用されます。</li><li>複数バージョンのデプロイ<br>同じモデルの異なるバージョンのものを、複数デプロイできます。クライアント側でバージョンが明示された場合、そのバージョンのモデルに対して処理が実行されます。</li><li>優先度付きリクエスト<br>リクエストキューを利用している場合など、リクエストごとに優先度を設定できます。</li><li>Shared memory<br>共有メモリを介して、リクエストを送受信できます。これにより、たとえば同一マシン上にクライアントとサーバプロセスが存在する場合、通信のオーバーヘッドを削減することができます。</li><li>組み込みライブラリ化<br>Triton のコア機能を libtritonserver.so として、独自のサーバプロセスに組み込むこともできます。</li><li>Prometheus フォーマットの Metrics<br>GPU 使用率やリクエストキューでの滞留時間など、複数の指標について、起動中に情報を取得できます。</li><li>など……</li></ul><p>これらの機能もうまく活用して、高速で効率の良い推論システムを目指しましょう！</p><h3>関連情報</h3><ul><li><a href="https://medium.com/google-cloud-jp/building-high-performance-online-prediction-system-on-gcp-12b57ca44284">GCP で構築する高性能かつスケーラブルなオンライン予測システム<br></a>(古いバージョンでの検証ですが) 1 GPU に対して負荷をかけた際に、設定を調整することでどこまで性能を出し切ることができるか、について検証した記事です。</li><li><a href="https://qiita.com/m_ogushi/items/fb9538ba24b81b57574a">TensorFlowの画像識別モデルをTensorFlow-TensorRTで推論高速化<br></a>TensorRT による最適化を、TensorFlow の内部 API として適用する方法に関する記事です。もちろん Triton への直接デプロイが可能なので、活用できるシーンは多い……はず。</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd2980514af2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/gpu-for-inference-easy-deploy-by-triton-inference-server-fd2980514af2">GPU に推論を: Triton Inference Server でかんたんデプロイ</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[秋の #GTC20 セッション紹介 (実サービスでの活用例など)]]></title>
            <link>https://medium.com/nvidiajapan/gtc20fall-session-intro-on-service-usecases-96c7fc0bde41?source=rss-f8c9d9365fc7------2</link>
            <guid isPermaLink="false">https://medium.com/p/96c7fc0bde41</guid>
            <category><![CDATA[japanese]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[nvidia]]></category>
            <dc:creator><![CDATA[Kazuhiro Yamasaki]]></dc:creator>
            <pubDate>Thu, 12 Nov 2020 06:30:41 GMT</pubDate>
            <atom:updated>2020-11-12T06:30:41.741Z</atom:updated>
            <content:encoded><![CDATA[<p>はじめましての方もそうでない方も、こんにちは。エヌビディアでディープラーニング ソリューションアーキテクトをしております、山崎と申します。今日は、先月 10 月に開催されました秋の GTC について、&lt;s&gt; 独断と偏見で選んだ &lt;/s&gt; いくつかのセッションについてご紹介できればと思います。</p><h3><strong>(内容に入る前に……) 「秋の」GTC とは？</strong></h3><p>そもそも GTC というのは、毎年 GPU Technology Conference という名称で開催されている、GPU にまつわる技術カンファレンスです。例年、3 月ごろにサンノゼで開催されたのち、夏から秋にかけて世界の各地域で、固有のトピックを取り上げる形の地域別カンファレンスが開催されていました。しかし今年は世界を取り巻く情勢を反映し、各地域別の GTC が行われない代わりに、全世界で一斉にオンライン開催することになり、これが「秋の」GTC というわけです。イベントページは <a href="https://www.nvidia.com/ja-jp/gtc/">https://www.nvidia.com/ja-jp/gtc/</a> です。なお余談ですが、次の春に予定されている GTC の発表受付も、実はすでに始まっていたりします ( <a href="https://www.nvidia.com/en-us/gtc/call-for-submissions/">https://www.nvidia.com/en-us/gtc/call-for-submissions/</a>)。例年より募集期間が短いのがネックではありますが、気になる方はチェックしてみてください！</p><p>……閑話休題。</p><p>さて今回、秋の GTC では、日本だけで 180 以上のセッションが、世界全体ではのべ 1200 以上ものセッションが実施され、GTC に参加されなかった方向けにも、まもなく資料やレコーディングが公開されます。セッション一覧は、<a href="https://www.nvidia.com/ja-jp/gtc/session-catalog/">https://www.nvidia.com/ja-jp/gtc/session-catalog/</a> からご確認いただけます。</p><p>ここまで多くのセッションがあると、そのすべてを網羅するのはなかなか骨が折れる作業になります。ということでこの記事では、ピックアップした 4 つのセッションについてご紹介したいと思います。(注: なぜか permalink が存在しないので、もしかすると各セッションへのリンクが切れていることがあるかもしれません。その場合、お手数ですがご一報いただけますと大変ありがたいです。)</p><h3>4500 社に SaaS として提供している機械翻訳サービスのオンプレミス GPU 基盤の裏側 [A21782]</h3><p><a href="https://www.nvidia.com/ja-jp/gtc/session-catalog/?search=A21782">https://www.nvidia.com/ja-jp/gtc/session-catalog/?search=A21782</a></p><p>ひとつめのセッションは、株式会社ロゼッタの木村様より、実サービスに GPU を組み込む際の裏側について、これまでのご経験をもとに、お話しいただきました。特に、オンプレミスで GPU を搭載するサーバを運用するにあたり、どういったことに注意すべきなのか、また、なぜクラウドを利用していないのか、ということについて、詳細にご紹介いただいています。</p><p>これからサービスを拡大しようと考えられている方などに、おすすめのセッションです。</p><h3>インターネットサービスにおけるユーザー投稿に対する大規模フィルタリングモデルの学習 [A21804]</h3><p><a href="https://www.nvidia.com/ja-jp/gtc/session-catalog/?search=A21804">https://www.nvidia.com/ja-jp/gtc/session-catalog/?search=A21804</a></p><p>続いてふたつめ、ヤフー株式会社の清水様より、Yahoo! 知恵袋などで活用されている、深層学習ベースの言語モデルなどについて、ご説明いただきました。すでにブログ等の記事でも解説されていますが、Deep Structured Semantic Model (DSSM) というモデルを、どのように文書分類的なタスクなどへ活用しているのか、といった事例や、位置情報解析への LSTM の応用について、解説していただきました。</p><p>実サービスで利用されている言語処理モデルの、最新の状況が気になる方などに、おすすめのセッションです。</p><h3>Kubernetes-based GPU as a Service Platform by using Open Source Software [A21807]</h3><p><a href="https://www.nvidia.com/ja-jp/gtc/session-catalog/?search=A21807">https://www.nvidia.com/ja-jp/gtc/session-catalog/?search=A21807</a></p><p>みっつめのセッションは、株式会社サイバーエージェントの青山様と李様より、社内の開発者向け GPU 基盤をどのように構築しているのかについて、ご紹介いただきました。特に、Kubernetes をはじめとする、各種 OSS を軸に、いかにユーザにとって利用しやすい環境を構築していくのか、という点について、ご説明いただいています。</p><p>オンプレミスの環境とクラウドの環境を上手に連携させたい、という方に、おすすめのセッションです。</p><h3>Japanese Language Analysis by GPU Ready Open Source NLP Frameworks [A21887]</h3><p><a href="https://www.nvidia.com/ja-jp/gtc/session-catalog/?search=A21887">https://www.nvidia.com/ja-jp/gtc/session-catalog/?search=A21887</a></p><p>最後のセッションは少し毛色を変えて、日本語における言語解析について、株式会社リクルート Megagon Labs の松田様よりご紹介いただきました。GiNZA や spaCy、Stanza のような、日本語解析に利用可能な OSS フレームワークについてご紹介いただき、同時に、GPU の有効化方法なども合わせてご説明いただいています。また、商用利用可能な形式に整備された日本語の Universal Dependencies データセットなどについても、ご説明いただいています。</p><p>日本語の言語処理に深層学習を適用したいという方などに、おすすめのセッションです。</p><h3>まとめ</h3><p>いかがでしたか？この他にも多くのセッションがありますので、ぜひ一度、<a href="https://www.nvidia.com/ja-jp/gtc/session-catalog/">セッション一覧</a>をチェックしていただければと思います！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96c7fc0bde41" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nvidiajapan/gtc20fall-session-intro-on-service-usecases-96c7fc0bde41">秋の #GTC20 セッション紹介 (実サービスでの活用例など)</a> was originally published in <a href="https://medium.com/nvidiajapan">NVIDIA Japan</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>