本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 複製模型 (SDK)
您可以使用 `CopyProjectVersion` API 將模型版本從來源專案複製到目的地專案。目的地專案可以位於不同的 AWS 帳戶中，但必須是相同的 AWS 區域。如果目的地專案位於不同的 AWS 帳戶中 （或者如果您想要授予 AWS 帳戶中複製的模型版本的特定許可），您必須將專案政策連接至來源專案。如需詳細資訊，請參閱[建立專案政策文件。](md-create-project-policy-document.md)。`CopyProjectVersion` API 需要存取您的 Amazon S3 儲存貯體。
複製的模型包含來源模型的訓練結果，但不包含來源資料集。
除非您設定適當的許可，否則來源 AWS 帳戶對複製到目的地帳戶的模型沒有所有權。
**複製模型 (SDK)**
1. 如果您尚未這麼做，請安裝並設定 AWS CLI 和 AWS SDKs。如需詳細資訊，請參閱[步驟 4：設定 AWS CLI 和 AWS SDKs](su-awscli-sdk.md)。
1. 依照 [連接專案政策 (SDK)](md-attach-project-policy.md) 中的指示，將專案政策連接至來源專案。
1. 如果您要將模型複製到不同的 AWS 帳戶，請確定目的地帳戶中有一個專案 AWS 。
1. 使用下列程式碼將模型版本複製到目的地專案。
------
#### [ AWS CLI ]
變更下列值：
+ `source-project-arn` 至包含您要複製的模型版本之來源專案的 ARN。
+ `source-project-version-arn` 至您要複製的模型版本之 ARN。
+ `destination-project-arn` 至您要將模型複製到的目的地專案之 ARN。
+ `version-name` 至目的地專案中模型的版本名稱。
+ `bucket` 至您要將來源模型的訓練結果複製到的 S3 儲存貯體。
+ `folder` 至 `bucket` 中您要將來源模型的訓練結果複製到的資料夾。
+ (選用) `kms-key-id` 至模型的 AWS Key Management Service 金鑰 ID。
+ (選用) `key` 至您選擇的標籤金鑰。
+ (選用) `value` 至您選擇的標籤值。
```
aws rekognition copy-project-version \
--source-project-arn {{source-project-arn}} \
--source-project-version-arn {{source-project-version-arn}} \
--destination-project-arn {{destination-project-arn}} \
--version-name {{version-name}} \
--output-config '{"S3Bucket":"{{bucket}}","S3KeyPrefix":"{{folder}}"}' \
--kms-key-id arn:{{myKey}} \
--tags '{"{{key}}":"{{key}}"}' \
--profile custom-labels-access
```
------
#### [ Python ]
使用以下程式碼。請請提供以下命令列參數：
+ `source_project_arn` — 來源 AWS 帳戶中來源專案的 ARN，其中包含您要複製的模型版本。
+ `source_project_version-arn` — 您要複製之來源 AWS 帳戶中模型版本的 ARN。
+ `destination_project_arn` — 您要將模型複製到的目的地專案之 ARN。
+ `destination_version_name` — 目的地專案中模型的版本名稱。
+ `training_results` — 您要將來源模型的訓練結果複製到的 S3 位置。
+ (選用) `kms_key_id` 至模型的 AWS Key Management Service 金鑰 ID。
+ (選用) `tag_name` 至您選擇的標籤金鑰。
+ (選用) `tag_value` 至您選擇的標籤值。
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import argparse
import logging
import time
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
def copy_model(
rekognition_client, source_project_arn, source_project_version_arn,
destination_project_arn, training_results, destination_version_name):
"""
Copies a version of a Amazon Rekognition Custom Labels model.
:param rekognition_client: A Boto3 Amazon Rekognition Custom Labels client.
:param source_project_arn: The ARN of the source project that contains the
model that you want to copy.
:param source_project_version_arn: The ARN of the model version that you want
to copy.
:param destination_project_Arn: The ARN of the project that you want to copy the model
to.
:param training_results: The Amazon S3 location where training results for the model
should be stored.
return: The model status and version.
"""
try:
logger.info("Copying model...%s from %s to %s ", source_project_version_arn,
source_project_arn,
destination_project_arn)
output_bucket, output_folder = training_results.replace(
"s3://", "").split("/", 1)
output_config = {"S3Bucket": output_bucket,
"S3KeyPrefix": output_folder}
response = rekognition_client.copy_project_version(
DestinationProjectArn=destination_project_arn,
OutputConfig=output_config,
SourceProjectArn=source_project_arn,
SourceProjectVersionArn=source_project_version_arn,
VersionName=destination_version_name
)
destination_model_arn = response["ProjectVersionArn"]
logger.info("Destination model ARN: %s", destination_model_arn)
# Wait until training completes.
finished = False
status = "UNKNOWN"
while finished is False:
model_description = rekognition_client.describe_project_versions(ProjectArn=destination_project_arn,
VersionNames=[destination_version_name])
status = model_description["ProjectVersionDescriptions"][0]["Status"]
if status == "COPYING_IN_PROGRESS":
logger.info("Model copying in progress...")
time.sleep(60)
continue
if status == "COPYING_COMPLETED":
logger.info("Model was successfully copied.")
if status == "COPYING_FAILED":
logger.info(
"Model copy failed: %s ",
model_description["ProjectVersionDescriptions"][0]["StatusMessage"])
finished = True
except ClientError:
logger.exception("Couldn't copy model.")
raise
else:
return destination_model_arn, status
def add_arguments(parser):
"""
Adds command line arguments to the parser.
:param parser: The command line parser.
"""
parser.add_argument(
"source_project_arn",
help="The ARN of the project that contains the model that you want to copy."
)
parser.add_argument(
"source_project_version_arn",
help="The ARN of the model version that you want to copy."
)
parser.add_argument(
"destination_project_arn",
help="The ARN of the project which receives the copied model."
)
parser.add_argument(
"destination_version_name",
help="The version name for the model in the destination project."
)
parser.add_argument(
"training_results",
help="The S3 location in the destination account that receives the training results for the copied model."
)
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()
print(
f"Copying model version {args.source_project_version_arn} to project {args.destination_project_arn}")
session = boto3.Session(profile_name='custom-labels-access')
rekognition_client = session.client("rekognition")
# Copy the model.
model_arn, status = copy_model(rekognition_client,
args.source_project_arn,
args.source_project_version_arn,
args.destination_project_arn,
args.training_results,
args.destination_version_name,
)
print(f"Finished copying model: {model_arn}")
print(f"Status: {status}")
except ClientError as err:
print(f"Problem copying model: {err}")
if __name__ == "__main__":
main()
```
------
#### [ Java V2 ]
使用以下程式碼。請請提供以下命令列參數：
+ `source_project_arn` — 來源 AWS 帳戶中來源專案的 ARN，其中包含您要複製的模型版本。
+ `source_project_version-arn` — 您要複製之來源 AWS 帳戶中模型版本的 ARN。
+ `destination_project_arn` — 您要將模型複製到的目的地專案之 ARN。
+ `destination_version_name` — 目的地專案中模型的版本名稱。
+ `output_bucket` — 您要將來源模型版本的訓練結果複製到的 S3 儲存貯體。
+ `output_folder` — 您要將來源模型版本的訓練結果複製到的 S3 中的資料夾。
```
/*
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.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CopyProjectVersionRequest;
import software.amazon.awssdk.services.rekognition.model.CopyProjectVersionResponse;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeProjectVersionsResponse;
import software.amazon.awssdk.services.rekognition.model.OutputConfig;
import software.amazon.awssdk.services.rekognition.model.ProjectVersionDescription;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class CopyModel {
public static final Logger logger = Logger.getLogger(CopyModel.class.getName());
public static ProjectVersionDescription copyMyModel(RekognitionClient rekClient,
String sourceProjectArn,
String sourceProjectVersionArn,
String destinationProjectArn,
String versionName,
String outputBucket,
String outputFolder) throws InterruptedException {
try {
OutputConfig outputConfig = OutputConfig.builder().s3Bucket(outputBucket).s3KeyPrefix(outputFolder).build();
String[] logArguments = new String[] { versionName, sourceProjectArn, destinationProjectArn };
logger.log(Level.INFO, "Copying model {0} for from project {1} to project {2}", logArguments);
CopyProjectVersionRequest copyProjectVersionRequest = CopyProjectVersionRequest.builder()
.sourceProjectArn(sourceProjectArn)
.sourceProjectVersionArn(sourceProjectVersionArn)
.versionName(versionName)
.destinationProjectArn(destinationProjectArn)
.outputConfig(outputConfig)
.build();
CopyProjectVersionResponse response = rekClient.copyProjectVersion(copyProjectVersionRequest);
logger.log(Level.INFO, "Destination model ARN: {0}", response.projectVersionArn());
logger.log(Level.INFO, "Copying model...");
// wait until copying completes.
boolean finished = false;
ProjectVersionDescription copiedModel = null;
while (Boolean.FALSE.equals(finished)) {
DescribeProjectVersionsRequest describeProjectVersionsRequest = DescribeProjectVersionsRequest.builder()
.versionNames(versionName)
.projectArn(destinationProjectArn)
.build();
DescribeProjectVersionsResponse describeProjectVersionsResponse = rekClient
.describeProjectVersions(describeProjectVersionsRequest);
for (ProjectVersionDescription projectVersionDescription : describeProjectVersionsResponse
.projectVersionDescriptions()) {
copiedModel = projectVersionDescription;
switch (projectVersionDescription.status()) {
case COPYING_IN_PROGRESS:
logger.log(Level.INFO, "Copying model...");
Thread.sleep(5000);
continue;
case COPYING_COMPLETED:
finished = true;
logger.log(Level.INFO, "Copying completed");
break;
case COPYING_FAILED:
finished = true;
logger.log(Level.INFO, "Copying failed...");
break;
default:
finished = true;
logger.log(Level.INFO, "Unexpected copy status %s",
projectVersionDescription.statusAsString());
break;
}
}
}
logger.log(Level.INFO, "Finished copying model {0} for from project {1} to project {2}", logArguments);
return copiedModel;
} catch (RekognitionException e) {
logger.log(Level.SEVERE, "Could not train model: {0}", e.getMessage());
throw e;
}
}
public static void main(String args[]) {
String sourceProjectArn = null;
String sourceProjectVersionArn = null;
String destinationProjectArn = null;
String versionName = null;
String bucket = null;
String location = null;
final String USAGE = "\n" + "Usage: "
+ " \n\n"
+ "Where:\n"
+ " source_project_arn - The ARN of the project that contains the model that you want to copy. \n\n"
+ " source_project_version_arn - The ARN of the project that contains the model that you want to copy. \n\n"
+ " destination_project_arn - The ARN of the destination project that you want to copy the model to. \n\n"
+ " version_name - A version name for the copied model.\n\n"
+ " output_bucket - The S3 bucket in which to place the training output. \n\n"
+ " output_folder - The folder within the bucket that the training output is stored in. \n\n";
if (args.length != 6) {
System.out.println(USAGE);
System.exit(1);
}
sourceProjectArn = args[0];
sourceProjectVersionArn = args[1];
destinationProjectArn = args[2];
versionName = args[3];
bucket = args[4];
location = args[5];
try {
// Get the Rekognition client.
RekognitionClient rekClient = RekognitionClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("custom-labels-access"))
.region(Region.US_WEST_2)
.build();
// Copy the model.
ProjectVersionDescription copiedModel = copyMyModel(rekClient,
sourceProjectArn,
sourceProjectVersionArn,
destinationProjectArn,
versionName,
bucket,
location);
System.out.println(String.format("Model copied: %s Status: %s",
copiedModel.projectVersionArn(),
copiedModel.statusMessage()));
rekClient.close();
} catch (RekognitionException rekError) {
logger.log(Level.SEVERE, "Rekognition client error: {0}", rekError.getMessage());
System.exit(1);
} catch (InterruptedException intError) {
logger.log(Level.SEVERE, "Exception while sleeping: {0}", intError.getMessage());
System.exit(1);
}
}
}
```
------