モデルのサービング


Red Hat OpenShift AI Self-Managed 2.16

Red Hat OpenShift AI Self-Managed でモデルを提供する

概要

Red Hat OpenShift AI Self-Managed でモデルを提供します。トレーニングされたモデルを提供すると、それらをテストしてインテリジェントなアプリケーションに実装できるようになります。

第1章 モデルサービングについて

Red Hat OpenShift AI でトレーニングされたモデルを提供するということは、モデルを OpenShift クラスターにデプロイしてテストし、インテリジェントなアプリケーションに統合することを意味します。モデルをデプロイすると、API を使用してアクセスできるサービスとして利用可能になります。これにより、API 呼び出しを通じて提供したデータ入力に基づいて、予測を返すことができます。このプロセスはモデル 推論 として知られています。OpenShift AI でモデルを提供すると、デプロイされたモデルに対してアクセスできる推論エンドポイントが、ダッシュボードに表示されます。

OpenShift AI は、次のモデルサービングプラットフォームを提供しています。

シングルモデルサービングプラットフォーム
OpenShift AI には、大規模言語モデル (LLM) などの大規模モデルをデプロイするために、KServe コンポーネントをベースとした シングルモデルサービングプラットフォーム が組み込まれています。各モデルが独自のモデルサーバーからデプロイされるため、シングルモデルサービングプラットフォームは、多くのリソースを必要とする大規模なモデルのデプロイ、監視、スケーリング、および保守に役立ちます。
マルチモデルサービングプラットフォーム
OpenShift AI には、小規模および中規模のモデルをデプロイするために、ModelMesh コンポーネントをベースとした マルチモデルサービングプラットフォーム が組み込まれています。マルチモデルサービングプラットフォームでは、同じモデルサーバーに複数のモデルをデプロイできます。デプロイされた各モデルはサーバーリソースを共有します。このアプローチは、有限のコンピュートリソースまたは Pod を持つ OpenShift クラスターで有利です。

第2章 中小規模のモデルの提供

OpenShift AI には、小規模および中規模のモデルをデプロイするために、ModelMesh コンポーネントをベースとした マルチモデルサービングプラットフォーム が組み込まれています。マルチモデルサービングプラットフォームでは、複数のモデルを同じモデルサーバーからデプロイし、サーバーリソースを共有できます。

2.1. モデルサーバーの設定

2.1.1. マルチモデルサービングプラットフォームの有効化

マルチモデルサービングプラットフォームを使用するには、まずプラットフォームを有効にする必要があります。

前提条件

  • OpenShift AI 管理者権限を持つユーザーとして OpenShift AI にログインしている。
  • クラスター管理者は、OpenShift AI ダッシュボード設定を編集して ModelMesh コンポーネントを使用するマルチモデルサービングプラットフォームを選択する機能を無効に していない。詳細は、ダッシュボード設定オプション を参照してください。

手順

  1. OpenShift AI ダッシュボードの左側のメニューで、SettingsCluster settings をクリックします。
  2. Model serving platforms セクションを見つけます。
  3. Multi-model serving platform チェックボックスをオンにします。
  4. Save changes をクリックします。

2.1.2. マルチモデルサービングプラットフォーム用のカスタムモデルサービングランタイムの追加

モデルサービングランタイムは、特定のモデルフレームワーク群のサポートと、それらのフレームワークでサポートされるモデル形式のサポートを追加します。デフォルトでは、マルチモデルサービングプラットフォームには OpenVINO Model Server ランタイムが含まれています。デフォルトのランタイムがニーズ (特定のモデル形式のサポートなど) を満たしていない場合は、独自のカスタムランタイムを追加することもできます。

管理者は、Red Hat OpenShift AI ダッシュボードを使用して、カスタムのモデルサービングランタイムを追加して有効にすることができます。その後、マルチモデルサービングプラットフォーム用の新しいモデルサーバーを作成する際に、カスタムランタイムを選択できます。

注記

Red Hat はカスタムランタイムのサポートを提供しません。追加したカスタムランタイムを使用するライセンスがあることを確認し、お客様の責任で正しく設定および保守するようにしてください。

前提条件

  • OpenShift AI 管理者権限を持つユーザーとして OpenShift AI にログインしている。
  • プロジェクトにモデルサーバーを追加する 方法を理解している。カスタムのモデルサービングランタイムを追加した場合は、そのランタイムを使用するように新しいモデルサーバーを設定する必要があります。
  • kserve/modelmesh-serving リポジトリー内のサンプルランタイムを確認している。これらの例を開始点として使用できます。ただし、各ランタイムを OpenShift AI にデプロイするには、さらにいくつかの変更が必要です。必要な変更は、次の手順で説明します。

    注記

    OpenShift AI には、デフォルトで OpenVINO Model Server ランタイムが含まれています。このランタイムを OpenShift AI に追加する必要はありません。

手順

  1. OpenShift AI ダッシュボードから、Settings > Serving runtimes をクリックします。

    Serving runtimes ページが開き、すでにインストールされ有効になっているモデルサービングランタイムが表示されます。

  2. カスタムランタイムを追加するには、次のオプションのいずれかを選択します。

    • 既存のランタイム (OpenVINO Model Server ランタイムなど) で開始するには、既存のランタイムの横にあるアクションメニュー (⋮) をクリックしてから、Duplicate をクリックします。
    • 新しいカスタムランタイムを追加するには、Add serving runtime をクリックします。
  3. Select the model serving platforms this runtime supports リストで、Multi-model serving platform を選択します。

    注記

    マルチモデルサービングプラットフォームは、REST プロトコルのみサポートします。つまり、Select the API protocol this runtime supports リスト内のデフォルト値は変更できません。

  4. オプション: (既存のランタイムを複製するのではなく) 新しいランタイムを開始した場合は、次のオプションのいずれかを選択してコードを追加します。

    • YAML ファイルをアップロードする

      1. Upload files をクリックします。
      2. ファイルブラウザーで、コンピューター上の YAML ファイルを選択します。このファイルは、kserve/modelmesh-serving リポジトリーからダウンロードしたサンプルランタイムの 1 つである可能性があります。

        埋め込み YAML エディターが開き、アップロードしたファイルの内容が表示されます。

    • エディターに YAML コードを直接入力する

      1. Start from scratch をクリックします。
      2. 埋め込みエディターに YAML コードを直接入力または貼り付けます。貼り付ける YAML は、kserve/modelmesh-serving リポジトリー内のサンプルランタイムの 1 つからコピーされる場合があります。
  5. オプション: kserve/modelmesh-serving リポジトリーにサンプルランタイムの 1 つを追加する場合は、次の変更を実行します。

    1. YAML エディターで、ランタイムの kind フィールドを見つけます。このフィールドの値を ServingRuntime に更新します。
    2. kserve/modelmesh-serving リポジトリーの kustomization.yaml ファイルで、追加するランタイムの newNamenewTag の値をメモします。これらの値は後の手順で指定します。
    3. カスタムランタイムの YAML エディターで、containers.image フィールドを見つけます。
    4. kustomization.yaml ファイルで前にメモした値に基づいて、containers.image フィールドの値を newName:newTag 形式で更新します。以下に例を示します。

      Nvidia Triton Inference Server
      image: nvcr.io/nvidia/tritonserver:23.04-py3
      Seldon Python MLServer
      image: seldonio/mlserver:1.3.2
      TorchServe
      image: pytorch/torchserve:0.7.1-cpu
  6. metadata.name フィールドで、追加するランタイムの値が一意であることを確認します (つまり、その値がすでに追加したランタイムと一致しないこと)。
  7. オプション: 追加するランタイムのカスタム表示名を設定するには、次の例に示すように、metadata.annotations.openshift.io/display-name フィールドを追加し、値を指定します。

    apiVersion: serving.kserve.io/v1alpha1
    kind: ServingRuntime
    metadata:
      name: mlserver-0.x
      annotations:
        openshift.io/display-name: MLServer
    注記

    ランタイムのカスタム表示名を設定しないと、OpenShift AI には metadata.name フィールドの値が表示されます。

  8. Add をクリックします。

    Serving runtimes ページが開き、インストールされているランタイムの更新されたリストが表示されます。追加したランタイムが自動的に有効になることを確認します。

  9. オプション: カスタムランタイムを編集するには、アクションメニュー (⋮) をクリックし、Edit を選択します。

検証

  • 追加したカスタムモデルサービングランタイムは、Serving runtimes ページに有効な状態で表示されます。

関連情報

2.1.3. マルチモデルサービングプラットフォームへのテスト済みおよび検証済みのモデルサービングランタイムの追加

プリインストールされたカスタムのモデルサービングランタイムに加えて、NVIDIA Triton Inference Server などの Red Hat でテストおよび検証されたモデルサービングランタイムを使用して要件に対応することもできます。Red Hat のテスト済みおよび検証済みのランタイムの詳細は、Red Hat OpenShift AI のテスト済みおよび検証済みのランタイム を参照してください。

Red Hat OpenShift AI ダッシュボードを使用して、NVIDIA Triton Inference Server ランタイムを追加して有効にし、マルチモデルサービングプラットフォーム用の新しいモデルサーバーを作成するときにランタイムを選択できます。

前提条件

  • OpenShift AI 管理者権限を持つユーザーとして OpenShift AI にログインしている。
  • プロジェクトにモデルサーバーを追加する 方法を理解している。テストおよび検証済みのモデルサービングランタイムを追加したら、そのランタイムを使用するように新しいモデルサーバーを設定する必要があります。

手順

  1. OpenShift AI ダッシュボードから、Settings > Serving runtimes をクリックします。

    Serving runtimes ページが開き、すでにインストールされ有効になっているモデルサービングランタイムが表示されます。

  2. テスト済みおよび検証済みのランタイムを追加するには、Add serving runtime をクリックします。
  3. Select the model serving platforms this runtime supports リストで、Multi-model serving platform を選択します。

    注記

    マルチモデルサービングプラットフォームは、REST プロトコルのみサポートします。つまり、Select the API protocol this runtime supports リスト内のデフォルト値は変更できません。

  4. Start from scratch をクリックします。
  5. 次の YAML コードを埋め込みエディターに直接入力または貼り付けます。

    apiVersion: serving.kserve.io/v1alpha1
    kind: ServingRuntime
    metadata:
      annotations:
        enable-route: "true"
      name: modelmesh-triton
      labels:
        opendatahub.io/dashboard: "true"
    spec:
      annotations:
        opendatahub.io/modelServingSupport: '["multi"x`x`]'
        prometheus.kserve.io/path: /metrics
        prometheus.kserve.io/port: "8002"
      builtInAdapter:
        env:
          - name: CONTAINER_MEM_REQ_BYTES
            value: "268435456"
          - name: USE_EMBEDDED_PULLER
            value: "true"
        memBufferBytes: 134217728
        modelLoadingTimeoutMillis: 90000
        runtimeManagementPort: 8001
        serverType: triton
      containers:
        - args:
            - -c
            - 'mkdir -p /models/_triton_models;  chmod 777
              /models/_triton_models;  exec
              tritonserver "--model-repository=/models/_triton_models" "--model-control-mode=explicit" "--strict-model-config=false" "--strict-readiness=false" "--allow-http=true" "--allow-grpc=true"  '
          command:
            - /bin/sh
          image: nvcr.io/nvidia/tritonserver@sha256:xxxxx
          name: triton
          resources:
            limits:
              cpu: "1"
              memory: 2Gi
            requests:
              cpu: "1"
              memory: 2Gi
      grpcDataEndpoint: port:8001
      grpcEndpoint: port:8085
      multiModel: true
      protocolVersions:
        - grpc-v2
        - v2
      supportedModelFormats:
        - autoSelect: true
          name: onnx
          version: "1"
        - autoSelect: true
          name: pytorch
          version: "1"
        - autoSelect: true
          name: tensorflow
          version: "1"
        - autoSelect: true
          name: tensorflow
          version: "2"
        - autoSelect: true
          name: tensorrt
          version: "7"
        - autoSelect: false
          name: xgboost
          version: "1"
        - autoSelect: true
          name: python
          version: "1"
  6. metadata.name フィールドで、追加するランタイムの値が、すでに追加されているランタイムと一致していないことを確認してください。
  7. オプション: 追加するランタイムのカスタム表示名を使用するには、次の例に示すように、metadata.annotations.openshift.io/display-name フィールドを追加し、値を指定します。

    apiVersion: serving.kserve.io/v1alpha1
    kind: ServingRuntime
    metadata:
      name: modelmesh-triton
      annotations:
        openshift.io/display-name: Triton ServingRuntime
    注記

    ランタイムのカスタム表示名を設定しないと、OpenShift AI には metadata.name フィールドの値が表示されます。

  8. Create をクリックします。

    Serving runtimes ページが開き、インストールされているランタイムの更新されたリストが表示されます。追加したランタイムが自動的に有効になることを確認します。

  9. オプション: ランタイムを編集するには、アクションメニュー (⋮) をクリックし、Edit を選択します。

検証

  • 追加したモデルサービスランタイムは、Serving runtimes ページに有効な状態で表示されます。

関連情報

2.1.4. マルチモデルサービングプラットフォーム用のモデルサーバーの追加

マルチモデルサービングプラットフォームを有効にした場合は、モデルをデプロイするようにモデルサーバーを設定する必要があります。大規模なデータセットを使用するために追加のコンピューティング能力が必要な場合は、モデルサーバーにアクセラレーターを割り当てることができます。

注記

OpenShift AI 2.15 では、Red Hat はモデルサービング用に NVIDIA GPU アクセラレーターのみをサポートしています。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用する場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • モデルサーバーを追加できるデータサイエンスプロジェクトを作成している。
  • マルチモデルサービングプラットフォームを有効化している。
  • モデルサーバーにカスタムのモデルサービングランタイムを使用する場合は、ランタイムを追加して有効にしている。カスタムモデルサービングランタイムの追加 を参照してください。
  • モデルサーバーでグラフィックスプロセッシングユニット (GPU) を使用する場合は、OpenShift AI で GPU サポートを有効にしている。NVIDIA GPU の有効化 を参照してください。

手順

  1. OpenShift AI ダッシュボードの左側のメニューで、Data Science Projects をクリックします。

    Data Science Projects ページが開きます。

  2. モデルサーバーを設定するプロジェクトの名前をクリックします。

    プロジェクトの詳細ページが開きます。

  3. Models タブをクリックします。
  4. 次のいずれかの操作を実行します。

    • ​Multi-model serving platform タイルが表示された場合は、タイル上の Add model server をクリックします。
    • タイルが表示されない場合は、Add model server ボタンをクリックします。

    Add model server ダイアログが開きます。

  5. Model server name フィールドに、モデルサーバーの一意の名前を入力します。
  6. Serving runtime リストから、OpenShift AI デプロイメントにインストールされ有効になっているモデルサービングランタイムを選択します。

    注記

    モデルサーバーで カスタム モデルサービングランタイムを使用していて、GPU を使用したい場合は、カスタムランタイムが GPU をサポートし、GPU を使用するように適切に設定されていることを確認する必要があります。

  7. Number of model replicas to deploy フィールドに値を指定します。
  8. Model server size リストから値を選択します。
  9. オプション: 前の手順で Custom を選択した場合は、Model server size セクションで次を設定して、モデルサーバーをカスタマイズします。

    1. CPUs requested フィールドで、モデルサーバーで使用する CPU の数を指定します。このフィールドの横にあるリストを使用して、値をコアまたはミリコアで指定します。
    2. CPU limit フィールドに、モデルサーバーで使用する CPU の最大数を指定します。このフィールドの横にあるリストを使用して、値をコアまたはミリコアで指定します。
    3. Memory requested フィールドに、モデルサーバーに要求されたメモリーをギビバイト (Gi) 単位で指定します。
    4. Memory limit フィールドに、モデルサーバーの最大メモリー制限をギビバイト (Gi) 単位で指定します。
  10. オプション: Accelerator リストからアクセラレーターを選択します。

    1. 前述の手順でアクセラレーターを選択した場合は、使用するアクセラレーターの数を指定します。
  11. オプション: Model route セクションで、Make deployed models available through an external route チェックボックスをオンにして、デプロイされたモデルを外部クライアントが利用できるようにします。
  12. オプション: Token authorization セクションで、Require token authentication チェックボックスをオンにして、モデルサーバーにトークン認証を要求します。トークン認証の設定を完了するには、次のアクションを実行します。

    1. Service account name フィールドに、トークンが生成されるサービスアカウント名を入力します。生成されたトークンは、モデルサーバーの設定時に作成され、Token secret フィールドに表示されます。
    2. 追加のサービスアカウントを追加するには、Add a service account をクリックし、別のサービスアカウント名を入力します。
  13. Add をクリックします。

    • 設定したモデルサーバーは、プロジェクトの Models タブの Models and model servers リストに表示されます。
  14. オプション: モデルサーバーを更新するには、モデルサーバーの横にあるアクションメニュー () をクリックし、Edit model server を選択します。

2.1.5. モデルサーバーの削除

モデルをホストするためにモデルサーバーが必要なくなった場合は、データサイエンスプロジェクトからモデルサーバーを削除できます。

注記

モデルサーバーを削除すると、そのモデルサーバーでホストされているモデルも削除されます。その結果、アプリケーションはモデルを利用できなくります。

前提条件

  • データサイエンスプロジェクトと関連するモデルサーバーを作成している。
  • モデルにアクセスするアプリケーションのユーザーに、モデルが利用できなくなることを通知している。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。

手順

  1. OpenShift AI ダッシュボードで、Data Science Projects をクリックします。

    Data Science Projects ページが開きます。

  2. モデルサーバーを削除するプロジェクトの名前をクリックします。

    プロジェクトの詳細ページが開きます。

  3. Models タブをクリックします。
  4. モデルサーバーを削除するプロジェクトの横にあるアクションメニュー () をクリックし、Delete model server をクリックします。

    Delete model server ダイアログが開きます。

  5. テキストフィールドにモデルサーバーの名前を入力して、削除することを確認します。
  6. Delete model server をクリックします。

検証

  • 削除したモデルサーバーは、プロジェクトの Models タブに表示されなくなります。

2.2. プロイされたモデルの使用

2.2.1. マルチモデルサービングプラットフォームを使用したモデルのデプロイ

OpenShift AI にトレーニングされたモデルをデプロイし、それらをテストしてインテリジェントなアプリケーションに実装できます。モデルをデプロイすると、API を使用してアクセスできるサービスとして利用可能になります。これにより、データ入力に基づく予測を返すことができます。

マルチモデルサービングプラットフォームを有効にすると、プラットフォーム上にモデルをデプロイできます。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループ、または、管理者グループ (rhoai-users など) に属している。
  • マルチモデルサービングプラットフォームを有効化している。
  • データサイエンスプロジェクトを作成し、モデルサーバーを追加している。
  • S3 互換オブジェクトストレージにアクセスできる。
  • デプロイするモデルについて、S3 互換オブジェクトストレージバケット内の関連フォルダーパスを把握している。

手順

  1. OpenShift AI ダッシュボードの左側のメニューで、Data Science Projects をクリックします。

    Data Science Projects ページが開きます。

  2. モデルをデプロイするプロジェクトの名前をクリックします。

    プロジェクトの詳細ページが開きます。

  3. Models タブをクリックします。
  4. Deploy model をクリックします。
  5. モデルをデプロイするためのプロパティーを次のように設定します。

    1. Model name フィールドに、デプロイするモデルの一意の名前を入力します。
    2. Model framework リストから、モデルのフレームワークを選択します。

      注記

      Model framework リストには、モデルサーバーの設定時に指定したモデルサービングランタイムによってサポートされるフレームワークのみが表示されます。

    3. S3 互換オブジェクトストレージからデプロイするモデルの場所を指定するには、次の一連のアクションのいずれかを実行します。

      • 既存の接続を使用するには

        1. Existing connection を選択します。
        2. Name リストから、以前に定義したデータ接続を選択します。
        3. Path フィールドに、指定したデータソース内のモデルを含むフォルダーパスを入力します。
      • 新しい接続を使用するには

        1. モデルがアクセスできる新しいコネクションを定義するには、New connection を選択します。
        2. Name フィールドに、接続の一意の名前を入力します。
        3. Access key フィールドに、S3 互換オブジェクトストレージプロバイダーのアクセスキー ID を入力します。
        4. Secret key フィールドに、指定した S3 互換オブジェクトストレージアカウントのシークレットアクセスキーを入力します。
        5. Endpoint フィールドに、S3 互換オブジェクトストレージバケットのエンドポイントを入力します。
        6. Region フィールドに、S3 互換オブジェクトストレージアカウントのデフォルトのリージョンを入力します。
        7. Bucket フィールドに、S3 互換のオブジェクトストレージバケットの名前を入力します。
        8. Path フィールドに、データファイルが含まれる S3 互換オブジェクトストレージ内のフォルダーパスを入力します。
    4. Deploy をクリックします。

検証

  • デプロイされたモデルがプロジェクトの Models タブに表示され、ダッシュボードの Model Serving ページで Status 列にチェックマークが付いて表示されていることを確認します。

2.2.2. デプロイされたモデルの表示

作業の結果を分析するために、Red Hat OpenShift AI にデプロイされたモデルのリストを表示できます。デプロイされたモデルとそのエンドポイントの現在のステータスも表示できます。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。

手順

  1. OpenShift AI ダッシュボードで、Model Serving をクリックします。

    Deployed models ページが開きます。

    このページには、モデルごとに、モデル名、モデルがデプロイされているプロジェクト、モデルが使用するモデルサービングランタイム、デプロイメントステータスなどの詳細が表示されます。

  2. オプション: 特定のモデルの場合は、Inference endpoint 列のリンクをクリックして、デプロイされたモデルの推論エンドポイントを表示します。

検証

  • 以前にデプロイされたデータサイエンスモデルのリストが、Deployed models ページに表示されます。

2.2.3. デプロイされたモデルのデプロイメントプロパティーの更新

以前にデプロイされたモデルのデプロイメントプロパティーを更新できます。たとえば、モデルの接続と名前を変更できます。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • OpenShift AI にモデルをデプロイしている。

手順

  1. OpenShift AI ダッシュボードで、Model Serving をクリックします。

    Deployed models ページが開きます。

  2. 更新するデプロイメントプロパティーを持つモデルの横にあるアクションメニュー () をクリックし、Edit をクリックします。

    Edit model ダイアログが開きます。

  3. 次のようにモデルのデプロイメントプロパティーを更新します。

    1. Model name フィールドに、モデルの新しい一意の名前を入力します。
    2. Model servers リストから、モデルのモデルサーバーを選択します。
    3. Model framework リストから、モデルのフレームワークを選択します。

      注記

      Model framework リストには、モデルサーバーの設定時に指定したモデルサービングランタイムによってサポートされるフレームワークのみが表示されます。

    4. モデルの場所の指定方法を更新するには、次の一連のアクションのいずれかを実行します。

      • 既存の接続を指定した場合

        1. Path フィールドで、指定したデータソース内のモデルを含むフォルダーパスを更新します。
      • 以前に新しい接続を指定した場合

        1. Name フィールドで、データ接続の一意の名前を更新します。
        2. Access key フィールドで、S3 互換オブジェクトストレージプロバイダーのアクセスキー ID を更新します。
        3. Secret key フィールドで、指定した S3 互換オブジェクトストレージアカウントのシークレットアクセスキーを更新します。
        4. Endpoint フィールドで、S3 互換オブジェクトストレージバケットのエンドポイントを更新します。
        5. Region フィールドで、S3 互換オブジェクトストレージアカウントのデフォルトのリージョンを更新します。
        6. Bucket フィールドで、S3 互換オブジェクトストレージバケットの名前を更新します。
        7. Path フィールドで、データファイルを含む S3 互換オブジェクトストレージ内のフォルダーパスを更新します。
    5. Redeploy をクリックします。

検証

  • デプロイメントプロパティーを更新したモデルは、ダッシュボードの Model Serving ページに表示されます。

2.2.4. デプロイされたモデルの削除

以前にデプロイしたモデルを削除できます。これにより、不要になったデプロイ済みのモデルを削除できます。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • モデルをデプロイしている。

手順

  1. OpenShift AI ダッシュボードで、Model serving をクリックします。

    Deployed models ページが開きます。

  2. 削除するデプロイモデルの横にあるアクションメニュー () をクリックし、Delete をクリックします。

    Delete deployed model ダイアログが開きます。

  3. テキストフィールドにデプロイしたモデルの名前を入力し、削除することを確認します。
  4. Delete deployed model をクリックします。

検証

  • 削除したモデルは、Deployed models ページに表示されなくなります。

2.3. マルチモデルサービングプラットフォームのモニタリング設定

マルチモデルサービングプラットフォームには、ModelMesh コンポーネントのモデルおよびモデルサーバーメトリクスが含まれています。ModelMesh は独自のメトリクスセットを生成し、それらの提供に基盤となるモデルサービングランタイムに依存しません。ModelMesh が生成するメトリクスのセットには、モデルリクエスト率とタイミング、モデルのロード率とアンロード率、時間とサイズ、内部キューイング遅延、容量と使用率、キャッシュ状態、最近最も使用されていないモデルのメトリクスが含まれます。詳細は、ModelMesh メトリクス を参照してください。

監視を設定したら、ModelMesh コンポーネントのメトリクスを表示できます。

前提条件

  • OpenShift クラスターのクラスター管理者権限を持っている。
  • OpenShift コマンドラインインターフェイス (CLI) がダウンロードおよびインストールされている。OpenShift CLI のインストール を参照してください。
  • ユーザー定義ワークフローの監視に使用する config map の作成 について理解している。この手順でも同様のステップを実行します。
  • OpenShift でユーザー定義プロジェクトの モニタリングを有効にする方法 について理解している。この手順でも同様のステップを実行します。
  • メトリクスを監視するユーザーに、monitoring-rules-view ロールを 割り当て ている。

手順

  1. ターミナルウィンドウで、クラスター管理者として OpenShift クラスターにまだログインしていない場合は、次の例に示すように OpenShift CLI にログインします。

    $ oc login <openshift_cluster_url> -u <admin_username> -p <password>
  2. uwm-cm-conf.yaml という YAML ファイルに次の内容の ConfigMap オブジェクトを定義します。

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: user-workload-monitoring-config
      namespace: openshift-user-workload-monitoring
    data:
      config.yaml: |
        prometheus:
          logLevel: debug
          retention: 15d

    user-workload-monitoring-config オブジェクトは、ユーザー定義プロジェクトを監視するコンポーネントを設定します。保持時間が推奨値の 15 日に設定されていることを確認します。

  3. 設定を適用して user-workload-monitoring-config オブジェクトを作成します。

    $ oc apply -f uwm-cm-conf.yaml
  4. uwm-cm-enable.yaml という YAML ファイルに、次の内容で、別の ConfigMap オブジェクトを定義します。

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: cluster-monitoring-config
      namespace: openshift-monitoring
    data:
      config.yaml: |
        enableUserWorkload: true

    cluster-monitoring-config オブジェクトを使用して、ユーザー定義プロジェクトの監視を有効にします。

  5. 設定を適用して、cluster-monitoring-config オブジェクトを作成します。

    $ oc apply -f uwm-cm-enable.yaml

2.4. マルチモデルサービングプラットフォームのモデルサービングランタイムメトリクスの表示

クラスター管理者がマルチモデルサービングプラットフォームの監視を設定すると、管理者以外のユーザーは OpenShift Web コンソールを使用して、ModelMesh コンポーネントのモデルサービングランタイムメトリクスを表示できます。

前提条件

手順

  1. OpenShift Web コンソールにログインします。
  2. Developer パースペクティブに切り替えます。
  3. 左側のメニューで、Observe をクリックします。
  4. プロジェクトメトリクスのモニタリング で説明されているように、Web コンソールを使用して modelmesh_* メトリクスのクエリーを実行します。

2.5. モデルのパフォーマンスのモニタリング

マルチモデルサービングプラットフォームでは、モデルサーバーにデプロイされたすべてのモデルと、モデルサーバーにデプロイされた特定のモデルのパフォーマンスメトリクスを表示できます。

2.5.1. モデルサーバー上のすべてのモデルのパフォーマンスメトリクスの表示

モデルサーバーにデプロイされているすべてのモデルについて、次のメトリクスを監視できます。

  • 5 分あたりの HTTP リクエスト数 - サーバー上のすべてのモデルに対して失敗または成功した HTTP リクエストの数。
  • 平均応答時間 (ミリ秒) - サーバー上のすべてのモデルについて、モデルサーバーがリクエストに応答するのにかかる平均時間。
  • CPU 使用率 (%) - サーバー上のすべてのモデルで現在使用されている CPU 容量の割合。
  • メモリー使用率 (%) - サーバー上のすべてのモデルで現在使用されているシステムメモリーの割合。

これらのメトリクスの時間範囲と更新間隔を指定すると、使用量のピーク時間帯や、指定した時間におけるモデルのパフォーマンスなどを判断するのに役立ちます。

前提条件

  • Red Hat OpenShift AI がインストール済みである。
  • OpenShift AI がインストールされている OpenShift クラスターで、ユーザーのワークロードモニタリングが有効化されている。
  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • マルチモデルサービングプラットフォームにモデルがデプロイされている。

手順

  1. OpenShift AI ダッシュボードのナビゲーションメニューから、Data Science Projects をクリックします。

    Data Science Projects ページが開きます。

  2. 監視するデータサイエンスモデルが含まれているプロジェクトの名前をクリックします。
  3. プロジェクトの詳細ページで、Models タブをクリックします。
  4. 関心のあるモデルサーバーの行で、アクションメニュー (⋮) をクリックしてから、View model server metrics を選択します。
  5. オプション: モデルサーバーのメトリクスページで、次のオプションを設定します。

    • 時間範囲 - メトリクスを追跡する期間を指定します。1 時間、24 時間、7 日、30 日のいずれかの値を選択できます。
    • 更新間隔 - (最新のデータを表示するために) メトリクスページのグラフを更新する頻度を指定します。15 秒、30 秒、1 分、5 分、15 分、30 分、1 時間、2 時間、1 日の値のいずれかを選択できます。
  6. 下にスクロールすると、5 分あたりの HTTP リクエスト、平均応答時間、CPU 使用率、メモリー使用率のデータグラフが表示されます。

検証

モデルサーバーのメトリクスページでは、グラフによってパフォーマンスメトリクスに関するデータが提供されます。

2.5.2. デプロイされたモデルの HTTP リクエストメトリクスの表示

マルチモデルサービングプラットフォームにデプロイされている特定のモデルに対し、失敗または成功した HTTP リクエストを示すグラフを表示できます。

前提条件

  • Red Hat OpenShift AI がインストール済みである。
  • OpenShift AI がインストールされている OpenShift クラスターで、ユーザーのワークロードモニタリングが有効化されている。
  • 次のダッシュボード設定オプションは、次のようにデフォルト値に設定されている。

    disablePerformanceMetrics:false
    disableKServeMetrics:false

    詳細は、ダッシュボード設定オプション を参照してください。

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • マルチモデルサービングプラットフォームにモデルがデプロイされている。

手順

  1. OpenShift AI ダッシュボードのナビゲーションメニューから、Model Serving を選択します。
  2. Deployed models ページで、モデルを選択します。
  3. オプション: Endpoint performance タブで、次のオプションを設定します。

    • 時間範囲 - メトリクスを追跡する期間を指定します。1 時間、24 時間、7 日、30 日のいずれかの値を選択できます。
    • 更新間隔 - (最新のデータを表示するために) メトリクスページのグラフを更新する頻度を指定します。15 秒、30 秒、1 分、5 分、15 分、30 分、1 時間、2 時間、1 日の値のいずれかを選択できます。

検証

Endpoint performance タブには、モデルの HTTP メトリクスのグラフが表示されます。

第3章 大規模モデルのサービング

Red Hat OpenShift AI には、大規模言語モデル (LLM) などの大規模モデルをデプロイするために、KServe コンポーネントをベースとした シングルモデルサービングプラットフォーム が組み込まれています。各モデルが独自のモデルサーバーからデプロイされるため、シングルモデルサービングプラットフォームは、多くのリソースを必要とする大規模なモデルのデプロイ、監視、スケーリング、および保守に役立ちます。

3.1. シングルモデルサービングプラットフォームについて

OpenShift AI には、大規模言語モデル (LLM) などの大規模モデルをデプロイするために、KServe コンポーネントをベースとしたシングルモデルサービングプラットフォームが組み込まれています。各モデルが独自のモデルサーバー上にデプロイされるため、シングルモデルサービングプラットフォームは、多くのリソースを必要とする大規模なモデルのデプロイ、監視、スケーリング、および保守に役立ちます。

3.2. コンポーネント

  • KServe : あらゆるタイプのモデルに対するモデルサービングを調整する Kubernetes カスタムリソース定義 (CRD)。KServe には、指定されたモデルサーバータイプの読み込みを実装するモデルサービングランタイムが含まれます。KServe は、デプロイメントオブジェクト、ストレージアクセス、およびネットワーク設定のライフサイクルも処理します。
  • Red Hat OpenShift Serverless: モデルのサーバーレスデプロイメントを可能にするクラウドネイティブ開発モデル。OpenShift Serverless は、オープンソースの Knative プロジェクトをベースにしています。
  • Red Hat OpenShift Service Mesh: トラフィックフローを管理し、アクセスポリシーを適用するサービスメッシュネットワーキングレイヤー。OpenShift Service Mesh は、オープンソースの Istio プロジェクトをベースにしています。

3.3. インストールオプション

シングルモデルサービングプラットフォームをインストールするには、次のオプションがあります。

自動インストール

OpenShift クラスターに ServiceMeshControlPlane または KNativeServing リソースをまだ作成していない場合は、KServe とその依存関係をインストールして構成するように Red Hat OpenShift AI Operator を設定できます。

自動インストールの詳細は、KServe の自動インストールの設定 を参照してください。

手動インストール

OpenShift クラスターに ServiceMeshControlPlane または KNativeServing リソースをすでに作成している場合は、KServe とその依存関係をインストールして構成するように Red Hat OpenShift AI Operator を設定 できません。この状況では、KServe を手動でインストールする必要があります。

手動インストールの詳細は、KServe の手動インストール を参照してください。

3.4. 認可

シングルモデルサービングプラットフォームの認可プロバイダーとして Authorino を追加できます。認可プロバイダーを追加すると、プラットフォームにデプロイするモデルに対してトークン認可を有効にできます。その場合、認可されなければモデルに対して推論リクエストを実行できなくなります。

シングルモデルサービングプラットフォームに Authorino を認可プロバイダーとして追加するには、次のオプションがあります。

  • クラスター上でシングルモデルサービングプラットフォームの自動インストールが可能な場合は、自動インストールプロセスの一部として Authorino を含めることができます。
  • シングルモデルサービングプラットフォームを手動でインストールする必要がある場合は、Authorino も手動で設定する必要があります。

シングルモデルサービングプラットフォームのインストールオプションを選択する方法は、インストールオプション を参照してください。

3.5. モニタリング

シングルモデルサービングプラットフォームの監視を設定し、Prometheus を使用して、プリインストールされた各モデルサービングランタイムのメトリクスをスクレイピングできます。

3.6. サポート対象のモデルサービングランタイム

OpenShift AI には、いくつかのプリインストールされたモデルサービングランタイムが含まれています。プリインストールされたモデルサービングランタイムを使用すると、ランタイムを自分で変更したり定義したりすることなく、モデルの提供を開始できます。モデルをサポートするために、カスタムランタイムを追加することもできます。

カスタムランタイムの追加に関するサポートは、シングルモデルサービングプラットフォーム用のカスタムモデルサービングランタイムの追加 を参照してください。

表3.1 モデルサービングランタイム
名前説明エクスポートされたモデル形式

Caikit Text Generation Inference Server (Caikit-TGIS) ServingRuntime for KServe (1)

Caikit 形式のモデルを提供するための複合ランタイム

Caikit テキスト生成

Caikit Standalone ServingRuntime for KServe (2)

埋め込みタスク用の Caikit 埋め込み形式でモデルを提供するためのランタイム

Caikit の埋め込み

OpenVINO Model Server

Intel アーキテクチャーに最適化されたモデルを提供するためのスケーラブルで高性能なランタイム

PyTorch、TensorFlow、OpenVINO IR、PaddlePaddle、MXNet、Caffe、Kaldi

Text Generation Inference Server (TGIS) Standalone ServingRuntime for KServe (3)

TGI 対応モデルを提供するためのランタイム

PyTorch モデル形式

vLLM ServingRuntime for KServe

大規模言語モデル向けの高スループットかつメモリー効率の高い推論およびサービングランタイム

サポート対象モデル

KServe の Gaudi accelerators サポートを備えた VLLM ServingRuntime

Intel Gaudi アクセラレーターをサポートする高スループットおよびメモリー効率の高い推論および提供ランタイム

サポート対象モデル

  1. 複合 Caikit-TGIS ランタイムは、Caikit および Text Generation Inference Server (TGIS) に基づいています。このランタイムを使用するには、モデルを Caikit 形式に変換する必要があります。例は、caikit-tgis-serving リポジトリーの Converting Hugging Face Hub models to Caikit format を参照してください。
  2. Caikit Standalone ランタイムは Caikit NLP に基づいています。このランタイムを使用するには、モデルを Caikit 埋め込み形式に変換する必要があります。例は、Tests for text embedding module を参照してください。
  3. Text Generation Inference Server (TGIS) は、Hugging Face TGI の初期のフォークに基づいています。Red Hat は、TGI モデルをサポートするスタンドアロン TGIS ランタイムの開発を継続します。モデルが OpenShift AI の最新バージョンと互換性がない場合は、今後のバージョンでサポートが追加される可能性があります。それまでの間は、独自のカスタムランタイムを追加して TGI モデルをサポートすることもできます。詳細は、シングルモデルサービングプラットフォーム用のカスタムモデルサービングランタイムの追加 を参照してください。
表3.2 デプロイメント要件
名前デフォルトプロトコル追加プロトコルモデルメッシュのサポートシングルノードの OpenShift サポートデプロイメントモード

Caikit Text Generation Inference Server (Caikit-TGIS) ServingRuntime for KServe

REST

gRPC

いいえ

はい

raw および serverless

Caikit Standalone ServingRuntime for KServe

REST

gRPC

いいえ

はい

raw および serverless

OpenVINO Model Server

REST

なし

はい

はい

raw および serverless

Text Generation Inference Server (TGIS) Standalone ServingRuntime for KServe

gRPC

なし

いいえ

はい

raw および serverless

vLLM ServingRuntime for KServe

REST

なし

いいえ

はい

raw および serverless

KServe の Gaudi accelerators サポートを備えた VLLM ServingRuntime

REST

なし

いいえ

はい

raw および serverless

3.7. テストおよび検証済みのモデルサービングランタイム

テストおよび検証済みのランタイムは、OpenShift AI の特定のバージョンに対してテストおよび検証されたモデルサービングランタイムのコミュニティーバージョンです。

Red Hat は、OpenShift AI の新しいバージョンがリリースされるたびに、テストおよび検証済みのランタイムの最新バージョンをテストします。テストおよび検証済みのランタイムの新しいバージョンが OpenShift AI リリースサイクルの途中でリリースされた場合、今後のリリースでテストおよび検証されます。

テスト済みで検証済みのランタイムと互換性のあるバージョンの一覧は、OpenShift AI リリースノート で確認できます。

注記

テストおよび検証済みのランタイムは、Red Hat によって直接サポートされません。お客様が責任を持って追加するテスト済みおよび検証済みのランタイムを使用するライセンスがあることを確認して正しく設定および保守するようにしてください。

詳細は、OpenShift AI でテストおよび検証されたランタイム を参照してください。

表3.3 モデルサービングランタイム
名前説明エクスポートされたモデル形式

NVIDIA Triton Inference Server

アプリケーションにおける高速かつスケーラブルな AI を実現するオープンソースの推論サービスソフトウェア。

TensorRT、TensorFlow、PyTorch、ONNX、OpenVINO、Python、RAPIDS FIL など

表3.4 デプロイメント要件
名前デフォルトプロトコル追加プロトコルモデルメッシュのサポートシングルノードの OpenShift サポートデプロイメントモード

NVIDIA Triton Inference Server

gRPC

REST

はい

はい

raw および serverless

3.8. 推論エンドポイント

これらの例は、推論エンドポイントを使用してモデルをクエリーする方法を示しています。

注記

モデルのデプロイ時にトークン認可を有効にした場合は、Authorization ヘッダーを追加してトークン値を指定する必要があります。

3.8.1. Caikit TGIS ServingRuntime for KServe

  • :443/api/v1/task/text-generation
  • :443/api/v1/task/server-streaming-text-generation

コマンドの例

curl --json '{"model_id": "<model_name__>", "inputs": "<text>"}' https://<inference_endpoint_url>:443/api/v1/task/server-streaming-text-generation -H 'Authorization: Bearer <token>'

3.8.2. Caikit Standalone ServingRuntime for KServe

複数のモデルを提供している場合は、/info/models または :443 caikit.runtime.info.InfoService/GetModelsInfo をクエリーして、提供されているモデルのリストを表示できます。

REST エンドポイント

  • /api/v1/task/embedding
  • /api/v1/task/embedding-tasks
  • /api/v1/task/sentence-similarity
  • /api/v1/task/sentence-similarity-tasks
  • /api/v1/task/rerank
  • /api/v1/task/rerank-tasks
  • /info/models
  • /info/version
  • /info/runtime

gRPC エンドポイント

  • :443 caikit.runtime.Nlp.NlpService/EmbeddingTaskPredict
  • :443 caikit.runtime.Nlp.NlpService/EmbeddingTasksPredict
  • :443 caikit.runtime.Nlp.NlpService/SentenceSimilarityTaskPredict
  • :443 caikit.runtime.Nlp.NlpService/SentenceSimilarityTasksPredict
  • :443 caikit.runtime.Nlp.NlpService/RerankTaskPredict
  • :443 caikit.runtime.Nlp.NlpService/RerankTasksPredict
  • :443 caikit.runtime.info.InfoService/GetModelsInfo
  • :443 caikit.runtime.info.InfoService/GetRuntimeInfo
注記

デフォルトでは、Caikit Standalone ランタイムは REST エンドポイントを公開します。gRPC プロトコルを使用するには、カスタム Caikit Standalone ServingRuntime を手動でデプロイします。詳細は、シングルモデルサービングプラットフォーム用のカスタムモデルサービングランタイムの追加 を参照してください。

サンプルのマニフェストは caikit-tgis-serving GitHub リポジトリー で入手できます。

REST

curl -H 'Content-Type: application/json' -d '{"inputs": "<text>", "model_id": "<model_id>"}' <inference_endpoint_url>/api/v1/task/embedding -H 'Authorization: Bearer <token>'

gRPC

grpcurl -d '{"text": "<text>"}' -H \"mm-model-id: <model_id>\" <inference_endpoint_url>:443 caikit.runtime.Nlp.NlpService/EmbeddingTaskPredict -H 'Authorization: Bearer <token>'

3.8.3. TGIS Standalone ServingRuntime for KServe

  • :443 fmaas.GenerationService/Generate
  • :443 fmaas.GenerationService/GenerateStream

    注記

    TGIS スタンドアロンランタイムのエンドポイントをクエリーするには、OpenShift AI text-generation-inference リポジトリーの proto ディレクトリーにあるファイルもダウンロードする必要があります。

コマンドの例

grpcurl -proto text-generation-inference/proto/generation.proto -d '{"requests": [{"text":"<text>"}]}' -H 'Authorization: Bearer <token>' -insecure <inference_endpoint_url>:443 fmaas.GenerationService/Generate

3.8.4. OpenVINO Model Server

  • /v2/models/<model-name>/infer

コマンドの例

curl -ks <inference_endpoint_url>/v2/models/<model_name>/infer -d '{ "model_name": "<model_name>", "inputs": [{ "name": "<name_of_model_input>", "shape": [<shape>], "datatype": "<data_type>", "data": [<data>] }]}' -H 'Authorization: Bearer <token>'

3.8.5. vLLM ServingRuntime for KServe

  • :443/version
  • :443/docs
  • :443/v1/models
  • :443/v1/chat/completions
  • :443/v1/completions
  • :443/v1/embeddings
  • :443/tokenize
  • :443/detokenize

    注記
    • vLLM ランタイムは OpenAI REST API と互換性があります。vLLM ランタイムがサポートするモデルのリストは、サポートされるモデル を参照してください。
    • vLLM で embeddings 推論エンドポイントを使用するには、vLLM でサポートされている embeddings モデルを使用する必要があります。生成モデルでは embeddings エンドポイントは使用できません。詳細は、vLLM でサポートされている embeddings モデル を参照してください。
    • vLLM v0.5.5 以降では、/v1/chat/completions エンドポイントを使用してモデルをクエリーするときに、チャットテンプレートを提供する必要があります。モデルに定義済みのチャットテンプレートが含まれていない場合は、例に示すように、chat-template コマンドラインパラメーターを使用して、カスタム vLLM ランタイムでチャットテンプレートを指定できます。<CHAT_TEMPLATE> をテンプレートのパスに置き換えます。

      containers:
        - args:
            - --chat-template=<CHAT_TEMPLATE>

      ここで .jinja ファイルとして利用できるチャットテンプレート、または /apps/data/template の下の vLLM イメージを使用できます。詳細は、チャットテンプレート を参照してください。

    上記のパスで示されているように、シングルモデルサービングプラットフォームは、OpenShift ルーターの HTTPS ポート (通常はポート 443) を使用して、外部 API リクエストを処理します。

コマンドの例

curl -v https://<inference_endpoint_url>:443/v1/chat/completions -H "Content-Type: application/json" -d '{ "messages": [{ "role": "<role>", "content": "<content>" }] -H 'Authorization: Bearer <token>'

3.8.6. KServe の Gaudi accelerators サポートを備えた VLLM ServingRuntime

vLLM ServingRuntime for KServe

3.8.7. NVIDIA Triton Inference Server

REST エンドポイント

  • v2/models/[/versions/<model_version>]/infer
  • v2/models/<model_name>[/versions/<model_version>]
  • v2/health/ready
  • v2/health/live
  • v2/models/<model_name>[/versions/]/ready
  • v2

コマンドの例

curl -ks <inference_endpoint_url>/v2/models/<model_name>/infer -d '{ "model_name": "<model_name>", "inputs": [{ "name": "<name_of_model_input>", "shape": [<shape>], "datatype": "<data_type>", "data": [<data>] }]}' -H 'Authorization: Bearer <token>'

gRPC エンドポイント

  • :443 inference.GRPCInferenceService/ModelInfer
  • :443 inference.GRPCInferenceService/ModelReady
  • :443 inference.GRPCInferenceService/ModelMetadata
  • :443 inference.GRPCInferenceService/ServerReady
  • :443 inference.GRPCInferenceService/ServerLive
  • :443 inference.GRPCInferenceService/ServerMetadata

コマンドの例

grpcurl -cacert ./openshift_ca_istio_knative.crt -proto ./grpc_predict_v2.proto -d @ -H "Authorization: Bearer <token>" <inference_endpoint_url>:443 inference.GRPCInferenceService/ModelMetadata

3.8.8. 関連情報

3.9. KServe デプロイメントモードについて

デフォルトでは、モデルの serverless デプロイメントを可能にするクラウドネイティブ開発モデルである Red Hat OpenShift Serverless を使用して、KServe でシングルモデルサービングプラットフォームにモデルをデプロイできます。OpenShift Serverless は、オープンソースの Knative プロジェクトをベースにしています。さらに、serverless モードは Red Hat OpenShift Serverless Operator に依存します。

あるいは、Red Hat OpenShift Serverless Operator に依存しない raw デプロイメントモードを使用することもできます。raw デプロイメントモードでは、DeploymentServiceIngressHorizontal Pod Autoscaler などの Kubernetes リソースを使用してモデルをデプロイできます。

重要

KServe の raw デプロイメントモードを使用して機械学習モデルをデプロイすることは、限定提供機能です。限定提供とは、Red Hat AI Business Unit からの特別な承認を得た場合にのみ、対象となる機能をインストールしてサポートを受けることができることを意味します。このような承認がない場合、この機能はサポートされません。また、この機能は、シングルノードの OpenShift のセルフマネージドデプロイメントでのみサポートされます。

これらの各デプロイメントモードには、それぞれメリットとデメリットがあります。

3.9.1. Serverless モード

メリット:

  • リクエスト量に基づいて自動スケーリングを有効にします。

    • 着信リクエストを受信すると、リソースは自動的にスケールアップされます。
    • リソースの使用を最適化し、ピーク時のパフォーマンスを維持します。
  • Knative を使用してゼロへのスケールダウンとゼロからのスケールダウンをサポートします。

    • 着信リクエストがない場合にリソースを完全にスケールダウンできます。
    • アイドル状態のリソースを実行しないことでコストを節約します。

デメリット:

  • カスタマイズの制限があります。

    • 複数のボリュームをマウントする場合など、Serverless は Knative に制限されます。
  • スケーリン用に Knative に依存します。

    • 従来のスケーリング方法と比較して、セットアップと管理がさらに複雑になります。

3.9.2. raw デプロイメントモード

メリット:

  • DeploymentServiceIngressHorizontal Pod Autoscaler などの Kubernetes リソースを使用したデプロイメントを有効にします。

    • Kubernetes リソースを完全に制御し、デプロイメント設定の詳細なカスタマイズと設定を可能にします。
  • 複数のボリュームをマウントできないなどの Knative の制限を解除します。

    • 複雑な設定や複数のストレージマウントを必要とするアプリケーションに役立ちます。

デメリット:

  • 自動スケーリングはサポートされていません。

    • アイドル時にリソースを自動的にゼロにスケールダウンすることはサポートされていません。
    • トラフィックが少ない期間にはコストが高くなる可能性があります。
  • スケーリングの手動管理が必要です。

3.10. KServe の raw デプロイメントモードを使用してシングルノードの OpenShift にモデルをデプロイする

シングルノードの OpenShift で KServe の raw デプロイメントモードを使用して機械学習モデルをデプロイできます。raw デプロイメントモードには、複数のボリュームをマウントする機能など、Knative に比べていくつかのメリットがあります。

重要

シングルノード OpenShift で KServe の raw デプロイメントモードを使用して機械学習モデルをデプロイすることは、限定提供機能です。限定提供とは、Red Hat AI Business Unit からの特別な承認を得た場合にのみ、対象となる機能をインストールしてサポートを受けることができることを意味します。このような承認がない場合、この機能はサポートされません。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift クラスターのクラスター管理者権限を持っている。
  • 少なくとも 4 つの CPU と 16 GB のメモリーを備えたノードを持つ OpenShift クラスターを作成している。
  • Red Hat OpenShift AI (RHOAI) Operator がインストールされている。
  • OpenShift コマンドラインインターフェイス (CLI) がインストールされている。OpenShift コマンドラインインターフェイス (CLI) のインストールに関する詳細は、OpenShift CLI のスタートガイド を参照してください。
  • KServe をインストールしている。
  • S3 互換オブジェクトストレージにアクセスできる。
  • デプロイするモデルについて、S3 互換オブジェクトストレージバケット内の関連フォルダーパスを把握している。
  • Caikit-TGIS ランタイムを使用するために、モデルを Caikit 形式に変換している。例は、caikit-tgis-serving リポジトリーの Converting Hugging Face Hub models to Caikit format を参照してください。
  • モデルサーバーでグラフィックスプロセッシングユニット (GPU) を使用する場合は、OpenShift AI で GPU サポートを有効にしている。NVIDIA GPU の有効化 を参照してください。
  • vLLM ランタイムを使用するには、OpenShift AI で GPU サポートを有効にし、クラスターに Node Feature Discovery Operator をインストールして設定しておく。詳細は、Node Feature Discovery Operator のインストールNVIDIA GPU の有効化 を参照してください。

手順

  1. コマンドラインターミナルを開き、クラスター管理者として OpenShift クラスターにログインします。

    $ oc login <openshift_cluster_url> -u <admin_username> -p <password>
  2. デフォルトでは、OpenShift はネットワークトラフィック管理にサービスメッシュを使用します。KServe の raw デプロイメントモードではサービスメッシュは必要ないため、Red Hat OpenShift Service Mesh を無効にします。

    1. Red Hat OpenShift Service Mesh を無効にするには、次のコマンドを入力します。

      $ oc edit dsci -n redhat-ods-operator
    2. YAML エディターで、serviceMesh コンポーネントの managementState の値を次のように Removed に変更します。

      spec:
        components:
          serviceMesh:
            managementState: Removed
    3. 変更を保存します。
  3. プロジェクトを作成します。

    $ oc new-project <project_name> --description="<description>" --display-name="<display_name>"

    プロジェクトの作成に関する詳細は、プロジェクトの使用 を参照してください。

  4. データサイエンスクラスターを作成します。

    1. Red Hat OpenShift Web コンソールの Administrator ビューで、OperatorsInstalled Operators をクリックし、Red Hat OpenShift AI Operator をクリックします。
    2. Data Science Cluster タブをクリックします。
    3. Create DataScienceCluster ボタンをクリックします。
    4. Configure via フィールドで、YAML view ラジオボタンをクリックします。
    5. YAML エディターの spec.components セクションで、kserve コンポーネントを次のように設定します。

        kserve:
          defaultDeploymentMode: RawDeployment
          managementState: Managed
          serving:
            managementState: Removed
            name: knative-serving
    6. Create をクリックします。
  5. シークレットファイルを作成します。

    1. コマンドラインターミナルで、シークレットを格納する YAML ファイルを作成し、次の YAML コードを追加します。

      apiVersion: v1
      kind: Secret
      metadata:
        annotations:
          serving.kserve.io/s3-endpoint: <AWS_ENDPOINT>
          serving.kserve.io/s3-usehttps: "1"
          serving.kserve.io/s3-region: <AWS_REGION>
          serving.kserve.io/s3-useanoncredential: "false"
        name: <Secret-name>
      stringData:
        AWS_ACCESS_KEY_ID: "<AWS_ACCESS_KEY_ID>"
        AWS_SECRET_ACCESS_KEY: "<AWS_SECRET_ACCESS_KEY>"
      重要

      切断されたデプロイメントで機械学習モデルをデプロイする場合は、metadata.annotations セクションに serving.kserve.io/s3-verifyssl: '0' を追加します。

    2. ファイルを secret.yaml というファイル名で保存します。
    3. secret.yaml ファイルを適用します。

      $ oc apply -f secret.yaml -n <namespace>
  6. サービスアカウントを作成します。

    1. サービスアカウントを格納する YAML ファイルを作成し、次の YAML コードを追加します。

      apiVersion: v1
      kind: ServiceAccount
      metadata:
        name: models-bucket-sa
      secrets:
      - name: s3creds

      サービスアカウントの詳細は、サービスアカウントの理解と作成 を参照してください。

    2. ファイルを serviceAccount.yaml というファイル名で保存します。
    3. serviceAccount.yaml ファイルを適用します。

      $ oc apply -f serviceAccount.yaml -n <namespace>
  7. モデルの予測を提供するコンテナーイメージを定義するために、サービングランタイム用の YAML ファイルを作成します。以下は OpenVINO Model Server の使用例です。

    apiVersion: serving.kserve.io/v1alpha1
    kind: ServingRuntime
    metadata:
      name: ovms-runtime
    spec:
      annotations:
        prometheus.io/path: /metrics
        prometheus.io/port: "8888"
      containers:
        - args:
            - --model_name={{.Name}}
            - --port=8001
            - --rest_port=8888
            - --model_path=/mnt/models
            - --file_system_poll_wait_seconds=0
            - --grpc_bind_address=0.0.0.0
            - --rest_bind_address=0.0.0.0
            - --target_device=AUTO
            - --metrics_enable
          image: quay.io/modh/openvino_model_server@sha256:6c7795279f9075bebfcd9aecbb4a4ce4177eec41fb3f3e1f1079ce6309b7ae45
          name: kserve-container
          ports:
            - containerPort: 8888
              protocol: TCP
      multiModel: false
      protocolVersions:
        - v2
        - grpc-v2
      supportedModelFormats:
        - autoSelect: true
          name: openvino_ir
          version: opset13
        - name: onnx
          version: "1"
        - autoSelect: true
          name: tensorflow
          version: "1"
        - autoSelect: true
          name: tensorflow
          version: "2"
        - autoSelect: true
          name: paddle
          version: "2"
        - autoSelect: true
          name: pytorch
          version: "2"
    1. 上記の OpenVINO Model Server の例を使用している場合は、YAML コード内のプレースホルダーに必要な正しい値を挿入していることを確認してください。
    2. 適切なファイル名でファイルを保存します。
    3. サービングランタイムを含むファイルを適用します。

      $ oc apply -f <serving run time file name> -n <namespace>
  8. InferenceService カスタムリソース (CR) を作成します。InferenceService CR を含むための YAML ファイルを作成します。以前使用した OpenVINO Model Server の例を使用する場合の対応する YAML コードは、次のとおりです。

    apiVersion: serving.kserve.io/v1beta1
    kind: InferenceService
    metadata:
      annotations:
        serving.knative.openshift.io/enablePassthrough: "true"
        sidecar.istio.io/inject: "true"
        sidecar.istio.io/rewriteAppHTTPProbers: "true"
        serving.kserve.io/deploymentMode: RawDeployment
      name: <InferenceService-Name>
    spec:
      predictor:
        scaleMetric:
        minReplicas: 1
        scaleTarget:
        canaryTrafficPercent:
        serviceAccountName: <serviceAccountName>
        model:
          env: []
          volumeMounts: []
          modelFormat:
            name: onnx
          runtime: ovms-runtime
          storageUri: s3://<bucket_name>/<model_directory_path>
          resources:
            requests:
              memory: 5Gi
        volumes: []
    1. YAML コードで、次の値が正しく設定されていることを確認します。

      • serving.kserve.io/deploymentMode には、RawDeployment の値が含まれている必要があります。
      • modelFormat には、onnx などのモデル形式の値が含まれている必要があります。
      • storageUri には、モデルの s3 ストレージディレクトリーの値 (例 s3://<bucket_name>/<model_directory_path>) が含まれている必要があります。
      • runtime には、ovms-runtime など、サービングランタイムの名前の値が含まれている必要があります。
    2. 適切なファイル名でファイルを保存します。
    3. InferenceService CR を含むファイルを適用します。

      $ oc apply -f <InferenceService CR file name> -n <namespace>
  9. クラスター内のすべての Pod が実行されていることを確認します。

    $ oc get pods -n <namespace>

    出力例:

    NAME READY STATUS RESTARTS AGE
    <isvc_name>-predictor-xxxxx-2mr5l 1/1 Running 2 165m
    console-698d866b78-m87pm 1/1 Running 2 165m
  10. すべての Pod が実行中であることを確認したら、サービスポートをローカルマシンに転送します。

    $ oc -n <namespace> port-forward pod/<pod-name> <local_port>:<remote_port>

    <namespace><pod-name><local_port><remote_port> (これは 8888 などのモデルサーバーのポート) を、デプロイメントに適した値に置き換えてください。

検証

  • 好みのクライアントライブラリーまたはツールを使用して、localhost 推論 URL にリクエストを送信します。

3.10.1. 複数の GPU ノードを使用したモデルのデプロイ

複数のノードで複数のグラフィカルプロセッシングユニット(GPU)を使用するモデルをデプロイすると、大規模な言語モデル(LLM)などの大規模なモデルをデプロイする場合に役立ちます。

この手順では、vLLM 提供フレームワークを使用して、複数の GPU ノード間で Red Hat OpenShift AI でモデルを提供する方法を説明します。マルチノードの推論は、vllm-multinode-runtime ServingRuntime をカスタムランタイムとして使用します。vllm-multinode-runtime ServingRuntime は、vllm-runtime と同じ vLLM イメージを使用し、マルチ GPU インフレーションに必要な情報が含まれます。

重要

現在、複数の GPU ノードを使用するモデルのデプロイ は、テクノロジープレビュー機能としてのみ Red Hat OpenShift AI で利用できます。テクノロジープレビュー機能は、Red Hat 製品のサービスレベルアグリーメント (SLA) の対象外であり、機能的に完全ではないことがあります。Red Hat では、実稼働環境での使用を推奨していません。テクノロジープレビュー機能は、最新の製品機能をいち早く提供して、開発段階で機能のテストを行い、フィードバックを提供していただくことを目的としています。

Red Hat のテクノロジープレビュー機能のサポート範囲に関する詳細は、テクノロジープレビュー機能のサポート範囲 を参照してください。

前提条件

  • OpenShift クラスターのクラスター管理者権限を持っている。
  • OpenShift コマンドラインインターフェイス (CLI) がダウンロードおよびインストールされている。OpenShift CLI のインストール を参照してください。
  • Node Feature Discovery Operator、NVIDIA GPU Operator など、GPU タイプの Operator を有効にしている。アクセラレーターの有効化の詳細は、アクセラレーターの有効化 を 参照してください。

    • NVIDIA GPU (nvidia.com/gpu)を使用している。
    • ServingRuntime または InferenceService のいずれかを使用して GPU タイプを指定します。ServingRuntime で指定された GPU タイプが InferenceService で設定されている内容と異なる場合は、両方の GPU タイプがリソースに割り当てられ、エラーが発生する可能性があります。
  • クラスターで KServe を有効にしている。
  • セットアップには 1 つの head Pod のみがあります。InferenceServicemin_replicas または max_replicas 設定を使用してレプリカ数を調整しないでください。追加の head Pod を作成すると、それらが Ray クラスターから除外される可能性があります。
  • ReadWriteMany (RWX)アクセスモード用に永続ボリューム要求(PVC)がセットアップされ、設定されている。

手順

  1. ターミナルウィンドウで、クラスター管理者として OpenShift クラスターにまだログインしていない場合は、次の例に示すように OpenShift CLI にログインします。

    $ oc login <openshift_cluster_url> -u <admin_username> -p <password>
  2. モデルをデプロイする namespace を選択または作成します。この例では、kserve-demo が使用され、以下のコマンドを使用して作成できます。

    oc new-project kserve-demo
  3. モデルをデプロイする namespace から、モデルストレージの PVC を作成し、ストレージクラスの名前を指定します。ストレージクラスはファイルストレージである必要があります。

    注記

    PVC がすでに設定されている場合は、この手順を省略できます。

    kubectl apply -f -
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: granite-8b-code-base-pvc
    spec:
      accessModes:
        - ReadWriteMany
      volumeMode: Filesystem
      resources:
        requests:
          storage: 50Gi
      storageClassName: __<fileStorageClassName>__
  4. モデルを PVC にダウンロードします。以下に例を示します。

    apiVersion: v1
    kind: Pod
    metadata:
      name: download-granite-8b-code
      labels:
        name: download-granite-8b-code
    spec:
      volumes:
        - name: model-volume
          persistentVolumeClaim:
            claimName: granite-8b-code-claim
      restartPolicy: Never
      initContainers:
        - name: fix-volume-permissions
          image: quay.io/quay/busybox@sha256:xxxxx
          command: ["sh"]
          args: ["-c", "mkdir -p /mnt/models/granite-8b-code-base && chmod -R 777 /mnt/models"]
          volumeMounts:
            - mountPath: "/mnt/models/"
              name: model-volume
      containers:
        - resources:
            requests:
              memory: 40Gi
          name: download-model
          imagePullPolicy: IfNotPresent
          image: quay.io/modh/kserve-storage-initializer@sha256:xxxxx
          args:
            - 's3://$<bucket_name>/granite-8b-code-base/'
            - /mnt/models/granite-8b-code-base
          env:
            - name: AWS_ACCESS_KEY_ID
              value: <id>
            - name: AWS_SECRET_ACCESS_KEY
              value: <secret>
            - name: BUCKET_NAME
              value: <bucket_name>
            - name: S3_USE_HTTPS
              value: "1"
            - name: AWS_ENDPOINT_URL
              value: <AWS endpoint>
            - name: awsAnonymousCredential
              value: 'false'
            - name: AWS_DEFAULT_REGION
              value: <region>
          volumeMounts:
            - mountPath: "/mnt/models/"
              name: model-volume
  5. vllm-multinode-runtime ServingRuntime をカスタムランタイムとして作成します。

    oc process vllm-multinode-runtime-template -n redhat-ods-applications|oc apply  -f -
  6. 次の InferenceService 設定を使用してモデルをデプロイします。

    apiVersion: serving.kserve.io/v1beta1
    kind: InferenceService
    metadata:
      annotations:
        serving.kserve.io/deploymentMode: RawDeployment
        serving.kserve.io/autoscalerClass: external
      name: granite-8b-code-base-pvc
    spec:
      predictor:
        model:
          modelFormat:
            name: vLLM
          runtime: vllm-multinode-runtime
          storageUri: pvc://granite-8b-code-base-pvc/hf/8b_instruction_tuned
        workerSpec: {}

    次の設定を InferenceService に追加できます。

    • workerSpec.tensorParallelSize: ノードごとに使用される GPU の数を決定します。ヘッドおよびワーカーノードのデプロイメントリソースの両方の GPU タイプカウントは自動的に更新されます。workerSpec.tensorParallelSize の値が 1 以上であることを確認します。
    • workerSpec.pipelineParallelSize: デプロイメントに関与するノードの数を決定します。この変数は、ヘッドノードとワーカーノードの両方を含むノードの総数を表します。workerSpec.pipelineParallelSize の値が 2 以上であることを確認します。

検証

複数の GPU ノードにモデルをデプロイするように環境を設定していることを確認するには、GPU リソースのステータス、InferenceService のステータス、トレイクラスターステータスを確認し、モデルにリクエストを送信します。

  • GPU リソースのステータスを確認します。

    • ヘッドおよびワーカーノードの Pod 名を取得します。

      # Get pod name
      podName=$(oc get pod -l app=isvc.granite-8b-code-base-pvc-predictor --no-headers|cut -d' ' -f1)
      workerPodName=$(oc get pod -l app=isvc.granite-8b-code-base-pvc-predictor-worker --no-headers|cut -d' ' -f1)
      
      oc wait --for=condition=ready pod/${podName} --timeout=300s
      # Check the GPU memory size for both the head and worker pods:
      echo "### HEAD NODE GPU Memory Size"
      kubectl exec $podName -- nvidia-smi
      echo "### Worker NODE GPU Memory Size"
      kubectl exec $workerPodName -- nvidia-smi

      応答の例

      +-----------------------------------------------------------------------------------------+
      | NVIDIA-SMI 550.90.07              Driver Version: 550.90.07      CUDA Version: 12.4     |
      |-----------------------------------------+------------------------+----------------------+
      | GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
      | Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
      |                                         |                        |               MIG M. |
      |=========================================+========================+======================|
      |   0  NVIDIA A10G                    On  |   00000000:00:1E.0 Off |                    0 |
      |  0%   33C    P0             71W /  300W |19031MiB /  23028MiB <1>|      0%      Default |
      |                                         |                        |                  N/A |
      +-----------------------------------------+------------------------+----------------------+
               ...
      +-----------------------------------------------------------------------------------------+
      | NVIDIA-SMI 550.90.07              Driver Version: 550.90.07      CUDA Version: 12.4     |
      |-----------------------------------------+------------------------+----------------------+
      | GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
      | Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
      |                                         |                        |               MIG M. |
      |=========================================+========================+======================|
      |   0  NVIDIA A10G                    On  |   00000000:00:1E.0 Off |                    0 |
      |  0%   30C    P0             69W /  300W |18959MiB /  23028MiB <2>|      0%      Default |
      |                                         |                        |                  N/A |
      +-----------------------------------------+------------------------+----------------------+

      <1> および <2> の値をチェックして、モデルが正しくロードされていることを確認します。モデルがロードされなかった場合、これらのフィールドの値は 0MiB になります。

  • 次のコマンドを使用して、InferenceService のステータスを確認します。

    注記

    テクノロジープレビューでは、移植にはポート転送のみを使用できます。

    oc wait --for=condition=ready pod/${podName} -n $DEMO_NAMESPACE --timeout=300s
    export MODEL_NAME=granite-8b-code-base-pvc

    応答の例

       NAME                 URL                                                   READY   PREV   LATEST   PREVROLLEDOUTREVISION   LATESTREADYREVISION                          AGE
       granite-8b-code-base-pvc   http://granite-8b-code-base-pvc.default.example.com

  • モデルにリクエストを送信して、モデルが推論に使用できることを確認します。

    oc wait --for=condition=ready pod/${podName} -n vllm-multinode --timeout=300s
    
    oc port-forward $podName 8080:8080 &
    
    curl http://localhost:8080/v1/completions \
           -H "Content-Type: application/json" \
           -d "{
                'model': "$MODEL_NAME",
                'prompt': 'At what temperature does Nitrogen boil?',
                'max_tokens': 100,
                'temperature': 0
            }"

3.11. シングルモデルサービングプラットフォームを使用したモデルのデプロイ

シングルモデルサービングプラットフォームでは、各モデルが独自のモデルサーバー上でデプロイされます。これにより、リソースの増加を必要とする大規模なモデルのデプロイ、監視、スケーリング、保守が容易になります。

重要

シングルモデルサービングプラットフォームを使用して、自己署名 SSL 証明書を使用する S3 互換ストレージからモデルをデプロイする場合は、OpenShift クラスターに認証局 (CA) バンドルをインストールする必要があります。詳細は、証明書の使用 (OpenShift AI Self-Managed) または 証明書の使用 (非接続環境の OpenShift AI Self-Managed) を参照してください。

3.11.1. シングルモデルサービングプラットフォームの有効化

KServe をインストールすると、Red Hat OpenShift AI ダッシュボードを使用して、シングルモデルサービングプラットフォームを有効にすることができます。ダッシュボードを使用して、プラットフォームのモデルサービングランタイムを有効にすることもできます。

前提条件

  • OpenShift AI 管理者権限を持つユーザーとして OpenShift AI にログインしている。
  • KServe をインストールしている。
  • クラスター管理者は、OpenShift AI ダッシュボード設定を編集して KServe コンポーネントを使用するシングルモデルサービングプラットフォームを選択する機能を無効に していない。詳細は、ダッシュボード設定オプション を参照してください。

手順

  1. 次のようにシングルモデルサービングプラットフォームを有効にします。

    1. 左側のメニューで、SettingsCluster settings をクリックします。
    2. Model serving platforms セクションを見つけます。
    3. プロジェクトに対してシングルモデルサービングプラットフォームを有効にするには、Single model serving platform チェックボックスをオンにします。
    4. Save changes をクリックします。
  2. 次のように、シングルモデルサービングプラットフォーム用のプリインストールされたランタイムを有効にします。

    1. OpenShift AI ダッシュボードの左側のメニューで、SettingsServing runtimes をクリックします。

      Serving runtimes ページには、プリインストールされたランタイムと追加したカスタムランタイムが表示されます。

      プリインストールされたランタイムの詳細は、サポートされているランタイム を参照してください。

    2. 使用するランタイムを Enabled に設定します。

      これで、シングルモデルサービングプラットフォームをモデルのデプロイに使用できるようになりました。

3.11.2. シングルモデルサービングプラットフォーム用のカスタムモデルサービングランタイムの追加

モデルサービングランタイムは、特定のモデルフレームワーク群のサポートと、それらのフレームワークでサポートされるモデル形式のサポートを追加します。OpenShift AI に含まれている プリインストールされたランタイム を使用できます。デフォルトのランタイムがニーズを満たしていない場合は、独自のカスタムランタイムを追加することもできます。たとえば、TGIS ランタイムが Hugging Face Text Generation Inference (TGI) でサポートされているモデル形式をサポートしていない場合は、カスタムランタイムを作成してモデルのサポートを追加できます。

管理者は、OpenShift AI インターフェイスを使用して、カスタムのモデルサービングランタイムを追加して有効にすることができます。その場合は、シングルモデルサービングプラットフォームにモデルをデプロイする際に、カスタムランタイムを選択できます。

注記

Red Hat はカスタムランタイムのサポートを提供しません。追加したカスタムランタイムを使用するライセンスがあることを確認し、お客様の責任で正しく設定および保守するようにしてください。

前提条件

  • OpenShift AI 管理者権限を持つユーザーとして OpenShift AI にログインしている。
  • カスタムランタイムをビルドし、イメージを Quay などのコンテナーイメージリポジトリーに追加している。

手順

  1. OpenShift AI ダッシュボードから、Settings > Serving runtimes をクリックします。

    Serving runtimes ページが開き、すでにインストールされ有効になっているモデルサービングランタイムが表示されます。

  2. カスタムランタイムを追加するには、次のオプションのいずれかを選択します。

    • 既存のランタイム (TGIS Standalone ServingRuntime for KServe など) で開始するには、既存のランタイムの横にあるアクションメニュー (⋮) をクリックしてから、Duplicate をクリックします。
    • 新しいカスタムランタイムを追加するには、Add serving runtime をクリックします。
  3. Select the model serving platforms this runtime supports リストで、Single-model serving platform を選択します。
  4. Select the API protocol this runtime supports リストで、REST または gRPC を選択します。
  5. オプション: (既存のランタイムを複製するのではなく) 新しいランタイムを開始した場合は、次のオプションのいずれかを選択してコードを追加します。

    • YAML ファイルをアップロードする

      1. Upload files をクリックします。
      2. ファイルブラウザーで、コンピューター上の YAML ファイルを選択します。

        埋め込み YAML エディターが開き、アップロードしたファイルの内容が表示されます。

    • エディターに YAML コードを直接入力する

      1. Start from scratch をクリックします。
      2. 埋め込みエディターに YAML コードを直接入力または貼り付けます。
    注記

    多くの場合、カスタムランタイムを作成するには、ServingRuntime 仕様の env セクションに新しいパラメーターまたはカスタムパラメーターを追加する必要があります。

  6. Add をクリックします。

    Serving runtimes ページが開き、インストールされているランタイムの更新されたリストが表示されます。追加したカスタムランタイムが自動的に有効になることを確認します。ランタイム作成時に指定した API プロトコルが表示されます。

  7. オプション: カスタムランタイムを編集するには、アクションメニュー (⋮) をクリックし、Edit を選択します。

検証

  • 追加したカスタムモデルサービングランタイムは、Serving runtimes ページに有効な状態で表示されます。

3.11.3. シングルモデルサービングプラットフォームへのテスト済みおよび検証済みのモデルサービングランタイム追加

プリインストールされたカスタムのモデルサービングランタイムに加えて、NVIDIA Triton Inference Server などの Red Hat でテストおよび検証されたモデルサービングランタイムを使用して要件に対応することもできます。Red Hat のテスト済みおよび検証済みのランタイムの詳細は、Red Hat OpenShift AI のテスト済みおよび検証済みのランタイム を参照してください。

Red Hat OpenShift AI ダッシュボードを使用して、シングルモデルサービングプラットフォーム用の NVIDIA Triton Inference Server ランタイムを追加して有効にできます。その場合は、シングルモデルサービングプラットフォームにモデルをデプロイする際に、ランタイムを選択できます。

前提条件

  • OpenShift AI 管理者権限を持つユーザーとして OpenShift AI にログインしている。

手順

  1. OpenShift AI ダッシュボードから、Settings > Serving runtimes をクリックします。

    Serving runtimes ページが開き、すでにインストールされ有効になっているモデルサービングランタイムが表示されます。

  2. Add serving runtime をクリックします。
  3. Select the model serving platforms this runtime supports リストで、Single-model serving platform を選択します。
  4. Select the API protocol this runtime supports リストで、REST または gRPC を選択します。
  5. Start from scratch をクリックします。

    1. REST API プロトコルを選択した場合は、埋め込みエディターに次の YAML コードを直接入力または貼り付けます。

      apiVersion: serving.kserve.io/v1alpha1
      kind: ServingRuntime
      metadata:
        name: triton-kserve-rest
        labels:
          opendatahub.io/dashboard: "true"
      spec:
        annotations:
          prometheus.kserve.io/path: /metrics
          prometheus.kserve.io/port: "8002"
        containers:
          - args:
              - tritonserver
              - --model-store=/mnt/models
              - --grpc-port=9000
              - --http-port=8080
              - --allow-grpc=true
              - --allow-http=true
            image: nvcr.io/nvidia/tritonserver@sha256:xxxxx
            name: kserve-container
            resources:
              limits:
                cpu: "1"
                memory: 2Gi
              requests:
                cpu: "1"
                memory: 2Gi
            ports:
              - containerPort: 8080
                protocol: TCP
        protocolVersions:
          - v2
          - grpc-v2
        supportedModelFormats:
          - autoSelect: true
            name: tensorrt
            version: "8"
          - autoSelect: true
            name: tensorflow
            version: "1"
          - autoSelect: true
            name: tensorflow
            version: "2"
          - autoSelect: true
            name: onnx
            version: "1"
          - name: pytorch
            version: "1"
          - autoSelect: true
            name: triton
            version: "2"
          - autoSelect: true
            name: xgboost
            version: "1"
          - autoSelect: true
            name: python
            version: "1"
    2. gRPC API プロトコルを選択した場合は、埋め込みエディターで次の YAML コードを直接入力または貼り付けます。

      apiVersion: serving.kserve.io/v1alpha1
      kind: ServingRuntime
      metadata:
        name: triton-kserve-grpc
        labels:
          opendatahub.io/dashboard: "true"
      spec:
        annotations:
          prometheus.kserve.io/path: /metrics
          prometheus.kserve.io/port: "8002"
        containers:
          - args:
              - tritonserver
              - --model-store=/mnt/models
              - --grpc-port=9000
              - --http-port=8080
              - --allow-grpc=true
              - --allow-http=true
            image: nvcr.io/nvidia/tritonserver@sha256:xxxxx
            name: kserve-container
            ports:
              - containerPort: 9000
                name: h2c
                protocol: TCP
            volumeMounts:
              - mountPath: /dev/shm
                name: shm
            resources:
              limits:
                cpu: "1"
                memory: 2Gi
              requests:
                cpu: "1"
                memory: 2Gi
        protocolVersions:
          - v2
          - grpc-v2
        supportedModelFormats:
          - autoSelect: true
            name: tensorrt
            version: "8"
          - autoSelect: true
            name: tensorflow
            version: "1"
          - autoSelect: true
            name: tensorflow
            version: "2"
          - autoSelect: true
            name: onnx
            version: "1"
          - name: pytorch
            version: "1"
          - autoSelect: true
            name: triton
            version: "2"
          - autoSelect: true
            name: xgboost
            version: "1"
          - autoSelect: true
            name: python
            version: "1"
      volumes:
        - emptyDir: null
          medium: Memory
          sizeLimit: 2Gi
          name: shm
  6. metadata.name フィールドで、追加するランタイムの値が、すでに追加されているランタイムと一致していないことを確認してください。
  7. オプション: 追加するランタイムのカスタム表示名を使用するには、次の例に示すように、metadata.annotations.openshift.io/display-name フィールドを追加し、値を指定します。

    apiVersion: serving.kserve.io/v1alpha1
    kind: ServingRuntime
    metadata:
      name: kserve-triton
      annotations:
        openshift.io/display-name: Triton ServingRuntime
    注記

    ランタイムのカスタム表示名を設定しないと、OpenShift AI には metadata.name フィールドの値が表示されます。

  8. Create をクリックします。

    Serving runtimes ページが開き、インストールされているランタイムの更新されたリストが表示されます。追加したランタイムが自動的に有効になっていることを確認します。ランタイム作成時に指定した API プロトコルが表示されます。

  9. オプション: ランタイムを編集するには、アクションメニュー (⋮) をクリックし、Edit を選択します。

検証

  • 追加したモデルサービスランタイムは、Serving runtimes ページに有効な状態で表示されます。

3.11.4. シングルモデルサービングプラットフォームへのモデルのデプロイ

シングルモデルサービングプラットフォームを有効にすると、カスタムまたはプリインストールされたモデルサービングランタイムを有効にして、プラットフォームへのモデルのデプロイを開始できます。

注記

Text Generation Inference Server (TGIS) は、Hugging Face TGI の初期のフォークに基づいています。Red Hat は、TGI モデルをサポートするスタンドアロン TGIS ランタイムの開発を継続します。モデルが OpenShift AI の現在のバージョンで機能しない場合、今後のバージョンでサポートが追加される可能性があります。それまでの間は、独自のカスタムランタイムを追加して TGI モデルをサポートすることもできます。詳細は、シングルモデルサービングプラットフォーム用のカスタムモデルサービングランタイムの追加 を参照してください。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • KServe をインストールしている。
  • シングルモデルサービングプラットフォームを有効にしている。
  • デプロイされたモデルのトークン認可と外部モデルルートを有効にするために、Authorino を認可プロバイダーとして追加している。詳細は、シングルモデルサービングプラットフォームの認可プロバイダーの追加 を参照してください。
  • データサイエンスプロジェクトを作成した。
  • S3 互換オブジェクトストレージにアクセスできる。
  • デプロイするモデルについて、S3 互換オブジェクトストレージバケット内の関連フォルダーパスを把握している。
  • Caikit-TGIS ランタイムを使用するために、モデルを Caikit 形式に変換している。例は、caikit-tgis-serving リポジトリーの Converting Hugging Face Hub models to Caikit format を参照してください。
  • モデルサーバーでグラフィックスプロセッシングユニット (GPU) を使用する場合は、OpenShift AI で GPU サポートを有効にしている。NVIDIA GPU の有効化 を参照してください。
  • KServe ランタイムに vLLM ServingRuntime を 使用するには、OpenShift AI で GPU サポートを有効にし、クラスターに Node Feature Discovery Operator をインストールおよび設定している。詳細は、Node Feature Discovery Operator のインストール と NVIDIA GPU の有効化 を参照してください。
  • KServe ランタイムの Gaudi accelerators サポートで vLLM ServingRuntime を使用するには、OpenShift AI でハイブリッドプロセッシングユニット(HPU)のサポートを有効にしている。これには、Intel Gaudi AI アクセラレーターオペレーターのインストールやアクセラレータープロファイルの設定が含まれます。詳細は、Setting up Gaudi for OpenShift および Working with accelerators を参照してください。

    注記

    OpenShift AI 2.16 では、Red Hat はモデル提供の NVIDIA GPU および Intel Gaudi アクセラレーターをサポートします。

  • RHEL AI モデルをデプロイする。

    • KServe ランタイムの vLLM ServingRuntime を 有効にしている。
    • Red Hat コンテナーレジストリーからモデルをダウンロードし、S3 互換オブジェクトストレージにアップロードしている。

手順

  1. 左側のメニューで、Data Science Projects をクリックします。

    Data Science Projects ページが開きます。

  2. モデルをデプロイするプロジェクトの名前をクリックします。

    プロジェクトの詳細ページが開きます。

  3. Models タブをクリックします。
  4. 次のいずれかの操作を実行します。

    • ​​Single-model serving platform タイルが表示された場合は、タイル上の Deploy model をクリックします。
    • タイルが表示されない場合は、Deploy model ボタンをクリックします。

    Deploy model ダイアログが開きます。

  5. Model deployment name フィールドに、デプロイするモデルの一意の名前を入力します。
  6. Serving runtime フィールドで、有効なランタイムを選択します。
  7. Model framework (name - version) リストから値を選択します。
  8. Number of model server replicas to deploy フィールドに値を指定します。
  9. Model server size リストから値を選択します。
  10. 次のオプションは、クラスターで GPU サポートを有効にし、アクセラレータープロファイルを作成した場合にのみ使用できます。

    1. Accelerator リストからアクセラレーターを選択します。
    2. 前の手順でアクセラレーターを選択した場合は、Number of accelerators フィールドで使用するアクセラレーターの数を指定します。
  11. オプション: Model route セクションで、Make deployed models available through an external route チェックボックスをオンにして、デプロイされたモデルを外部クライアントが利用できるようにします。
  12. デプロイされたモデルに対する推論リクエストにトークン認可を要求するには、次のアクションを実行します。

    1. Require token authorization を選択します。
    2. Service account name フィールドに、トークンが生成されるサービスアカウント名を入力します。
  13. モデルの場所を指定するには、次の一連のアクションのいずれかを実行します。

    • 既存の接続を使用するには

      1. Existing connection を選択します。
      2. Name リストから、以前に定義したデータ接続を選択します。
      3. Path フィールドに、指定したデータソース内のモデルを含むフォルダーパスを入力します。

        重要

        OpenVINO Model Server ランタイムには、モデルパスの指定方法に関する特定の要件があります。詳細は、OpenShift AI リリースノートの既知の問題 RHOAIENG-3025 を参照してください。

    • 新しい接続を使用するには

      1. モデルがアクセスできる新しいコネクションを定義するには、New connection を選択します。
      2. Name フィールドに、接続の一意の名前を入力します。
      3. Access key フィールドに、S3 互換オブジェクトストレージプロバイダーのアクセスキー ID を入力します。
      4. Secret key フィールドに、指定した S3 互換オブジェクトストレージアカウントのシークレットアクセスキーを入力します。
      5. Endpoint フィールドに、S3 互換オブジェクトストレージバケットのエンドポイントを入力します。
      6. Region フィールドに、S3 互換オブジェクトストレージアカウントのデフォルトのリージョンを入力します。
      7. Bucket フィールドに、S3 互換のオブジェクトストレージバケットの名前を入力します。
      8. Path フィールドに、データファイルが含まれる S3 互換オブジェクトストレージ内のフォルダーパスを入力します。

        重要

        OpenVINO Model Server ランタイムには、モデルパスの指定方法に関する特定の要件があります。詳細は、OpenShift AI リリースノートの既知の問題 RHOAIENG-3025 を参照してください。

  14. (オプション) Configuration parameters セクションでランタイムパラメーターをカスタマイズします。

    1. Additional serving runtime arguments の値を変更して、デプロイされたモデルの動作を定義します。
    2. Additional environment variables の値を変更して、モデルの環境で変数を定義します。

      Configuration parameters セクションには、事前に定義された提供ランタイムパラメーター(利用可能な場合)が表示されます。

      注記

      ポートまたはモデル提供ランタイム引数は特定の値を設定する必要があるため、変更しないでください。これらのパラメーターを上書きすると、デプロイメントが失敗する場合があります。

  15. Deploy をクリックします。

検証

  • デプロイされたモデルがプロジェクトの Models タブに表示され、ダッシュボードの Model Serving ページで Status 列にチェックマークが付いて表示されていることを確認します。

3.11.5. デプロイされたモデル提供ランタイムのパラメーターのカスタマイズ

特定のモデルをデプロイしたり、既存のモデルデプロイメントを強化したりするには、デフォルトのパラメーター以外のパラメーターが必要になる場合があります。このような場合は、デプロイメントのニーズに合わせて既存のランタイムのパラメーターを変更できます。

注記

ランタイムのパラメーターをカスタマイズすると、選択したモデルデプロイメントにのみ影響します。

前提条件

  • OpenShift AI 管理者権限を持つユーザーとして OpenShift AI にログインしている。
  • 単一モデル提供プラットフォームにモデルをデプロイしている。

手順

  1. OpenShift AI ダッシュボードの左側のメニューで、Model Serving をクリックします。

    Deployed models ページが開きます。

  2. カスタマイズするモデル名の横にあるアクションメニュー(⋮)をクリックし、Edit を選択します。

    Configuration parameters セクションには、事前に定義された提供ランタイムパラメーター(利用可能な場合)が表示されます。

  3. Configuration parameters セクションのランタイムパラメーターをカスタマイズします。

    1. Additional serving runtime arguments の値を変更して、デプロイされたモデルの動作を定義します。
    2. Additional environment variables の値を変更して、モデルの環境で変数を定義します。

      注記

      ポートまたはモデル提供ランタイム引数は特定の値を設定する必要があるため、変更しないでください。これらのパラメーターを上書きすると、デプロイメントが失敗する場合があります。

  4. ランタイムパラメーターのカスタマイズが完了したら、Redeploy をクリックして、変更内容でモデルを保存し、デプロイします。

検証

  • デプロイされたモデルがプロジェクトの Models タブに表示され、ダッシュボードの Model Serving ページで Status 列にチェックマークが付いて表示されていることを確認します。
  • 設定した引数と変数が、spec.predictor.model.argsspec.predictor.model.env に表示されるのを、次のいずれかのメソッドで確認します。

    • OpenShift コンソールから InferenceService YAML を確認します。
    • OpenShift CLI で以下のコマンドを使用します。

      oc get -o json inferenceservice <inferenceservicename/modelname> -n <projectname>

3.11.6. カスタマイズ可能なモデル提供ランタイムパラメーター

デプロイメントのニーズに合わせて、既存のモデル提供ランタイムのパラメーターを変更できます。

サポートされる各提供ランタイムのパラメーターの詳細については、次の表を参照してください。

提供ランタイムリソース

NVIDIA Triton Inference Server

Nvidia Triton Inference Server: モデルパラメーター

Caikit Text Generation Inference Server (Caikit-TGIS) ServingRuntime for KServe

Caikit NLP: Configuration
TGIS: Model configuration

Caikit Standalone ServingRuntime for KServe

Caikit NLP: 設定

OpenVINO Model Server

OpenVINO Model Server Features: 動的入力パラメーター

Text Generation Inference Server (TGIS) Standalone ServingRuntime for KServe

TGIS: モデル設定

vLLM ServingRuntime for KServe

VLLM: エンジン引数
OpenAI Compatible Server

3.11.7. モデル保存用の OCI コンテナーの使用

モデルを S3 バケットまたは URI に保存する代わりに、モデルを OCI コンテナーにアップロードできます。モデルの保存に OCI コンテナーを使用すると、次のことが可能になります。

  • 同じモデルを複数回ダウンロードすることを回避し、起動時間を短縮します。
  • ローカルにダウンロードされるモデルの数を減らすことで、ディスク領域の使用量を削減します。
  • 事前に取得したイメージを許可することで、モデルのパフォーマンスが向上します。

このガイドでは、OpenVINO モデルサーバー上の OCI イメージに保存されている、ONNX 形式の MobileNet v2-7 モデルを手動でデプロイする方法を説明します。

重要

モデルストレージに OCI コンテナーを使用する機能は、現在、Red Hat OpenShift AI 2.15 でテクノロジープレビュー機能として利用できます。テクノロジープレビュー機能は、Red Hat 製品のサービスレベルアグリーメント (SLA) の対象外であり、機能的に完全ではないことがあります。Red Hat では、実稼働環境での使用を推奨していません。テクノロジープレビュー機能は、最新の製品機能をいち早く提供して、開発段階で機能のテストを行い、フィードバックを提供していただくことを目的としています。

Red Hat のテクノロジープレビュー機能のサポート範囲に関する詳細は、テクノロジープレビュー機能のサポート範囲 を参照してください。

前提条件

  • ONNX 形式のモデルがある。
3.11.7.1. OCI イメージを作成し、コンテナーイメージにモデルを保存する

手順

  1. ローカルマシンから、ダウンロードしたモデルとサポートファイルの両方を保存して OCI イメージを作成するための一時ディレクトリーを作成します。

    cd $(mktemp -d)
  2. 一時ディレクトリー内に models フォルダーを作成し、モデルをダウンロードします。

    mkdir -p models/1
    
    DOWNLOAD_URL=https://github.com/onnx/models/raw/main/validated/vision/classification/mobilenet/model/mobilenetv2-7.onnx
    curl -L $DOWNLOAD_URL -O --output-dir models/1/
    注記

    OpenVINO では、モデルのバージョン管理に使用する番号付きサブディレクトリーが必要なため、サブディレクトリー 1 が使用されます。OpenVINO を使用していない場合は、OCI コンテナーイメージを使用するために 1 サブディレクトリーを作成する必要はありません。

  3. 次の内容を含む Docker ファイルを Containerfile という名前で作成します。

    FROM registry.access.redhat.com/ubi9/ubi-micro:latest
    COPY --chown=0:0 models /models
    RUN chmod -R a=rX /models
    
    # nobody user
    USER 65534
    注記
    • この例では、ubi9-micro がベースコンテナーイメージとして使用されています。KServe はシェルを使用してモデルファイルがモデルサーバーにアクセスできることを確認するため、scratch などのシェルを提供しない空のイメージは使用できません。
    • コピーされたモデルファイルの所有権と読み取り権限は、root グループに付与されます。OpenShift は、ランダムなユーザー ID と root グループ ID を使用してコンテナーを実行します。グループの所有権を変更すると、確実にモデルサーバーがグループにアクセスできるようになります。
  4. tree コマンドを使用して、モデルが表示されているディレクトリー構造に従っていることを確認します。

    tree
    
    .
    ├── Containerfile
    └── models
        └── 1
            └── mobilenetv2-7.onnx
  5. Podman を使用して OCI コンテナーイメージを作成し、レジストリーにアップロードします。たとえば、レジストリーとして Quay を使用する場合は次のようになります。

    podman build --format=oci -t quay.io/<user_name>/<repository_name>:<tag_name> .
    podman push quay.io/<user_name>/<repository_name>:<tag_name>
    注記

    リポジトリーがプライベートの場合は、コンテナーイメージをアップロードする前に、レジストリーに対して認証されていることを確認してください。

3.11.7.2. パブリックリポジトリーから OCI イメージに保存されたモデルをデプロイする
注記

KServe では、デフォルトでモデルはクラスター外部に公開され、認可によって保護されません。

  1. モデルをデプロイするための namespace を作成します。

    oc new-project oci-model-example
  2. OpenShift AI アプリケーションプロジェクトの kserve-ovms テンプレートを使用して ServingRuntime リソースを作成し、新しい namespace で OpenVINO モデルサーバーを設定します。

    oc process -n redhat-ods-applications -o yaml kserve-ovms | oc apply -f -
    1. ServingRuntimekserve-ovms の名前で作成されたことを確認します。

      oc get servingruntimes
      
      NAME          DISABLED   MODELTYPE     CONTAINERS         AGE
      kserve-ovms              openvino_ir   kserve-container   1m
  3. 次の値を持つ InferenceService YAML リソースを作成します。

    apiVersion: serving.kserve.io/v1beta1
    kind: InferenceService
    metadata:
      name: sample-isvc-using-oci
    spec:
      predictor:
        model:
          runtime: kserve-ovms # Ensure this matches the name of the ServingRuntime resource
          modelFormat:
            name: onnx
          storageUri: oci://quay.io/<user_name>/<repository_name>:<tag_name>
    重要

    ServingRuntime および InferenceService 設定では、リソース制限は設定されません。

検証

InferenceService リソースを作成すると、KServe は storageUri フィールドによって参照される OCI イメージに保存されているモデルをデプロイします。次のコマンドを実行して、デプロイメントのステータスを確認します。

oc get inferenceservice

NAME                    URL                                                       READY   PREV   LATEST   PREVROLLEDOUTREVISION   LATESTREADYREVISION                     AGE
sample-isvc-using-oci   https://sample-isvc-using-oci-oci-model-example.example   True           100                              sample-isvc-using-oci-predictor-00001   1m
3.11.7.3. OCI イメージに保存されたモデルをプライベートリポジトリーからデプロイする

プライベート OCI リポジトリーから保存されたモデルをデプロイするには、イメージプルシークレットを設定する必要があります。イメージプルシークレットの作成の詳細は、イメージプルシークレットの使用 を参照してください。

  1. 前のセクションの手順に従ってモデルをデプロイします。ただし、手順 3 で InferenceService を作成するときに、spec.predictor.imagePullSecrets フィールドにプルシークレットを指定します。

    apiVersion: serving.kserve.io/v1beta1
    kind: InferenceService
    metadata:
      name: sample-isvc-using-private-oci
    spec:
      predictor:
        model:
          runtime: kserve-ovms
          modelFormat:
            name: onnx
          storageUri: oci://quay.io/<user_name>/<repository_name>:<tag_name>
        imagePullSecrets: # Specify image pull secrets to use for fetching container images (including OCI model images)
        - name: <pull-secret-name>

3.12. シングルモデルサービングプラットフォームにデプロイされたモデルに対する推論リクエストの実行

シングルモデルサービングプラットフォームを使用してモデルをデプロイすると、そのモデルは、API リクエストを使用してアクセスできるサービスとして利用できます。これにより、データ入力に基づく予測を返すことができます。API リクエストを使用してデプロイされたモデルと対話するには、モデルの推論エンドポイントを知っておく必要があります。

さらに、トークン認可を有効にすることで推論エンドポイントを保護した場合は、推論リクエストで認可トークンを指定できるように、認可トークンへのアクセス方法を理解する必要があります。

3.12.1. デプロイされたモデルの認可トークンにアクセスする

トークン認可を有効にすることで推論エンドポイントを保護した場合は、推論リクエストで認可トークンを指定できるように、認可トークンへのアクセス方法を理解する必要があります。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • シングルモデルサービングプラットフォームを使用してモデルをデプロイした。

手順

  1. OpenShift AI ダッシュボードで、Data Science Projects をクリックします。

    Data Science Projects ページが開きます。

  2. デプロイされたモデルが含まれるプロジェクトの名前をクリックします。

    プロジェクトの詳細ページが開きます。

  3. Models タブをクリックします。
  4. Models and model servers リストで、モデルのセクションを展開します。

    認可トークンは、Token authorization セクションの Token secret フィールドに表示されます。

  5. オプション: 推論リクエストで使用する認可トークンをコピーするには、トークン値の横に表示される Copy ボタン ( osd copy ) をクリックします。

3.12.2. デプロイされたモデルの推論エンドポイントにアクセスする

デプロイされたモデルに対して推論リクエストを行うには、利用可能な推論エンドポイントへのアクセス方法を知っておく必要があります。

サポートされているランタイムとコマンド例で使用するパスのリストは、推論エンドポイント を参照してください。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • シングルモデルサービングプラットフォームを使用してモデルをデプロイした。
  • デプロイされたモデルに対してトークン認可を有効にしている場合は、関連付けられたトークン値があります。

手順

  1. OpenShift AI ダッシュボードで、Model Serving をクリックします。

    モデルの推論エンドポイントは、Inference endpoint フィールドに表示されます。

  2. モデルで実行するアクション (およびモデルがそのアクションをサポートしているかどうか) に応じて、表示されている推論エンドポイントをコピーし、URL の末尾にパスを追加します。
  3. エンドポイントを使用して、デプロイされたモデルに API リクエストを送信します。

3.13. シングルモデルサービングプラットフォームのモニタリング設定

シングルモデルサービングプラットフォームには、KServe コンポーネントの サポート対象ランタイム のメトリクスが含まれています。KServe は独自のメトリクスを生成せず、基盤となるモデルサービングランタイムに依存してメトリクスを提供します。デプロイされたモデルで利用可能なメトリクスセットは、モデルを提供するランタイムにより異なります。

KServe のランタイムメトリクスに加え、OpenShift Service Mesh の監視も設定できます。OpenShift Service Mesh メトリクスは、メッシュ内のコンポーネント間の依存関係とトラフィックフローを理解するのに役立ちます。

前提条件

  • OpenShift クラスターのクラスター管理者権限を持っている。
  • OpenShift Service Mesh および Knative Serving インスタンスを作成し、KServe をインストールしている。
  • OpenShift コマンドラインインターフェイス (CLI) がダウンロードおよびインストールされている。OpenShift CLI のインストール を参照してください。
  • ユーザー定義ワークフローの監視に使用する config map の作成 について理解している。この手順でも同様のステップを実行します。
  • OpenShift でユーザー定義プロジェクトの モニタリングを有効にする方法 について理解している。この手順でも同様のステップを実行します。
  • メトリクスを監視するユーザーに、monitoring-rules-view ロールを 割り当て ている。

手順

  1. ターミナルウィンドウで、クラスター管理者として OpenShift クラスターにまだログインしていない場合は、次の例に示すように OpenShift CLI にログインします。

    $ oc login <openshift_cluster_url> -u <admin_username> -p <password>
  2. uwm-cm-conf.yaml という YAML ファイルに次の内容の ConfigMap オブジェクトを定義します。

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: user-workload-monitoring-config
      namespace: openshift-user-workload-monitoring
    data:
      config.yaml: |
        prometheus:
          logLevel: debug
          retention: 15d

    user-workload-monitoring-config オブジェクトは、ユーザー定義プロジェクトを監視するコンポーネントを設定します。保持時間が推奨値の 15 日に設定されていることを確認します。

  3. 設定を適用して user-workload-monitoring-config オブジェクトを作成します。

    $ oc apply -f uwm-cm-conf.yaml
  4. uwm-cm-enable.yaml という YAML ファイルに、次の内容で、別の ConfigMap オブジェクトを定義します。

    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: cluster-monitoring-config
      namespace: openshift-monitoring
    data:
      config.yaml: |
        enableUserWorkload: true

    cluster-monitoring-config オブジェクトを使用して、ユーザー定義プロジェクトの監視を有効にします。

  5. 設定を適用して、cluster-monitoring-config オブジェクトを作成します。

    $ oc apply -f uwm-cm-enable.yaml
  6. 次のように、ServiceMonitor オブジェクトと PodMonitor オブジェクトを作成して、サービスメッシュコントロールプレーンのメトリックを監視します。

    1. 次の内容を含む istiod-monitor.yaml YAML ファイルを作成します。

      apiVersion: monitoring.coreos.com/v1
      kind: ServiceMonitor
      metadata:
        name: istiod-monitor
        namespace: istio-system
      spec:
        targetLabels:
        - app
        selector:
          matchLabels:
            istio: pilot
        endpoints:
        - port: http-monitoring
          interval: 30s
    2. 指定された istio-system namespace に ServiceMonitor CR をデプロイします。

      $ oc apply -f istiod-monitor.yaml

      以下のような出力が表示されます。

      servicemonitor.monitoring.coreos.com/istiod-monitor created
    3. 次の内容を含む istio-proxies-monitor.yaml YAML ファイルを作成します。

      apiVersion: monitoring.coreos.com/v1
      kind: PodMonitor
      metadata:
        name: istio-proxies-monitor
        namespace: istio-system
      spec:
        selector:
          matchExpressions:
          - key: istio-prometheus-ignore
            operator: DoesNotExist
        podMetricsEndpoints:
        - path: /stats/prometheus
          interval: 30s
    4. 指定された istio-system namespace に PodMonitor CR をデプロイします。

      $ oc apply -f istio-proxies-monitor.yaml

      以下のような出力が表示されます。

      podmonitor.monitoring.coreos.com/istio-proxies-monitor created

3.14. シングルモデルサービングプラットフォームのモデルサービングランタイムメトリクスを表示する

クラスター管理者は、シングルモデルサービングプラットフォームの監視を設定する際に、管理者以外のユーザーは OpenShift Web コンソールを使用して、KServe コンポーネントのモデルサービングランタイムメトリクスを表示できます。

前提条件

手順

  1. OpenShift Web コンソールにログインします。
  2. Developer パースペクティブに切り替えます。
  3. 左側のメニューで、Observe をクリックします。
  4. プロジェクトメトリクスの監視 で説明されているように、Web コンソールを使用して、モデルサービングランタイムメトリクスのクエリーを実行します。OpenShift Service Mesh に関連付けられたメトリクスのクエリーも実行できます。以下に例を示します。

    1. 次のクエリーは、vLLM ランタイムでデプロイされたモデルについて、一定期間内に成功した推論リクエストの数を表示します。

      sum(increase(vllm:request_success_total{namespace=${namespace},model_name=${model_name}}[${rate_interval}]))
      注記

      特定の vLLM メトリクスは、デプロイされたモデルによって推論要求が処理された後にのみ使用できます。これらのメトリクスを生成して表示するには、まずモデルに対して推論リクエストを行う必要があります。

    2. 次のクエリーは、スタンドアロン TGIS ランタイムでデプロイされたモデルについて、一定期間内に成功した推論リクエストの数を表示します。

      sum(increase(tgi_request_success{namespace=${namespace}, pod=~${model_name}-predictor-.*}[${rate_interval}]))
    3. 次のクエリーは、Caikit Standalone ランタイムでデプロイされたモデルについて、一定期間内に成功した推論リクエストの数を表示します。

      sum(increase(predict_rpc_count_total{namespace=${namespace},code=OK,model_id=${model_name}}[${rate_interval}]))
    4. 次のクエリーは、OpenVINO Model Server ランタイムでデプロイされたモデルについて、一定期間内に成功した推論リクエストの数を表示します。

      sum(increase(ovms_requests_success{namespace=${namespace},name=${model_name}}[${rate_interval}]))

3.15. モデルのパフォーマンスのモニタリング

シングルモデルサービングプラットフォームでは、プラットフォームにデプロイされている特定のモデルのパフォーマンスメトリクスを表示できます。

3.15.1. デプロイされたモデルのパフォーマンスメトリクスの表示

シングルモデルサービングプラットフォームにデプロイされている特定のモデルについて、次のメトリクスを監視できます。

  • リクエスト数 - 特定のモデルに対して失敗または成功したリクエストの数。
  • 平均応答時間 (ミリ秒) - 特定のモデルがリクエストに応答するまでにかかる平均時間。
  • CPU 使用率 (%) - 特定のモデルによって現在使用されている、モデルレプリカごとの CPU 制限の割合。
  • メモリー使用率 (%) - 特定のモデルによって使用されているモデルレプリカごとのメモリー制限の割合。

これらのメトリクスの時間範囲と更新間隔を指定すると、使用量のピーク時間帯や、指定した時間におけるモデルのパフォーマンスなどを判断するのに役立ちます。

前提条件

  • Red Hat OpenShift AI がインストール済みである。
  • クラスター管理者が、OpenShift クラスター上のユーザー定義プロジェクトに対してユーザーワークロードモニタリング (UWM) を有効化している。詳細は、ユーザー定義プロジェクトのモニタリングの有効化 および シングルモデルサービングプラットフォームのモニタリングの設定 を参照してください。
  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • 次のダッシュボード設定オプションは、次のようにデフォルト値に設定されている。

    disablePerformanceMetrics:false
    disableKServeMetrics:false

    詳細は、ダッシュボード設定オプション を参照してください。

  • プリインストールされたランタイムを使用して、シングルモデルサービングプラットフォームにモデルをデプロイしている。

    注記

    メトリクスは、プリインストールされたモデルサービングランタイム、またはプリインストールされたランタイムから複製されたカスタムランタイムを使用してデプロイされたモデルに対してのみサポートされます。

手順

  1. OpenShift AI ダッシュボードのナビゲーションメニューから、Data Science Projects をクリックします。

    Data Science Projects ページが開きます。

  2. 監視するデータサイエンスモデルが含まれているプロジェクトの名前をクリックします。
  3. プロジェクトの詳細ページで、Models タブをクリックします。
  4. 使用するモデルを選択します。
  5. Endpoint performance タブで、次のオプションを設定します。

    • 時間範囲 - メトリクスを追跡する期間を指定します。1 時間、24 時間、7 日、30 日のいずれかの値を選択できます。
    • 更新間隔 - (最新のデータを表示するために) メトリクスページのグラフを更新する頻度を指定します。15 秒、30 秒、1 分、5 分、15 分、30 分、1 時間、2 時間、1 日の値のいずれかを選択できます。
  6. 下にスクロールすると、リクエスト数、平均応答時間、CPU 使用率、メモリー使用率のデータグラフが表示されます。

検証

Endpoint performance タブには、モデルのメトリクスのグラフが表示されます。

3.16. モデルサービングランタイムの最適化

オプションで、OpenShift AI で利用可能なプリインストールされたモデルサービングランタイムを拡張して、最適化された推論、レイテンシーの短縮、微調整されたリソース割り当てなどの追加のメリットと機能を活用することができます。

3.16.1. vLLM モデルサービングランタイムの最適化

vLLM ServingRuntime for KServe ランタイムを設定して、大規模言語モデル (LLM) の推論時間を最適化するための並列処理技術である投機的デコーディングを使用できます。

ランタイムを設定して、Vision-Language Model (VLM) の推論をサポートすることもできます。VLM は、視覚データとテキストデータの両方を統合するマルチモーダルモデルのサブセットです。

投機的デコーディングまたはマルチモーダル推論用に vLLM ServingRuntime for KServe ランタイムを設定するには、vLLM モデルサービングランタイムに引数をさらに追加する必要があります。

前提条件

  • OpenShift AI 管理者権限を持つユーザーとして OpenShift AI にログインしている。
  • プリインストールされた vLLM ServingRuntime for KServe ランタイムを使用した場合は、ランタイムを複製してカスタムバージョンを作成している。プリインストールされている vLLM ランタイムの複製の詳細は、シングルモデルサービングプラットフォーム用のカスタムモデルサービングランタイムの追加 を参照してください。
  • ドラフトモデルで投機的デコーディングに vLLM モデルサービングランタイムを使用している場合は、元のモデルと投機的モデルを S3 互換オブジェクトストレージ内の同じフォルダーに保存している。

手順

  1. OpenShift AI ダッシュボードから、Settings > Serving runtimes をクリックします。

    Serving runtimes ページが開き、すでにインストールされ有効になっているモデルサービングランタイムが表示されます。

  2. 作成したカスタム vLLM モデルサービングランタイムを見つけて、ランタイムの横にあるアクションメニュー (⋮) をクリックし、Edit を選択します。

    埋め込み YAML エディターが開き、カスタムモデルサービングランタイムの内容が表示されます。

  3. プロンプトで n-gram を一致させて投機的デコーディングを行うために vLLM モデルサービングランタイムを設定するには、以下を実行します。

    1. 次の引数を追加します。

      containers:
        - args:
            - --speculative-model=[ngram]
            - --num-speculative-tokens=<NUM_SPECULATIVE_TOKENS>
            - --ngram-prompt-lookup-max=<NGRAM_PROMPT_LOOKUP_MAX>
            - --use-v2-block-manager
    2. <NUM_SPECULATIVE_TOKENS><NGRAM_PROMPT_LOOKUP_MAX> を独自の値に置き換えます。

      注記

      推論スループットは、n-gram による推測に使用されるモデルによって異なります。

  4. ドラフトモデルで投機的デコーディングに vLLM モデルサービングランタイムを設定するには、以下を実行します。

    1. --model 引数を削除します。

      containers:
        - args:
            - --model=/mnt/models
    2. 次の引数を追加します。

      containers:
        - args:
            - --port=8080
            - --served-model-name={{.Name}}
            - --distributed-executor-backend=mp
            - --model=/mnt/models/<path_to_original_model>
            - --speculative-model=/mnt/models/<path_to_speculative_model>
            - --num-speculative-tokens=<NUM_SPECULATIVE_TOKENS>
            - --use-v2-block-manager
    3. <path_to_speculative_model><path_to_original_model> を、S3 互換オブジェクトストレージ上の投機的モデルと元のモデルへのパスに置き換えます。
    4. <NUM_SPECULATIVE_TOKENS> を独自の値に置き換えます。
  5. マルチモーダル推論用に vLLM モデルサービングランタイムを設定するには、以下を実行します。

    1. 次の引数を追加します。

      containers:
        - args:
            - --trust-remote-code
      注記

      --trust-remote-code 引数は、信頼できるソースからのモデルでのみ使用してください。

  6. Update をクリックします。

    Serving runtimes ページが開き、インストール済みランタイムのリストが表示されます。更新したカスタムモデルサービングランタイムが表示されていることを確認します。

  7. シングルモデルサービングプラットフォームへのモデルのデプロイ の説明に従って、カスタムランタイムを使用してモデルをデプロイします。

検証

  • 投機的デコーディング用に vLLM モデルサービングランタイムを設定している場合は、次のサンプルコマンドを使用して、デプロイされたモデルへの API リクエストを確認します。

    curl -v https://<inference_endpoint_url>:443/v1/chat/completions
    -H "Content-Type: application/json"
    -H "Authorization: Bearer <token>"
  • マルチモーダル推論用に vLLM モデルサービングランタイムを設定している場合は、次のサンプルコマンドを使用して、デプロイした Vision-Language Model (VLM) への API リクエストを確認します。

    curl -v https://<inference_endpoint_url>:443/v1/chat/completions
    -H "Content-Type: application/json"
    -H "Authorization: Bearer <token>"
    -d '{"model":"<model_name>",
         "messages":
            [{"role":"<role>",
              "content":
                 [{"type":"text", "text":"<text>"
                  },
                  {"type":"image_url", "image_url":"<image_url_link>"
                  }
                 ]
             }
            ]
        }'

3.17. パフォーマンスの最適化とチューニング

3.17.1. LLM 機能アプリケーションの GPU 要件の判断

OpenShift AI でホストされる Large Language Model (LLM)が搭載するアプリケーションに対して GPU を選択する際に考慮すべき要因がいくつかあります。

次のガイドラインは、モデルのサイズや予想される使用方法に応じて、アプリケーションのハードウェア要件を決定するのに役立ちます。

  • メモリーのニーズ を見積もる:一般的なルールは、16 ビットの精度で N パラメーターを持つモデルでは、GPU メモリーを約 2N バイト必要とすることです。たとえば、8-billion-parameter モデルには約 16GB の GPU メモリーが必要ですが、70-billion-parameter モデルには約 140 GB が必要です。
  • 定量化: メモリーの要件を低減し、スループットを向上させるには、定量(quantization)を使用して、INT8、FP8、INT4 などの低精度形式でモデルを読み込または実行できます。これにより、モデルの精度が大幅に低下し、メモリーフットプリントが削減されます。

    注記

    KServe モデル提供ランタイムの vLLM ServingRuntime は、いくつかの数量メソッドをサポートします。サポート対象の実装および互換性のあるハードウェアの詳細は、Supported hardware for quantization kernels を参照してください。

  • キーバリューキャッシュの追加メモリー:モデルの重みに加えて、GPU メモリーも注意キー値(KV)キャッシュを格納するため に必要です。これにより、要求の数と各リクエストのシーケンス長が増えます。これにより、特に大規模なモデルに対して、リアルタイムアプリケーションのパフォーマンスに影響する可能性があります。
  • 推奨される GPU 設定:

    • 小規模なモデル(1B-8B パラメーター): この範囲内のモデルでは、通常、少数の同時ユーザーをサポートするのに、24 GB のメモリーを持つ GPU で十分です。
    • 中規模モデル(10B-34B パラメーター):

      • 20B パラメーター下のモデルには、少なくとも 48 GB の GPU メモリーが必要です。
      • 20B - 34B パラメーターの間にあるモデルでは、1 つの GPU に少なくとも 80GB 以上のメモリーが必要です。
    • 大規模なモデル(70B パラメーター): この範囲のモデルは、数千の並列処理技術を使用して、複数の GPU に分散する必要がある場合があります。テレッサー並列処理により、モデルは複数の GPU にまたがることができ、KV キャッシュの追加メモリーを解放してトークン間のレイテンシーを改善し、最大バッチサイズを増加させます。GPU に NVLink などの高速相互接続がある場合、テクスレッター並列処理は最適に機能します。
    • 非常に大きなモデル(405B パラメーター): 非常に大きなモデルの場合は、メモリーの需要を減らすために定量化を推奨します。パイプラインの並列処理を使用して、複数のGPUをまたいで、あるいは2台サーバー間でこのモデルを分散することもできます。このアプローチにより、1 台のサーバーのメモリー制限を超えてスケーリングできますが、最適なパフォーマンスを得るには、サーバー間通信を慎重に管理する必要があります。

最良の結果を得るには、パフォーマンスとメモリーの要件を満たすための並列処理や量などの手法を使用して、必要に応じて小規模なモデルに拡大して、最高のモデルに拡大します。

関連情報

3.17.2. テキスト消費および返された生成(RAG)アプリケーションのパフォーマンスに関する考慮事項

テキスト消費と RAG アプリケーション、およびユーザーがアップロードした大きなドキュメントを処理する LLM 機能サービスのために考慮すべき他の要因があります。

  • 長い入力シーケンス:入力シーケンスの 長さは、一般的なチャットアプリケーションよりも大幅に長くなる可能性があります。各ユーザークエリーに大規模なプロンプトが含まれる場合や、アップロードしたドキュメントなどのコンテキストが大量に含まれる場合です。入力シーケンスの長さが長くなると、事前入力時間 が長くなります。応答を生成する前にモデルが最初の入力シーケンスを処理するのにかかる時間です。これにより、Time-to-First-Token (TTFT) が高くなる可能性があります。TTFT が長くなると、アプリケーションの応答性に影響が出る可能性があります。最適なユーザーエクスペリエンスを得るために、このレイテンシーを最小限に抑えます。
  • KV キャッシュの使用: 長いシーケンスでは、キー値(KV)キャッシュに追加の GPU メモリーが必要になります。KV キャッシュは、生成時のモデルのパフォーマンスを向上させるために、中間的なデータを格納します。要求ごとに高い KV キャッシュの使用率が高くなるには、GPU メモリーが十分にあるハードウェア設定が必要です。これは、各要求により合計メモリー負荷が追加されるため、複数のユーザーがモデルを同時にクエリーしている場合に特に重要になります。
  • 最適なハードウェア設定: 応答性を維持し、メモリーのボトルネックを回避するために、十分なメモリーを持つ GPU 設定を選択します。たとえば、単一の 24 GB GPU で 8B モデルを実行する代わりに、大きな GPU (48GB または 80GB など)にデプロイするか、複数の GPU にまたがってデプロイする代わりに、KV キャッシュでメモリーヘッドルームを増やしてトークン間のレイテンシーを短縮することでパフォーマンスを向上できます。テレッサー並列処理を備えたマルチ GPU セットアップは、メモリーの需要を管理し、より大きな入力シーケンスの効率を向上させるのにも役立ちます。

要約すると、ドキュメントベースのアプリケーションに最適な応答性とスケーラビリティを確保するには、GPU メモリー容量が高いハードウェアに優先順位を付け、長い入力シーケンスと KV キャッシュ のメモリー要件の増加を処理するためにマルチ GPU 設定も検討する必要があります。

3.17.3. パフォーマンスメトリクスの推論

遅延スループット、および 100 万トークンごとのコスト は、推測中にモデルのレスポンス生成効率を評価する際に考慮すべき主要なメトリクスです。これらのメトリクスは、モデルの推論パフォーマンスの包括的なビューを提供し、さまざまなユースケースに合わせて速度、効率、およびコストのバランスを取るのに役立ちます。

3.17.3.1. Latency

レイテンシー は、対話型またはリアルタイムのユースケースにとって重要であり、次のメトリクスを使用して測定されます。

  • Time-to-First-Token (TTFT): 最初の要求と最初のトークンの生成との間の遅延(ミリ秒単位)。このメトリクスは、レスポンスのストリーミングに重要です。
  • Inter-Token Latency (ITL): 最初のトークンの後に後続の各トークンを生成するのにかかった時間(ミリ秒単位)。またストリーミングに関連します。
  • time -Per-Output-Token (TPOT): ストリーミング以外のリクエストの場合、出力シーケンスで各トークンを生成するのにかかった平均時間(ミリ秒単位)。
3.17.3.2. Throughput

スループット は、モデルサーバーの全体的な効率を測定し、次のメトリックで表されます。

  • 1 秒あたりのトークン数(TPS): すべてのアクティブなリクエストで 1 秒あたりに生成されたトークンの総数。
  • 1 秒 あたりのリクエスト数(RPS): 1 秒あたりのリクエスト数。応答時間などの RPS は、シーケンスの長さに敏感です。
3.17.3.3. 数百万トークンあたりのコスト

ミリ あたりのトークンあたりのコストは、モデルの推論の費用対効果を測定し、生成された数百万 のトークンごとに経費を示します。このメトリクスは、モデルをデプロイするための経済性とスケーラビリティの両方を評価するのに役立ちます。

3.17.4. CUDA メモリー不足エラーを解決する

場合によっては、使用されているモデルとハードウェアアクセラレーターに応じて、TGIS メモリー自動チューニングアルゴリズムが長いシーケンスを処理するために必要な GPU メモリーの量を過小評価することがあります。この間違った計算により、モデルサーバーから Compute Unified Architecture (CUDA) のメモリー不足 (OOM) エラー応答が発生する可能性があります。その場合は、次の手順で説明するように、TGIS モデルサービングランタイムでパラメーターを更新または追加する必要があります。

前提条件

  • OpenShift AI 管理者権限を持つユーザーとして OpenShift AI にログインしている。

手順

  1. OpenShift AI ダッシュボードから、Settings > Serving runtimes をクリックします。

    Serving runtimes ページが開き、すでにインストールされ有効になっているモデルサービングランタイムが表示されます。

  2. モデルのデプロイに使用したランタイムに基づき、次のいずれかのアクションを実行します。

    • プリインストールされた TGIS Standalone ServingRuntime for KServe ランタイムを使用した場合は、ランタイムを複製してカスタムバージョンを作成してから残りの手順を実行します。プリインストールされている TGIS ランタイムの複製に関する詳細は、シングルモデルサービングプラットフォーム用のカスタムモデルサービングランタイムの追加 を参照してください。
    • すでにカスタム TGIS ランタイムを使用している場合は、ランタイムの横にあるアクションメニュー (⋮) をクリックし、Edit を選択します。

      埋め込み YAML エディターが開き、カスタムモデルサービングランタイムの内容が表示されます。

  3. BATCH_SAFETY_MARGIN 環境変数を追加または更新し、値を 30 に設定します。同様に、ESTIMATE_MEMORY_BATCH_SIZE 環境変数を追加または更新し、値を 8 に設定します。

    spec:
      containers:
        env:
        - name: BATCH_SAFETY_MARGIN
          value: 30
        - name: ESTIMATE_MEMORY_BATCH
          value: 8
    注記

    BATCH_SAFETY_MARGIN パラメーターは、OOM 状態を回避するための安全マージンとして保持する空き GPU メモリーの割合を設定します。BATCH_SAFETY_MARGIN のデフォルト値は 20 です。ESTIMATE_MEMORY_BATCH_SIZE パラメーターは、メモリー自動チューニングアルゴリズムで使用されるバッチサイズを設定します。ESTIMATE_MEMORY_BATCH_SIZE のデフォルト値は 16 です。

  4. Update をクリックします。

    Serving runtimes ページが開き、インストール済みランタイムのリストが表示されます。更新したカスタムモデルサービングランタイムが表示されていることを確認します。

  5. モデルを再デプロイしてパラメーターの更新を反映するには、次のアクションを実行します。

    1. OpenShift AI ダッシュボードから、Model Serving > Deployed Models をクリックします。
    2. 再デプロイするモデルを見つけて、モデルの横にあるアクションメニュー (⋮) をクリックし、Delete を選択します。
    3. シングルモデルサービングプラットフォームへのモデルのデプロイ の説明に従って、モデルを再デプロイします。

検証

  • モデルサーバーから正常な応答を受信し、CUDA OOM エラーが表示されなくなります。

3.18. NVIDIA NIM モデルサービングプラットフォームについて

NVIDIA NIM モデルサービングプラットフォーム で NVIDIA NIM 推論サービスを使用してモデルを展開できます。

NVIDIA AI Enterprise の一部である NVIDIA NIM は、クラウド、データセンター、ワークステーションをまたいで推論を実行する高性能 AI モデルの、セキュアで信頼性の高いデプロイメントのために設計されたマイクロサービスのセットです。

重要

現在、NVIDIA NIM モデルサービングプラットフォーム は Red Hat OpenShift AI でテクノロジープレビュー機能としてのみ使用できます。テクノロジープレビュー機能は、Red Hat 製品のサービスレベルアグリーメント (SLA) の対象外であり、機能的に完全ではないことがあります。Red Hat では、実稼働環境での使用を推奨していません。テクノロジープレビュー機能は、最新の製品機能をいち早く提供して、開発段階で機能のテストを行い、フィードバックを提供していただくことを目的としています。

Red Hat のテクノロジープレビュー機能のサポート範囲に関する詳細は、テクノロジープレビュー機能のサポート範囲 を参照してください。

関連情報

3.18.1. NVIDIA NIM モデルサービングプラットフォームの有効化

管理者は、Red Hat OpenShift AI ダッシュボードを使用して、NVIDIA NIM モデルサービングプラットフォームを有効にできます。

重要

現在、NVIDIA NIM モデルサービングプラットフォーム は Red Hat OpenShift AI でテクノロジープレビュー機能としてのみ使用できます。テクノロジープレビュー機能は、Red Hat 製品のサービスレベルアグリーメント (SLA) の対象外であり、機能的に完全ではないことがあります。Red Hat では、実稼働環境での使用を推奨していません。テクノロジープレビュー機能は、最新の製品機能をいち早く提供して、開発段階で機能のテストを行い、フィードバックを提供していただくことを目的としています。

Red Hat のテクノロジープレビュー機能のサポート範囲に関する詳細は、テクノロジープレビュー機能のサポート範囲 を参照してください。

注記

以前に OpenShift AI 2.14 または 2.15 で NVIDIA NIM モデル提供プラットフォーム を有効にし、2.16 にアップグレードした場合は、NVIDIA AI Enterprise ライセンスキーを再入力してから、NVIDIA NIM モデルサービス提供プラットフォームを再度有効にします。

前提条件

手順

  1. OpenShift AI ホームページで、Explore をクリックします。
  2. Explore ページで、NVIDIA NIM タイルを見つけます。
  3. アプリケーションタイルで Enable をクリックします。
  4. NVIDIA AI Enterprise ライセンスキーを入力し、Submit をクリックします。

検証

  • 有効にした NVIDIA NIM アプリケーションが Enabled ページに表示されます。

3.18.2. NVIDIA NIM モデルサービングプラットフォームにモデルをデプロイする

NVIDIA NIM モデルサービングプラットフォーム を有効にすると、プラットフォーム上で NVIDIA 向けに最適化されたモデルのデプロイを開始できます。

重要

現在、NVIDIA NIM モデルサービングプラットフォーム は Red Hat OpenShift AI でテクノロジープレビュー機能としてのみ使用できます。テクノロジープレビュー機能は、Red Hat 製品のサービスレベルアグリーメント (SLA) の対象外であり、機能的に完全ではないことがあります。Red Hat では、実稼働環境での使用を推奨していません。テクノロジープレビュー機能は、最新の製品機能をいち早く提供して、開発段階で機能のテストを行い、フィードバックを提供していただくことを目的としています。

Red Hat のテクノロジープレビュー機能のサポート範囲に関する詳細は、テクノロジープレビュー機能のサポート範囲 を参照してください。

前提条件

  • Red Hat OpenShift AI にログインしている。
  • OpenShift AI グループを使用している場合は、OpenShift のユーザーグループまたは管理者グループ (rhoai-usersrhoai-admins など) に属している。
  • NVIDIA NIM モデルサービングプラットフォーム を有効にした。
  • データサイエンスプロジェクトを作成した。
  • モデルサーバーでグラフィックスプロセッシングユニット (GPU) を使用する場合は、OpenShift AI で GPU サポートを有効にしている。NVIDIA GPU の有効化 を参照してください。

    注記

    OpenShift AI 2.15 では、Red Hat はモデルサービング用に NVIDIA GPU アクセラレーターのみをサポートしています。

手順

  1. 左側のメニューで、Data Science Projects をクリックします。

    Data Science Projects ページが開きます。

  2. モデルをデプロイするプロジェクトの名前をクリックします。

    プロジェクトの詳細ページが開きます。

  3. Models タブをクリックします。
  4. ​​NVIDIA NIM model serving platform タイルで、Deploy model をクリックします。

    Deploy model ダイアログが開きます。

  5. モデルをデプロイするためのプロパティーを次のように設定します。

    1. Model deployment name フィールドに、デプロイメントの一意の名前を入力します。
    2. NVIDIA NIM リストから、デプロイする NVIDIA NIM モデルを選択します。
    3. NVIDIA NIM storage size フィールドで、NVIDIA NIM モデルを保存するために作成されるクラスターストレージインスタンスのサイズを指定します。
    4. Number of model server replicas to deploy フィールドに値を指定します。
    5. Model server size リストから値を選択します。
    6. Accelerator リストから、NVIDIA GPU アクセラレーターを選択します。

      Number of accelerators フィールドが表示されます。

    7. Number of accelerators フィールドで、使用するアクセラレーターの数を指定します。デフォルト値は 1 です。
    8. Deploy をクリックします。

検証

  • デプロイされたモデルがプロジェクトの Models タブに表示され、ダッシュボードの Model Serving ページで Status 列にチェックマークが付いて表示されていることを確認します。

法律上の通知

Copyright © 2024 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
Red Hat logoGithubRedditYoutubeTwitter

詳細情報

試用、購入および販売

コミュニティー

Red Hat ドキュメントについて

Red Hat をお使いのお客様が、信頼できるコンテンツが含まれている製品やサービスを活用することで、イノベーションを行い、目標を達成できるようにします。

多様性を受け入れるオープンソースの強化

Red Hat では、コード、ドキュメント、Web プロパティーにおける配慮に欠ける用語の置き換えに取り組んでいます。このような変更は、段階的に実施される予定です。詳細情報: Red Hat ブログ.

会社概要

Red Hat は、企業がコアとなるデータセンターからネットワークエッジに至るまで、各種プラットフォームや環境全体で作業を簡素化できるように、強化されたソリューションを提供しています。

© 2024 Red Hat, Inc.