Amazon Rekognition Custom Labels モデルを開始する

Amazon Rekognition Custom Labels モデルの実行を開始するには、コンソールを使用するか、StartProjectバージョンオペレーションを使用します。

重要

モデルを停止するモデルの稼働時間数と、モデルの実行中にモデルが使用する推論単位の数に対して課金されます。詳細については、「トレーニング済み Amazon Rekognition Custom Labels の実行」を参照してください。

モデルの開始には数分かかることがあります。モデルの準備状況の現在のステータスを確認するには、プロジェクトの詳細ページを確認するか、DescribeProjectバージョンを使用します。

モデルが開始されたら、DetectCustomラベルを使用してモデルを使用してイメージを分析します。詳細については、「トレーニングされたモデルによるイメージの分析」を参照してください。コンソールには DetectCustomLabels を呼び出すサンプルコードも用意されています。

トピック

Amazon Rekognition Custom Labels モデルの開始 (コンソール)
Amazon Rekognition Custom Labels モデル (SDK) を開始します。

Amazon Rekognition Custom Labels モデルの開始 (コンソール)

以下の手順を使用して、コンソールで Amazon Rekognition Custom Labels モデルの実行を開始します。モデルをコンソールから直接起動することも、コンソールが提供する AWS SDK コードを使用することもできます。

モデル (コンソール) を開始するには

Amazon Rekognition コンソールを https://console.aws.amazon.com/rekognition/ で開きます。
[カスタムラベルを使用] を選択します。
[開始方法] を選択します。
左側のナビゲーションペインで、[プロジェクト] を選択します。
[プロジェクト] リソースページで、開始するモデルを含むプロジェクトを選択します。
[モデル] セクションで、開始するモデルを選択します。
[モデルを使用] タブを選択します。
次のいずれかを行います。
Start model using the console
[モデルの開始または停止] セクションで、次の操作を行います。
使用する推論単位の数を選択します。詳細については、「トレーニング済み Amazon Rekognition Custom Labels の実行」を参照してください。
[開始] を選択します。
[モデルを開始] ダイアログボックスで、[開始] を選択します。
Start model using the AWS SDK
[自分のモデルを使用] セクションで、次の操作を行います。
[API コード] を選択します。

[AWS CLI] または [Python] のいずれかを選択します。
[モデルを開始] で、サンプルコードをコピーします。
このサンプルコードを使用して、モデルを開始します。詳細については、「Amazon Rekognition Custom Labels モデル (SDK) を開始します。」を参照してください。
プロジェクトの概要ページに戻るには、ページの上部でプロジェクト名を選択します。
[モデル] セクションで、モデルのステータスを確認します。モデルのステータスが RUNNING の場合、モデルを使用してイメージを分析できます。詳細については、「トレーニングされたモデルによるイメージの分析」を参照してください。

Amazon Rekognition Custom Labels モデル (SDK) を開始します。

モデルを開始するには、StartProjectバージョン API を呼び出し、ProjectVersionArn入力パラメータでモデルの Amazon リソースネーム (ARN) を渡します。使用する推論単位の数も指定します。詳細については、「トレーニング済み Amazon Rekognition Custom Labels の実行」を参照してください。

モデルの開始までに時間がかかる場合があります。このトピックの Python と Java の例では、ウェーターを使用してモデルの開始を待ちます。ウェーターは、発生する特定の状態をポーリングするユーティリティメソッドです。または、DescribeProjectバージョンを呼び出して現在のステータスを確認することもできます。

モデル (SDK) を開始するには

まだインストールしていない場合は、と AWS SDKsをインストール AWS CLI して設定します。詳細については、「ステップ 4: AWS CLI と AWS SDKsを設定する」を参照してください。

次のサンプルコードを使用して、モデルを開始します。

CLI

project-version-arn の値を開始するモデルの ARN に変更します。--min-inference-units の値を使用する推論単位の数に変更します。必要に応じて、--max-inference-units を Amazon Rekognition Custom Labels がモデルを自動的にスケールするために使用できる推論単位の最大数に変更します。


aws rekognition start-project-version  --project-version-arn model_arn \
   --min-inference-units minimum number of units \
   --max-inference-units maximum number of units \
   --profile custom-labels-access

Python

次のコマンドラインパラメータを指定します。

project_arn - 開始するモデルを含むプロジェクトの ARN。
model_arn - 開始するモデルの ARN。
min_inference_units - 使用する推論単位の数。
(オプション) --max_inference_units Amazon Rekognition Custom Labels がモデルの自動スケーリングに使用できる推論単位の最大数。


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

"""
Purpose
Shows how to start running an Amazon Lookout for Vision model.
"""

import argparse
import logging
import boto3
from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)


def get_model_status(rek_client, project_arn, model_arn):
    """
    Gets the current status of an Amazon Rekognition Custom Labels model
    :param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
    :param project_name:  The name of the project that you want to use.
    :param model_arn:  The name of the model that you want the status for.
    :return: The model status
    """

    logger.info("Getting status for %s.", model_arn)

    # Extract the model version from the model arn.
    version_name = (model_arn.split("version/", 1)[1]).rpartition('/')[0]

    models = rek_client.describe_project_versions(ProjectArn=project_arn,
                                                  VersionNames=[version_name])

    for model in models['ProjectVersionDescriptions']:

        logger.info("Status: %s", model['StatusMessage'])
        return model["Status"]

    error_message = f"Model {model_arn} not found."
    logger.exception(error_message)
    raise Exception(error_message)


def start_model(rek_client, project_arn, model_arn, min_inference_units, max_inference_units=None):
    """
    Starts the hosting of an Amazon Rekognition Custom Labels model.
    :param rek_client: The Amazon Rekognition Custom Labels Boto3 client.
    :param project_name:  The name of the project that contains the
    model that you want to start hosting.
    :param min_inference_units: The number of inference units to use for hosting.
    :param max_inference_units: The number of inference units to use for auto-scaling
    the model. If not supplied, auto-scaling does not happen.
    """

    try:
        # Start the model
        logger.info(f"Starting model: {model_arn}. Please wait....")

        if max_inference_units is None:
            rek_client.start_project_version(ProjectVersionArn=model_arn,
                                             MinInferenceUnits=int(min_inference_units))
        else:
            rek_client.start_project_version(ProjectVersionArn=model_arn,
                                             MinInferenceUnits=int(
                                                 min_inference_units),
                                             MaxInferenceUnits=int(max_inference_units))

        # Wait for the model to be in the running state
        version_name = (model_arn.split("version/", 1)[1]).rpartition('/')[0]
        project_version_running_waiter = rek_client.get_waiter(
            'project_version_running')
        project_version_running_waiter.wait(
            ProjectArn=project_arn, VersionNames=[version_name])

        # Get the running status
        return get_model_status(rek_client, project_arn, model_arn)

    except ClientError as err:
        logger.exception("Client error: Problem starting model: %s", err)
        raise


def add_arguments(parser):
    """
    Adds command line arguments to the parser.
    :param parser: The command line parser.
    """

    parser.add_argument(
        "project_arn", help="The ARN of the project that contains that the model you want to start."
    )
    parser.add_argument(
        "model_arn", help="The ARN of the model that you want to start."
    )
    parser.add_argument(
        "min_inference_units", help="The minimum number of inference units to use."
    )
    parser.add_argument(
        "--max_inference_units",  help="The maximum number of inference units to use for auto-scaling the model.", required=False
    )


def main():

    logging.basicConfig(level=logging.INFO,
                        format="%(levelname)s: %(message)s")

    try:

        # Get command line arguments.
        parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
        add_arguments(parser)
        args = parser.parse_args()

        # Start the model.
        session = boto3.Session(profile_name='custom-labels-access')
        rekognition_client = session.client("rekognition")
        
        status = start_model(rekognition_client,
                             args.project_arn, args.model_arn,
                             args.min_inference_units,
                             args.max_inference_units)

        print(f"Finished starting model: {args.model_arn}")
        print(f"Status: {status}")

    except ClientError as err:
        error_message = f"Client error: Problem starting model: {err}"
        logger.exception(error_message)
        print(error_message)

    except Exception as err:
        error_message = f"Problem starting model:{err}"
        logger.exception(error_message)
        print(error_message)


if __name__ == "__main__":
    main()

Java V2

次のコマンドラインパラメータを指定します。

project_arn - 開始するモデルを含むプロジェクトの ARN。
model_arn - 開始するモデルの ARN。
min_inference_units - 使用する推論単位の数。
(オプション) max_inference_units - Amazon Rekognition Custom Labels がモデルを自動的にスケールするために使用できる推論単位の最大数。値を指定しない場合、自動スケーリングは行われません。


/*
   Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   SPDX-License-Identifier: Apache-2.0
*/
package com.example.rekognition;

import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionStatus;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.StartProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.StartProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.waiters.RekognitionWaiter;

import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;

public class StartModel {

    public static final Logger logger = Logger.getLogger(StartModel.class.getName());
    
    
    
    public static int findForwardSlash(String modelArn, int n) {

        int start = modelArn.indexOf('/');
        while (start >= 0 && n > 1) {
            start = modelArn.indexOf('/', start + 1);
            n -= 1;
        }
        return start;

    }

    public static void startMyModel(RekognitionClient rekClient, String projectArn, String modelArn,
            Integer minInferenceUnits, Integer maxInferenceUnits
            ) throws Exception, RekognitionException {

        try {
            
            logger.log(Level.INFO, "Starting model: {0}", modelArn);
            
            StartProjectVersionRequest startProjectVersionRequest = null;
            
            if (maxInferenceUnits == null) {
                startProjectVersionRequest = StartProjectVersionRequest.builder()
                    .projectVersionArn(modelArn)
                    .minInferenceUnits(minInferenceUnits)
                    .build();
            }
            else {
                startProjectVersionRequest = StartProjectVersionRequest.builder()
                        .projectVersionArn(modelArn)
                        .minInferenceUnits(minInferenceUnits)
                        .maxInferenceUnits(maxInferenceUnits)
                        .build();
                
            }

            StartProjectVersionResponse response = rekClient.startProjectVersion(startProjectVersionRequest);

            logger.log(Level.INFO, "Status: {0}", response.statusAsString() );
            
            
            // Get the model version

            int start = findForwardSlash(modelArn, 3) + 1;
            int end = findForwardSlash(modelArn, 4);

            String versionName = modelArn.substring(start, end);


            // wait until model starts

            DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
                    .versionNames(versionName)
                    .projectArn(projectArn)
                    .build();

            RekognitionWaiter waiter = rekClient.waiter();

            WaiterResponse<DescribeProjectVersionsResponse> waiterResponse = waiter
                    .waitUntilProjectVersionRunning(describeProjectVersionsRequest);

            Optional<DescribeProjectVersionsResponse> optionalResponse = waiterResponse.matched().response();

            DescribeProjectVersionsResponse describeProjectVersionsResponse = optionalResponse.get();

            for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
                    .projectVersionDescriptions()) {
                if(projectVersionDescription.status() == ProjectVersionStatus.RUNNING) {
                    logger.log(Level.INFO, "Model is running" );
                 
                }
                else {
                    String error = "Model training failed: " + projectVersionDescription.statusAsString() + " "
                            + projectVersionDescription.statusMessage() + " " + modelArn;
                    logger.log(Level.SEVERE, error);
                    throw new Exception(error);
                }
                
            }


        } catch (RekognitionException e) {
            logger.log(Level.SEVERE, "Could not start model: {0}", e.getMessage());
            throw e;
        }

    }

    public static void main(String[] args) {

        String modelArn = null;
        String projectArn = null;
        Integer minInferenceUnits = null;
        Integer maxInferenceUnits = null;
        



        final String USAGE = "\n" + "Usage: " + "<project_name> <version_name> <min_inference_units> <max_inference_units>\n\n" + "Where:\n"
                + "   project_arn - The ARN of the project that contains the model that you want to start. \n\n"
                + "   model_arn - The ARN of the model version that you want to start.\n\n"
                + "   min_inference_units - The number of inference units to start the model with.\n\n"
                + "   max_inference_units - The maximum number of inference units that Custom Labels can use to "
                + "   automatically scale the model. If the value is null, automatic scaling doesn't happen.\n\n";

        if (args.length < 3  || args.length >4) {
            System.out.println(USAGE);
            System.exit(1);
        }

        projectArn = args[0];
        modelArn = args[1];
        minInferenceUnits=Integer.parseInt(args[2]);
        
        if (args.length == 4) {
            maxInferenceUnits = Integer.parseInt(args[3]);
        }
  
        try {


            // Get the Rekognition client.
            RekognitionClient rekClient = RekognitionClient.builder()
            .credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
            .region(Region.US_WEST_2)
            .build();

            // Start the model.
            startMyModel(rekClient, projectArn, modelArn, minInferenceUnits, maxInferenceUnits);
            

            System.out.println(String.format("Model started: %s", modelArn));

            rekClient.close();

        } catch (RekognitionException rekError) {
            logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
            System.exit(1);
        } catch (Exception rekError) {
            logger.log(Level.SEVERE, "Error: {0}", rekError.getMessage());
            System.exit(1);
        }

        

    }

}

ブラウザで JavaScript が無効になっているか、使用できません。

AWS ドキュメントを使用するには、JavaScript を有効にする必要があります。手順については、使用するブラウザのヘルプページを参照してください。

ドキュメントの表記規則

トレーニング済みモデルの実行

モデルの停止