本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# Amazon Comprehend 使用场景 AWS SDKs
以下代码示例向您展示了如何使用在 Amazon Comprehend 中实现常见场景。 AWS SDKs这些场景演示了如何通过调用 Amazon Comprehend 中的多个函数或与其他 AWS 服务结合来完成特定任务。每个场景都包含完整源代码的链接，您可以在其中找到有关如何设置和运行代码的说明。
场景以中等水平的经验为目标，可帮助您结合具体环境了解服务操作。
**Topics**
+ [构建 Amazon Transcribe 流式传输应用程序](example_cross_TranscriptionStreamingApp_section.md)
+ [构建 Amazon Lex 聊天机器人](example_cross_LexChatbotLanguages_section.md)
+ [创建消息应用程序](example_cross_SQSMessageApp_section.md)
+ [创建用于分析客户反馈的应用程序](example_cross_FSA_section.md)
+ [检测文档元素](example_comprehend_Usage_DetectApis_section.md)
+ [检测从图像中提取的文本中的实体](example_cross_TextractComprehendDetectEntities_section.md)
+ [对示例数据运行主题建模任务](example_comprehend_Usage_TopicModeler_section.md)
+ [训练自定义分类器并对文档进行分类](example_comprehend_Usage_ComprehendClassifier_section.md)
# 构建 Amazon Transcribe 流式传输应用程序
以下代码示例展示如何构建可实时录制、转录与翻译实时音频，并通过电子邮件发送结果的应用程序。
------
#### [ JavaScript ]
**适用于 JavaScript (v3) 的软件开发工具包**
演示了如何使用 Amazon Transcribe 构建可实时录制、转录与翻译实时音频，并通过 Amazon Simple Email Service (Amazon SES) 以电子邮件发送结果的应用程序。
有关如何设置和运行的完整源代码和说明，请参阅上的完整示例[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/transcribe-streaming-app)。
**本示例中使用的服务**
+ Amazon Comprehend
+ Amazon SES
+ Amazon Transcribe
+ Amazon Translate
------
有关 S AWS DK 开发者指南和代码示例的完整列表，请参阅[将 Amazon Comprehend 与 SDK 配合 AWS 使用](sdk-general-information-section.md)。本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 创建 Amazon Lex 聊天机器人来吸引您的网站访客
以下代码示例显示如何创建用于吸引网站访客的聊天机器人。
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
展示如何使用 Amazon Lex API 在 Web 应用程序中创建聊天机器人，以吸引网站访客。
有关如何设置和运行的完整源代码和说明，请参阅上的完整示例[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_lex_chatbot)。
**本示例中使用的服务**
+ Amazon Comprehend
+ Amazon Lex
+ Amazon Translate
------
#### [ JavaScript ]
**适用于 JavaScript (v3) 的软件开发工具包**
展示如何使用 Amazon Lex API 在 Web 应用程序中创建聊天机器人，以吸引网站访客。
有关如何设置和运行的完整源代码和说明，请参阅 适用于 JavaScript 的 AWS SDK 开发者指南中的[构建 Amazon Lex 聊天机器人的](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/lex-bot-example.html)完整示例。
**本示例中使用的服务**
+ Amazon Comprehend
+ Amazon Lex
+ Amazon Translate
------
有关 S AWS DK 开发者指南和代码示例的完整列表，请参阅[将 Amazon Comprehend 与 SDK 配合 AWS 使用](sdk-general-information-section.md)。本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 使用 Amazon SQS 创建用于发送和检索消息的网络应用程序
以下代码示例显示如何使用 Amazon SQS 创建消息传输应用程序。
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
演示如何使用 Amazon SQS API 开发用于发送和检索消息的 Spring REST API。
有关如何设置和运行的完整源代码和说明，请参阅上的完整示例[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_message_application)。
**本示例中使用的服务**
+ Amazon Comprehend
+ Amazon SQS
------
#### [ Kotlin ]
**适用于 Kotlin 的 SDK**
演示如何使用 Amazon SQS API 开发用于发送和检索消息的 Spring REST API。
有关如何设置和运行的完整源代码和说明，请参阅上的完整示例[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/creating_message_application)。
**本示例中使用的服务**
+ Amazon Comprehend
+ Amazon SQS
------
有关 S AWS DK 开发者指南和代码示例的完整列表，请参阅[将 Amazon Comprehend 与 SDK 配合 AWS 使用](sdk-general-information-section.md)。本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 创建用于分析客户反馈和合成音频的应用程序
以下代码示例显示如何创建应用程序来分析客户意见卡、翻译其母语、确定其情绪并根据译后的文本生成音频文件。
------
#### [ .NET ]
**适用于 .NET 的 SDK**
此示例应用程序可分析并存储客户反馈卡。具体来说，它满足了纽约市一家虚构酒店的需求。酒店以实体意见卡的形式收集来自不同语种的客人的反馈。该反馈通过 Web 客户端上传到应用程序中。意见卡图片上传后，将执行以下步骤：
+ 使用 Amazon Textract 从图片中提取文本。
+ Amazon Comprehend 确定所提取文本的情绪及其语言。
+ 使用 Amazon Translate 将所提取文本翻译为英语。
+ Amazon Polly 根据所提取文本合成音频文件。
完整的应用程序可使用 AWS CDK 进行部署。有关源代码和部署说明，请参阅中的项目[ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/FeedbackSentimentAnalyzer)。
**本示例中使用的服务**
+ Amazon Comprehend
+ Lambda
+ Amazon Polly
+ Amazon Textract
+ Amazon Translate
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
此示例应用程序可分析并存储客户反馈卡。具体来说，它满足了纽约市一家虚构酒店的需求。酒店以实体意见卡的形式收集来自不同语种的客人的反馈。该反馈通过 Web 客户端上传到应用程序中。意见卡图片上传后，将执行以下步骤：
+ 使用 Amazon Textract 从图片中提取文本。
+ Amazon Comprehend 确定所提取文本的情绪及其语言。
+ 使用 Amazon Translate 将所提取文本翻译为英语。
+ Amazon Polly 根据所提取文本合成音频文件。
完整的应用程序可使用 AWS CDK 进行部署。有关源代码和部署说明，请参阅中的项目[ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_fsa_app)。
**本示例中使用的服务**
+ Amazon Comprehend
+ Lambda
+ Amazon Polly
+ Amazon Textract
+ Amazon Translate
------
#### [ JavaScript ]
**适用于 JavaScript (v3) 的软件开发工具包**
此示例应用程序可分析并存储客户反馈卡。具体来说，它满足了纽约市一家虚构酒店的需求。酒店以实体意见卡的形式收集来自不同语种的客人的反馈。该反馈通过 Web 客户端上传到应用程序中。意见卡图片上传后，将执行以下步骤：
+ 使用 Amazon Textract 从图片中提取文本。
+ Amazon Comprehend 确定所提取文本的情绪及其语言。
+ 使用 Amazon Translate 将所提取文本翻译为英语。
+ Amazon Polly 根据所提取文本合成音频文件。
完整的应用程序可使用 AWS CDK 进行部署。有关源代码和部署说明，请参阅中的项目[ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/feedback-sentiment-analyzer)。以下摘录显示了在 Lambda 函数中 适用于 JavaScript 的 AWS SDK 是如何使用的。
```
import {
ComprehendClient,
DetectDominantLanguageCommand,
DetectSentimentCommand,
} from "@aws-sdk/client-comprehend";
/**
* Determine the language and sentiment of the extracted text.
*
* @param {{ source_text: string}} extractTextOutput
*/
export const handler = async (extractTextOutput) => {
const comprehendClient = new ComprehendClient({});
const detectDominantLanguageCommand = new DetectDominantLanguageCommand({
Text: extractTextOutput.source_text,
});
// The source language is required for sentiment analysis and
// translation in the next step.
const { Languages } = await comprehendClient.send(
detectDominantLanguageCommand,
);
const languageCode = Languages[0].LanguageCode;
const detectSentimentCommand = new DetectSentimentCommand({
Text: extractTextOutput.source_text,
LanguageCode: languageCode,
});
const { Sentiment } = await comprehendClient.send(detectSentimentCommand);
return {
sentiment: Sentiment,
language_code: languageCode,
};
};
```
```
import {
DetectDocumentTextCommand,
TextractClient,
} from "@aws-sdk/client-textract";
/**
* Fetch the S3 object from the event and analyze it using Amazon Textract.
*
* @param {import("@types/aws-lambda").EventBridgeEvent<"Object Created">} eventBridgeS3Event
*/
export const handler = async (eventBridgeS3Event) => {
const textractClient = new TextractClient();
const detectDocumentTextCommand = new DetectDocumentTextCommand({
Document: {
S3Object: {
Bucket: eventBridgeS3Event.bucket,
Name: eventBridgeS3Event.object,
},
},
});
// Textract returns a list of blocks. A block can be a line, a page, word, etc.
// Each block also contains geometry of the detected text.
// For more information on the Block type, see https://docs.aws.amazon.com/textract/latest/dg/API_Block.html.
const { Blocks } = await textractClient.send(detectDocumentTextCommand);
// For the purpose of this example, we are only interested in words.
const extractedWords = Blocks.filter((b) => b.BlockType === "WORD").map(
(b) => b.Text,
);
return extractedWords.join(" ");
};
```
```
import { PollyClient, SynthesizeSpeechCommand } from "@aws-sdk/client-polly";
import { S3Client } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
/**
* Synthesize an audio file from text.
*
* @param {{ bucket: string, translated_text: string, object: string}} sourceDestinationConfig
*/
export const handler = async (sourceDestinationConfig) => {
const pollyClient = new PollyClient({});
const synthesizeSpeechCommand = new SynthesizeSpeechCommand({
Engine: "neural",
Text: sourceDestinationConfig.translated_text,
VoiceId: "Ruth",
OutputFormat: "mp3",
});
const { AudioStream } = await pollyClient.send(synthesizeSpeechCommand);
const audioKey = `${sourceDestinationConfig.object}.mp3`;
// Store the audio file in S3.
const s3Client = new S3Client();
const upload = new Upload({
client: s3Client,
params: {
Bucket: sourceDestinationConfig.bucket,
Key: audioKey,
Body: AudioStream,
ContentType: "audio/mp3",
},
});
await upload.done();
return audioKey;
};
```
```
import {
TranslateClient,
TranslateTextCommand,
} from "@aws-sdk/client-translate";
/**
* Translate the extracted text to English.
*
* @param {{ extracted_text: string, source_language_code: string}} textAndSourceLanguage
*/
export const handler = async (textAndSourceLanguage) => {
const translateClient = new TranslateClient({});
const translateCommand = new TranslateTextCommand({
SourceLanguageCode: textAndSourceLanguage.source_language_code,
TargetLanguageCode: "en",
Text: textAndSourceLanguage.extracted_text,
});
const { TranslatedText } = await translateClient.send(translateCommand);
return { translated_text: TranslatedText };
};
```
**本示例中使用的服务**
+ Amazon Comprehend
+ Lambda
+ Amazon Polly
+ Amazon Textract
+ Amazon Translate
------
#### [ Ruby ]
**适用于 Ruby 的 SDK**
此示例应用程序可分析并存储客户反馈卡。具体来说，它满足了纽约市一家虚构酒店的需求。酒店以实体意见卡的形式收集来自不同语种的客人的反馈。该反馈通过 Web 客户端上传到应用程序中。意见卡图片上传后，将执行以下步骤：
+ 使用 Amazon Textract 从图片中提取文本。
+ Amazon Comprehend 确定所提取文本的情绪及其语言。
+ 使用 Amazon Translate 将所提取文本翻译为英语。
+ Amazon Polly 根据所提取文本合成音频文件。
完整的应用程序可使用 AWS CDK 进行部署。有关源代码和部署说明，请参阅中的项目[ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/cross_service_examples/feedback_sentiment_analyzer)。
**本示例中使用的服务**
+ Amazon Comprehend
+ Lambda
+ Amazon Polly
+ Amazon Textract
+ Amazon Translate
------
有关 S AWS DK 开发者指南和代码示例的完整列表，请参阅[将 Amazon Comprehend 与 SDK 配合 AWS 使用](sdk-general-information-section.md)。本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 使用 Amazon Comprehend 和软件开发工具包检测文档元素 AWS
以下代码示例展示了如何：
+ 检测文档中的语言、实体和关键短语。
+ 检测文档中的个人身份信息 (PII)。
+ 检测文档的情绪。
+ 检测文档的语法元素。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/comprehend#code-examples)中查找完整示例，了解如何进行设置和运行。
创建一个包装 Amazon Comprehend 操作的类。
```
import logging
from pprint import pprint
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
class ComprehendDetect:
"""Encapsulates Comprehend detection functions."""
def __init__(self, comprehend_client):
"""
:param comprehend_client: A Boto3 Comprehend client.
"""
self.comprehend_client = comprehend_client
def detect_languages(self, text):
"""
Detects languages used in a document.
:param text: The document to inspect.
:return: The list of languages along with their confidence scores.
"""
try:
response = self.comprehend_client.detect_dominant_language(Text=text)
languages = response["Languages"]
logger.info("Detected %s languages.", len(languages))
except ClientError:
logger.exception("Couldn't detect languages.")
raise
else:
return languages
def detect_entities(self, text, language_code):
"""
Detects entities in a document. Entities can be things like people and places
or other common terms.
:param text: The document to inspect.
:param language_code: The language of the document.
:return: The list of entities along with their confidence scores.
"""
try:
response = self.comprehend_client.detect_entities(
Text=text, LanguageCode=language_code
)
entities = response["Entities"]
logger.info("Detected %s entities.", len(entities))
except ClientError:
logger.exception("Couldn't detect entities.")
raise
else:
return entities
def detect_key_phrases(self, text, language_code):
"""
Detects key phrases in a document. A key phrase is typically a noun and its
modifiers.
:param text: The document to inspect.
:param language_code: The language of the document.
:return: The list of key phrases along with their confidence scores.
"""
try:
response = self.comprehend_client.detect_key_phrases(
Text=text, LanguageCode=language_code
)
phrases = response["KeyPhrases"]
logger.info("Detected %s phrases.", len(phrases))
except ClientError:
logger.exception("Couldn't detect phrases.")
raise
else:
return phrases
def detect_pii(self, text, language_code):
"""
Detects personally identifiable information (PII) in a document. PII can be
things like names, account numbers, or addresses.
:param text: The document to inspect.
:param language_code: The language of the document.
:return: The list of PII entities along with their confidence scores.
"""
try:
response = self.comprehend_client.detect_pii_entities(
Text=text, LanguageCode=language_code
)
entities = response["Entities"]
logger.info("Detected %s PII entities.", len(entities))
except ClientError:
logger.exception("Couldn't detect PII entities.")
raise
else:
return entities
def detect_sentiment(self, text, language_code):
"""
Detects the overall sentiment expressed in a document. Sentiment can
be positive, negative, neutral, or a mixture.
:param text: The document to inspect.
:param language_code: The language of the document.
:return: The sentiments along with their confidence scores.
"""
try:
response = self.comprehend_client.detect_sentiment(
Text=text, LanguageCode=language_code
)
logger.info("Detected primary sentiment %s.", response["Sentiment"])
except ClientError:
logger.exception("Couldn't detect sentiment.")
raise
else:
return response
def detect_syntax(self, text, language_code):
"""
Detects syntactical elements of a document. Syntax tokens are portions of
text along with their use as parts of speech, such as nouns, verbs, and
interjections.
:param text: The document to inspect.
:param language_code: The language of the document.
:return: The list of syntax tokens along with their confidence scores.
"""
try:
response = self.comprehend_client.detect_syntax(
Text=text, LanguageCode=language_code
)
tokens = response["SyntaxTokens"]
logger.info("Detected %s syntax tokens.", len(tokens))
except ClientError:
logger.exception("Couldn't detect syntax.")
raise
else:
return tokens
```
调用包装类上的函数来检测文档中的实体、短语等。
```
def usage_demo():
print("-" * 88)
print("Welcome to the Amazon Comprehend detection demo!")
print("-" * 88)
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
comp_detect = ComprehendDetect(boto3.client("comprehend"))
with open("detect_sample.txt") as sample_file:
sample_text = sample_file.read()
demo_size = 3
print("Sample text used for this demo:")
print("-" * 88)
print(sample_text)
print("-" * 88)
print("Detecting languages.")
languages = comp_detect.detect_languages(sample_text)
pprint(languages)
lang_code = languages[0]["LanguageCode"]
print("Detecting entities.")
entities = comp_detect.detect_entities(sample_text, lang_code)
print(f"The first {demo_size} are:")
pprint(entities[:demo_size])
print("Detecting key phrases.")
phrases = comp_detect.detect_key_phrases(sample_text, lang_code)
print(f"The first {demo_size} are:")
pprint(phrases[:demo_size])
print("Detecting personally identifiable information (PII).")
pii_entities = comp_detect.detect_pii(sample_text, lang_code)
print(f"The first {demo_size} are:")
pprint(pii_entities[:demo_size])
print("Detecting sentiment.")
sentiment = comp_detect.detect_sentiment(sample_text, lang_code)
print(f"Sentiment: {sentiment['Sentiment']}")
print("SentimentScore:")
pprint(sentiment["SentimentScore"])
print("Detecting syntax elements.")
syntax_tokens = comp_detect.detect_syntax(sample_text, lang_code)
print(f"The first {demo_size} are:")
pprint(syntax_tokens[:demo_size])
print("Thanks for watching!")
print("-" * 88)
```
+ 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的以下主题。
+ [DetectDominantLanguage](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DetectDominantLanguage)
+ [DetectEntities](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DetectEntities)
+ [DetectKeyPhrases](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DetectKeyPhrases)
+ [DetectPiiEntities](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DetectPiiEntities)
+ [DetectSentiment](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DetectSentiment)
+ [DetectSyntax](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DetectSyntax)
------
有关 S AWS DK 开发者指南和代码示例的完整列表，请参阅[将 Amazon Comprehend 与 SDK 配合 AWS 使用](sdk-general-information-section.md)。本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 使用 AWS SDK 检测从图像中提取的文本中的实体
以下代码示例显示了如何使用 Amazon Comprehend 检测 Amazon Textract 从存储在 Amazon S3 内的图像中提取的文本中的实体。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
演示如何使用 Jupyter 笔记本 适用于 Python (Boto3) 的 AWS SDK 中的来检测从图像中提取的文本中的实体。此示例使用 Amazon Textract 从存储在 Amazon Simple Storage Service (Amazon S3) 内的图像中提取文本，并使用 Amazon Comprehend 检测提取文本中的实体。
此示例是 Jupyter 笔记本，必须在可以托管笔记本电脑的环境中运行。有关如何使用 Amazon A SageMaker I 运行示例的说明，请参阅 [TextractAndComprehendNotebook.ipyn](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/textract_comprehend_notebook/TextractAndComprehendNotebook.ipynb) b 中的说明。
有关如何设置和运行的完整源代码和说明，请参阅上的完整示例[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/textract_comprehend_notebook#readme)。
**本示例中使用的服务**
+ Amazon Comprehend
+ Amazon S3
+ Amazon Textract
------
有关 S AWS DK 开发者指南和代码示例的完整列表，请参阅[将 Amazon Comprehend 与 SDK 配合 AWS 使用](sdk-general-information-section.md)。本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 使用软件开发工具包对示例数据运行 Amazon Comprehend 主题建模作业 AWS
以下代码示例展示了如何：
+ 对示例数据运行 Amazon Comprehend 主题建模任务。
+ 获取该任务的相关信息。
+ 从 Amazon S3 提取任务输出数据。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/comprehend#code-examples)中查找完整示例，了解如何进行设置和运行。
创建一个包装类来调用 Amazon Comprehend 主题建模操作。
```
class ComprehendTopicModeler:
"""Encapsulates a Comprehend topic modeler."""
def __init__(self, comprehend_client):
"""
:param comprehend_client: A Boto3 Comprehend client.
"""
self.comprehend_client = comprehend_client
def start_job(
self,
job_name,
input_bucket,
input_key,
input_format,
output_bucket,
output_key,
data_access_role_arn,
):
"""
Starts a topic modeling job. Input is read from the specified Amazon S3
input bucket and written to the specified output bucket. Output data is stored
in a tar archive compressed in gzip format. The job runs asynchronously, so you
can call `describe_topics_detection_job` to get job status until it
returns a status of SUCCEEDED.
:param job_name: The name of the job.
:param input_bucket: An Amazon S3 bucket that contains job input.
:param input_key: The prefix used to find input data in the input
bucket. If multiple objects have the same prefix, all
of them are used.
:param input_format: The format of the input data, either one document per
file or one document per line.
:param output_bucket: The Amazon S3 bucket where output data is written.
:param output_key: The prefix prepended to the output data.
:param data_access_role_arn: The Amazon Resource Name (ARN) of a role that
grants Comprehend permission to read from the
input bucket and write to the output bucket.
:return: Information about the job, including the job ID.
"""
try:
response = self.comprehend_client.start_topics_detection_job(
JobName=job_name,
DataAccessRoleArn=data_access_role_arn,
InputDataConfig={
"S3Uri": f"s3://{input_bucket}/{input_key}",
"InputFormat": input_format.value,
},
OutputDataConfig={"S3Uri": f"s3://{output_bucket}/{output_key}"},
)
logger.info("Started topic modeling job %s.", response["JobId"])
except ClientError:
logger.exception("Couldn't start topic modeling job.")
raise
else:
return response
def describe_job(self, job_id):
"""
Gets metadata about a topic modeling job.
:param job_id: The ID of the job to look up.
:return: Metadata about the job.
"""
try:
response = self.comprehend_client.describe_topics_detection_job(
JobId=job_id
)
job = response["TopicsDetectionJobProperties"]
logger.info("Got topic detection job %s.", job_id)
except ClientError:
logger.exception("Couldn't get topic detection job %s.", job_id)
raise
else:
return job
def list_jobs(self):
"""
Lists topic modeling jobs for the current account.
:return: The list of jobs.
"""
try:
response = self.comprehend_client.list_topics_detection_jobs()
jobs = response["TopicsDetectionJobPropertiesList"]
logger.info("Got %s topic detection jobs.", len(jobs))
except ClientError:
logger.exception("Couldn't get topic detection jobs.")
raise
else:
return jobs
```
使用包装器类运行主题建模任务并获取任务数据。
```
def usage_demo():
print("-" * 88)
print("Welcome to the Amazon Comprehend topic modeling demo!")
print("-" * 88)
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
input_prefix = "input/"
output_prefix = "output/"
demo_resources = ComprehendDemoResources(
boto3.resource("s3"), boto3.resource("iam")
)
topic_modeler = ComprehendTopicModeler(boto3.client("comprehend"))
print("Setting up storage and security resources needed for the demo.")
demo_resources.setup("comprehend-topic-modeler-demo")
print("Copying sample data from public bucket into input bucket.")
demo_resources.bucket.copy(
{"Bucket": "public-sample-us-west-2", "Key": "TopicModeling/Sample.txt"},
f"{input_prefix}sample.txt",
)
print("Starting topic modeling job on sample data.")
job_info = topic_modeler.start_job(
"demo-topic-modeling-job",
demo_resources.bucket.name,
input_prefix,
JobInputFormat.per_line,
demo_resources.bucket.name,
output_prefix,
demo_resources.data_access_role.arn,
)
print(
f"Waiting for job {job_info['JobId']} to complete. This typically takes "
f"20 - 30 minutes."
)
job_waiter = JobCompleteWaiter(topic_modeler.comprehend_client)
job_waiter.wait(job_info["JobId"])
job = topic_modeler.describe_job(job_info["JobId"])
print(f"Job {job['JobId']} complete:")
pprint(job)
print(
f"Getting job output data from the output Amazon S3 bucket: "
f"{job['OutputDataConfig']['S3Uri']}."
)
job_output = demo_resources.extract_job_output(job)
lines = 10
print(f"First {lines} lines of document topics output:")
pprint(job_output["doc-topics.csv"]["data"][:lines])
print(f"First {lines} lines of terms output:")
pprint(job_output["topic-terms.csv"]["data"][:lines])
print("Cleaning up resources created for the demo.")
demo_resources.cleanup()
print("Thanks for watching!")
print("-" * 88)
```
+ 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的以下主题。
+ [DescribeTopicsDetectionJob](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DescribeTopicsDetectionJob)
+ [ListTopicsDetectionJobs](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/ListTopicsDetectionJobs)
+ [StartTopicsDetectionJob](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/StartTopicsDetectionJob)
------
有关 S AWS DK 开发者指南和代码示例的完整列表，请参阅[将 Amazon Comprehend 与 SDK 配合 AWS 使用](sdk-general-information-section.md)。本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 训练自定义 Amazon Comprehend 分类器并使用软件开发工具包对文档进行分类 AWS
以下代码示例展示了如何：
+ 创建 Amazon Comprehend 多标签分类器。
+ 在示例数据上训练分类器。
+ 对第二组数据运行分类任务。
+ 从 Amazon S3 提取任务输出数据。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
还有更多相关信息 GitHub。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/comprehend#code-examples)中查找完整示例，了解如何进行设置和运行。
创建一个包装类来调用 Amazon Comprehend 文档分类器操作。
```
class ComprehendClassifier:
"""Encapsulates an Amazon Comprehend custom classifier."""
def __init__(self, comprehend_client):
"""
:param comprehend_client: A Boto3 Comprehend client.
"""
self.comprehend_client = comprehend_client
self.classifier_arn = None
def create(
self,
name,
language_code,
training_bucket,
training_key,
data_access_role_arn,
mode,
):
"""
Creates a custom classifier. After the classifier is created, it immediately
starts training on the data found in the specified Amazon S3 bucket. Training
can take 30 minutes or longer. The `describe_document_classifier` function
can be used to get training status and returns a status of TRAINED when the
classifier is ready to use.
:param name: The name of the classifier.
:param language_code: The language the classifier can operate on.
:param training_bucket: The Amazon S3 bucket that contains the training data.
:param training_key: The prefix used to find training data in the training
bucket. If multiple objects have the same prefix, all
of them are used.
:param data_access_role_arn: The Amazon Resource Name (ARN) of a role that
grants Comprehend permission to read from the
training bucket.
:return: The ARN of the newly created classifier.
"""
try:
response = self.comprehend_client.create_document_classifier(
DocumentClassifierName=name,
LanguageCode=language_code,
InputDataConfig={"S3Uri": f"s3://{training_bucket}/{training_key}"},
DataAccessRoleArn=data_access_role_arn,
Mode=mode.value,
)
self.classifier_arn = response["DocumentClassifierArn"]
logger.info("Started classifier creation. Arn is: %s.", self.classifier_arn)
except ClientError:
logger.exception("Couldn't create classifier %s.", name)
raise
else:
return self.classifier_arn
def describe(self, classifier_arn=None):
"""
Gets metadata about a custom classifier, including its current status.
:param classifier_arn: The ARN of the classifier to look up.
:return: Metadata about the classifier.
"""
if classifier_arn is not None:
self.classifier_arn = classifier_arn
try:
response = self.comprehend_client.describe_document_classifier(
DocumentClassifierArn=self.classifier_arn
)
classifier = response["DocumentClassifierProperties"]
logger.info("Got classifier %s.", self.classifier_arn)
except ClientError:
logger.exception("Couldn't get classifier %s.", self.classifier_arn)
raise
else:
return classifier
def list(self):
"""
Lists custom classifiers for the current account.
:return: The list of classifiers.
"""
try:
response = self.comprehend_client.list_document_classifiers()
classifiers = response["DocumentClassifierPropertiesList"]
logger.info("Got %s classifiers.", len(classifiers))
except ClientError:
logger.exception(
"Couldn't get classifiers.",
)
raise
else:
return classifiers
def delete(self):
"""
Deletes the classifier.
"""
try:
self.comprehend_client.delete_document_classifier(
DocumentClassifierArn=self.classifier_arn
)
logger.info("Deleted classifier %s.", self.classifier_arn)
self.classifier_arn = None
except ClientError:
logger.exception("Couldn't deleted classifier %s.", self.classifier_arn)
raise
def start_job(
self,
job_name,
input_bucket,
input_key,
input_format,
output_bucket,
output_key,
data_access_role_arn,
):
"""
Starts a classification job. The classifier must be trained or the job
will fail. Input is read from the specified Amazon S3 input bucket and
written to the specified output bucket. Output data is stored in a tar
archive compressed in gzip format. The job runs asynchronously, so you can
call `describe_document_classification_job` to get job status until it
returns a status of SUCCEEDED.
:param job_name: The name of the job.
:param input_bucket: The Amazon S3 bucket that contains input data.
:param input_key: The prefix used to find input data in the input
bucket. If multiple objects have the same prefix, all
of them are used.
:param input_format: The format of the input data, either one document per
file or one document per line.
:param output_bucket: The Amazon S3 bucket where output data is written.
:param output_key: The prefix prepended to the output data.
:param data_access_role_arn: The Amazon Resource Name (ARN) of a role that
grants Comprehend permission to read from the
input bucket and write to the output bucket.
:return: Information about the job, including the job ID.
"""
try:
response = self.comprehend_client.start_document_classification_job(
DocumentClassifierArn=self.classifier_arn,
JobName=job_name,
InputDataConfig={
"S3Uri": f"s3://{input_bucket}/{input_key}",
"InputFormat": input_format.value,
},
OutputDataConfig={"S3Uri": f"s3://{output_bucket}/{output_key}"},
DataAccessRoleArn=data_access_role_arn,
)
logger.info(
"Document classification job %s is %s.", job_name, response["JobStatus"]
)
except ClientError:
logger.exception("Couldn't start classification job %s.", job_name)
raise
else:
return response
def describe_job(self, job_id):
"""
Gets metadata about a classification job.
:param job_id: The ID of the job to look up.
:return: Metadata about the job.
"""
try:
response = self.comprehend_client.describe_document_classification_job(
JobId=job_id
)
job = response["DocumentClassificationJobProperties"]
logger.info("Got classification job %s.", job["JobName"])
except ClientError:
logger.exception("Couldn't get classification job %s.", job_id)
raise
else:
return job
def list_jobs(self):
"""
Lists the classification jobs for the current account.
:return: The list of jobs.
"""
try:
response = self.comprehend_client.list_document_classification_jobs()
jobs = response["DocumentClassificationJobPropertiesList"]
logger.info("Got %s document classification jobs.", len(jobs))
except ClientError:
logger.exception(
"Couldn't get document classification jobs.",
)
raise
else:
return jobs
```
创建帮组运行场景的类。
```
class ClassifierDemo:
"""
Encapsulates functions used to run the demonstration.
"""
def __init__(self, demo_resources):
"""
:param demo_resources: A ComprehendDemoResources class that manages resources
for the demonstration.
"""
self.demo_resources = demo_resources
self.training_prefix = "training/"
self.input_prefix = "input/"
self.input_format = JobInputFormat.per_line
self.output_prefix = "output/"
def setup(self):
"""Creates AWS resources used by the demo."""
self.demo_resources.setup("comprehend-classifier-demo")
def cleanup(self):
"""Deletes AWS resources used by the demo."""
self.demo_resources.cleanup()
@staticmethod
def _sanitize_text(text):
"""Removes characters that cause errors for the document parser."""
return text.replace("\r", " ").replace("\n", " ").replace(",", ";")
@staticmethod
def _get_issues(query, issue_count):
"""
Gets issues from GitHub using the specified query parameters.
:param query: The query string used to request issues from the GitHub API.
:param issue_count: The number of issues to retrieve.
:return: The list of issues retrieved from GitHub.
"""
issues = []
logger.info("Requesting issues from %s?%s.", GITHUB_SEARCH_URL, query)
response = requests.get(f"{GITHUB_SEARCH_URL}?{query}&per_page={issue_count}")
if response.status_code == 200:
issue_page = response.json()["items"]
logger.info("Got %s issues.", len(issue_page))
issues = [
{
"title": ClassifierDemo._sanitize_text(issue["title"]),
"body": ClassifierDemo._sanitize_text(issue["body"]),
"labels": {label["name"] for label in issue["labels"]},
}
for issue in issue_page
]
else:
logger.error(
"GitHub returned error code %s with message %s.",
response.status_code,
response.json(),
)
logger.info("Found %s issues.", len(issues))
return issues
def get_training_issues(self, training_labels):
"""
Gets issues used for training the custom classifier. Training issues are
closed issues from the Boto3 repo that have known labels. Comprehend
requires a minimum of ten training issues per label.
:param training_labels: The issue labels to use for training.
:return: The set of issues used for training.
"""
issues = []
per_label_count = 15
for label in training_labels:
issues += self._get_issues(
f"q=type:issue+repo:boto/boto3+state:closed+label:{label}",
per_label_count,
)
for issue in issues:
issue["labels"] = issue["labels"].intersection(training_labels)
return issues
def get_input_issues(self, training_labels):
"""
Gets input issues from GitHub. For demonstration purposes, input issues
are open issues from the Boto3 repo with known labels, though in practice
any issue could be submitted to the classifier for labeling.
:param training_labels: The set of labels to query for.
:return: The set of issues used for input.
"""
issues = []
per_label_count = 5
for label in training_labels:
issues += self._get_issues(
f"q=type:issue+repo:boto/boto3+state:open+label:{label}",
per_label_count,
)
return issues
def upload_issue_data(self, issues, training=False):
"""
Uploads issue data to an Amazon S3 bucket, either for training or for input.
The data is first put into the format expected by Comprehend. For training,
the set of pipe-delimited labels is prepended to each document. For
input, labels are not sent.
:param issues: The set of issues to upload to Amazon S3.
:param training: Indicates whether the issue data is used for training or
input.
"""
try:
obj_key = (
self.training_prefix if training else self.input_prefix
) + "issues.txt"
if training:
issue_strings = [
f"{'|'.join(issue['labels'])},{issue['title']} {issue['body']}"
for issue in issues
]
else:
issue_strings = [
f"{issue['title']} {issue['body']}" for issue in issues
]
issue_bytes = BytesIO("\n".join(issue_strings).encode("utf-8"))
self.demo_resources.bucket.upload_fileobj(issue_bytes, obj_key)
logger.info(
"Uploaded data as %s to bucket %s.",
obj_key,
self.demo_resources.bucket.name,
)
except ClientError:
logger.exception(
"Couldn't upload data to bucket %s.", self.demo_resources.bucket.name
)
raise
def extract_job_output(self, job):
"""Extracts job output from Amazon S3."""
return self.demo_resources.extract_job_output(job)
@staticmethod
def reconcile_job_output(input_issues, output_dict):
"""
Reconciles job output with the list of input issues. Because the input issues
have known labels, these can be compared with the labels added by the
classifier to judge the accuracy of the output.
:param input_issues: The list of issues used as input.
:param output_dict: The dictionary of data that is output by the classifier.
:return: The list of reconciled input and output data.
"""
reconciled = []
for archive in output_dict.values():
for line in archive["data"]:
in_line = int(line["Line"])
in_labels = input_issues[in_line]["labels"]
out_labels = {
label["Name"]
for label in line["Labels"]
if float(label["Score"]) > 0.3
}
reconciled.append(
f"{line['File']}, line {in_line} has labels {in_labels}.\n"
f"\tClassifier assigned {out_labels}."
)
logger.info("Reconciled input and output labels.")
return reconciled
```
使用已知标签对分类器进行一系列 GitHub 问题训练，然后将第二组 GitHub 问题发送给分类器以便对其进行标记。
```
def usage_demo():
print("-" * 88)
print("Welcome to the Amazon Comprehend custom document classifier demo!")
print("-" * 88)
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
comp_demo = ClassifierDemo(
ComprehendDemoResources(boto3.resource("s3"), boto3.resource("iam"))
)
comp_classifier = ComprehendClassifier(boto3.client("comprehend"))
classifier_trained_waiter = ClassifierTrainedWaiter(
comp_classifier.comprehend_client
)
training_labels = {"bug", "feature-request", "dynamodb", "s3"}
print("Setting up storage and security resources needed for the demo.")
comp_demo.setup()
print("Getting training data from GitHub and uploading it to Amazon S3.")
training_issues = comp_demo.get_training_issues(training_labels)
comp_demo.upload_issue_data(training_issues, True)
classifier_name = "doc-example-classifier"
print(f"Creating document classifier {classifier_name}.")
comp_classifier.create(
classifier_name,
"en",
comp_demo.demo_resources.bucket.name,
comp_demo.training_prefix,
comp_demo.demo_resources.data_access_role.arn,
ClassifierMode.multi_label,
)
print(
f"Waiting until {classifier_name} is trained. This typically takes "
f"30–40 minutes."
)
classifier_trained_waiter.wait(comp_classifier.classifier_arn)
print(f"Classifier {classifier_name} is trained:")
pprint(comp_classifier.describe())
print("Getting input data from GitHub and uploading it to Amazon S3.")
input_issues = comp_demo.get_input_issues(training_labels)
comp_demo.upload_issue_data(input_issues)
print("Starting classification job on input data.")
job_info = comp_classifier.start_job(
"issue_classification_job",
comp_demo.demo_resources.bucket.name,
comp_demo.input_prefix,
comp_demo.input_format,
comp_demo.demo_resources.bucket.name,
comp_demo.output_prefix,
comp_demo.demo_resources.data_access_role.arn,
)
print(f"Waiting for job {job_info['JobId']} to complete.")
job_waiter = JobCompleteWaiter(comp_classifier.comprehend_client)
job_waiter.wait(job_info["JobId"])
job = comp_classifier.describe_job(job_info["JobId"])
print(f"Job {job['JobId']} complete:")
pprint(job)
print(
f"Getting job output data from Amazon S3: "
f"{job['OutputDataConfig']['S3Uri']}."
)
job_output = comp_demo.extract_job_output(job)
print("Job output:")
pprint(job_output)
print("Reconciling job output with labels from GitHub:")
reconciled_output = comp_demo.reconcile_job_output(input_issues, job_output)
print(*reconciled_output, sep="\n")
answer = input(f"Do you want to delete the classifier {classifier_name} (y/n)? ")
if answer.lower() == "y":
print(f"Deleting {classifier_name}.")
comp_classifier.delete()
print("Cleaning up resources created for the demo.")
comp_demo.cleanup()
print("Thanks for watching!")
print("-" * 88)
```
+ 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的以下主题。
+ [CreateDocumentClassifier](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/CreateDocumentClassifier)
+ [DeleteDocumentClassifier](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DeleteDocumentClassifier)
+ [DescribeDocumentClassificationJob](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DescribeDocumentClassificationJob)
+ [DescribeDocumentClassifier](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/DescribeDocumentClassifier)
+ [ListDocumentClassificationJobs](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/ListDocumentClassificationJobs)
+ [ListDocumentClassifiers](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/ListDocumentClassifiers)
+ [StartDocumentClassificationJob](https://docs.aws.amazon.com/goto/boto3/comprehend-2017-11-27/StartDocumentClassificationJob)
------
有关 S AWS DK 开发者指南和代码示例的完整列表，请参阅[将 Amazon Comprehend 与 SDK 配合 AWS 使用](sdk-general-information-section.md)。本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。