翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# SDK を使用した Amazon Comprehend のシナリオ AWS SDKs
次のコード例は、 AWS SDKs を使用して Amazon Comprehend で一般的なシナリオを実装する方法を示しています。これらのシナリオは、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 ストリーミングアプリケーションを構築する
次のコード例は、ライブ音声をリアルタイムで記録、転写、翻訳し、結果を E メールで送信するアプリケーションを構築する方法を示しています。
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
Amazon Transcribe を使用して、ライブ音声をリアルタイムで記録、転写、翻訳し、Amazon Simple Email Service (Amazon SES) を使用して結果を E メールで送信するアプリケーションを構築する方法について説明します。
完全なソースコードとセットアップおよび実行の手順については、[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
------
AWS SDK 開発者ガイドとコード例の完全なリストについては、「」を参照してください[AWS SDK での Amazon Comprehend の使用](sdk-general-information-section.md)。このトピックには、使用開始方法に関する情報と、以前の SDK バージョンの詳細も含まれています。
# Amazon Lex チャットボットを作成して、ウェブサイトの訪問者を引き付けましょう
次のコード例は、Web サイトの訪問者を引き込むチャットボットを作成する方法を示しています。
------
#### [ Java ]
**SDK for Java 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 ]
**SDK for JavaScript (v3)**
Amazon Lex API を使用して、ウェブアプリケーション内にチャットボットを作成し、Web サイトの訪問者と交流する方法を説明します。
完全なソースコードとセットアップと実行の手順については、 デ AWS SDK for JavaScript ベロッパーガイドの[Amazon Lexチャットボットの構築](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/lex-bot-example.html)」の完全な例を参照してください。
**この例で使用されているサービス**
+ Amazon Comprehend
+ Amazon Lex
+ Amazon Translate
------
AWS SDK 開発者ガイドとコード例の完全なリストについては、「」を参照してください[AWS SDK での Amazon Comprehend の使用](sdk-general-information-section.md)。このトピックには、使用開始方法に関する情報と、以前の SDK バージョンの詳細も含まれています。
# Amazon SQS を使用してメッセージを送受信するウェブアプリケーションを作成する
次のコード例は、Amazon SQS でメッセージングアプリケーションを作成する方法を示しています。
------
#### [ Java ]
**SDK for Java 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 ]
**SDK for Kotlin**
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
------
AWS SDK 開発者ガイドとコード例の完全なリストについては、「」を参照してください[AWS SDK での Amazon Comprehend の使用](sdk-general-information-section.md)。このトピックには、使用開始方法に関する情報と、以前の SDK バージョンの詳細も含まれています。
# 顧客からのフィードバックを分析し、音声を合成するアプリケーションの作成
次のコード例では、顧客のコメントカードを分析し、それを元の言語から翻訳し、顧客の感情を判断し、翻訳されたテキストから音声ファイルを生成するアプリケーションの作成方法を示しています。
------
#### [ .NET ]
**SDK for .NET**
このサンプルアプリケーションは、顧客フィードバックカードを分析し、保存します。具体的には、ニューヨーク市の架空のホテルのニーズを満たします。このホテルでは、お客様からのフィードバックをさまざまな言語で書かれた実際のコメントカードの形で受け取ります。そのフィードバックは、ウェブクライアントを通じてアプリにアップロードされます。コメントカードの画像をアップロードされると、次の手順が発生します。
+ テキストは 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 ]
**SDK for Java 2.x**
このサンプルアプリケーションは、顧客フィードバックカードを分析し、保存します。具体的には、ニューヨーク市の架空のホテルのニーズを満たします。このホテルでは、お客様からのフィードバックをさまざまな言語で書かれた実際のコメントカードの形で受け取ります。そのフィードバックは、ウェブクライアントを通じてアプリにアップロードされます。コメントカードの画像をアップロードされると、次の手順が発生します。
+ テキストは 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 ]
**SDK for JavaScript (v3)**
このサンプルアプリケーションは、顧客フィードバックカードを分析し、保存します。具体的には、ニューヨーク市の架空のホテルのニーズを満たします。このホテルでは、お客様からのフィードバックをさまざまな言語で書かれた実際のコメントカードの形で受け取ります。そのフィードバックは、ウェブクライアントを通じてアプリにアップロードされます。コメントカードの画像をアップロードされると、次の手順が発生します。
+ テキストは 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) のプロジェクトを参照してください。次の抜粋 AWS SDK for JavaScript は、Lambda 関数内で がどのように使用されるかを示しています。
```
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 ]
**SDK for Ruby**
このサンプルアプリケーションは、顧客フィードバックカードを分析し、保存します。具体的には、ニューヨーク市の架空のホテルのニーズを満たします。このホテルでは、お客様からのフィードバックをさまざまな言語で書かれた実際のコメントカードの形で受け取ります。そのフィードバックは、ウェブクライアントを通じてアプリにアップロードされます。コメントカードの画像をアップロードされると、次の手順が発生します。
+ テキストは 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
------
AWS SDK 開発者ガイドとコード例の完全なリストについては、「」を参照してください[AWS SDK での Amazon Comprehend の使用](sdk-general-information-section.md)。このトピックには、使用開始方法に関する情報と、以前の SDK バージョンの詳細も含まれています。
# Amazon Comprehend と AWS SDK を使用してドキュメント要素を検出する
次のコード例は、以下の操作方法を示しています。
+ ドキュメント内の言語、エンティティ、キーフレーズを検出する。
+ ドキュメントから個人を特定できる情報 (PII)を検出する。
+ ドキュメントのセンチメントを検出する。
+ ドキュメントの構文要素を検出する。
------
#### [ Python ]
**SDK for Python (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
```
Wrapper クラスの関数を呼び出して、ドキュメント内のエンティティ、フレーズなどを検出します。
```
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 リファレンス*」の以下のトピックを参照してください。
+ [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)
------
AWS SDK 開発者ガイドとコード例の完全なリストについては、「」を参照してください[AWS SDK での Amazon Comprehend の使用](sdk-general-information-section.md)。このトピックには、使用開始方法に関する情報と、以前の SDK バージョンの詳細も含まれています。
# AWS SDK を使用してイメージから抽出されたテキスト内のエンティティを検出する
次のコード例は、Amazon Comprehend を使用して、Amazon S3 に格納されている画像から Amazon Textract によって抽出されたテキスト内のエンティティを検出する方法を示しています。
------
#### [ Python ]
**SDK for Python (Boto3)**
Jupyter ノートブック AWS SDK for Python (Boto3) で を使用して、イメージから抽出されたテキスト内のエンティティを検出する方法を示します。この例では、Amazon Textract を使用して Amazon Simple Storage Service (Amazon S3) に保存されている画像からテキストを抽出し、Amazon Comprehend を使用して、抽出されたテキスト内のエンティティを検出します。
この例は Jupyter Notebook であり、ノートブックをホストできる環境で実行する必要があります。Amazon SageMaker AI を使用してサンプルを実行する方法については、「[TextractAndComprehendNotebook.ipynb](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/textract_comprehend_notebook/TextractAndComprehendNotebook.ipynb)」の手順を参照してください。
完全なソースコードとセットアップおよび実行の手順については、[GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/textract_comprehend_notebook#readme) で完全な例を参照してください。
**この例で使用されているサービス**
+ Amazon Comprehend
+ Amazon S3
+ Amazon Textract
------
AWS SDK 開発者ガイドとコード例の完全なリストについては、「」を参照してください[AWS SDK での Amazon Comprehend の使用](sdk-general-information-section.md)。このトピックには、使用開始方法に関する情報と、以前の SDK バージョンの詳細も含まれています。
# AWS SDK を使用してサンプルデータで Amazon Comprehend トピックモデリングジョブを実行する
次のコード例は、以下の操作方法を示しています。
+ Amazon Comprehend トピックモデリングジョブをサンプルデータに対して実行します。
+ ジョブに関する情報｡
+ Amazon S3 のジョブ出力データを抽出します。
------
#### [ Python ]
**SDK for Python (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 リファレンス*」の以下のトピックを参照してください。
+ [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)
------
AWS SDK 開発者ガイドとコード例の完全なリストについては、「」を参照してください[AWS SDK での Amazon Comprehend の使用](sdk-general-information-section.md)。このトピックには、使用開始方法に関する情報と、以前の SDK バージョンの詳細も含まれています。
# AWS SDK を使用してカスタム Amazon Comprehend 分類子をトレーニングし、ドキュメントを分類する
次のコード例は、以下の操作方法を示しています。
+ Amazon Comprehend マルチラベル分類子を作成します。
+ 分類子をサンプルデータに基づいてトレーニングします。
+ 2 番目のデータセットで分類ジョブを実行します。
+ Amazon S3 からジョブ出力データを抽出します。
------
#### [ Python ]
**SDK for Python (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 課題について分類子をトレーニングし、次に 2 つ目の 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 リファレンス*」の以下のトピックを参照してください。
+ [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)
------
AWS SDK 開発者ガイドとコード例の完全なリストについては、「」を参照してください[AWS SDK での Amazon Comprehend の使用](sdk-general-information-section.md)。このトピックには、使用開始方法に関する情報と、以前の SDK バージョンの詳細も含まれています。