本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 复制模型 (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 and AWS 软件开发工具包](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);
}
}
}
```
------