Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Kirim satu prompt dengan InvokeModel
Anda menjalankan inferensi pada satu prompt dengan menggunakan operasi [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)dan [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API dan menentukan model. Model Amazon Bedrock berbeda dalam apakah mereka menerima input teks, gambar, atau video dan apakah mereka dapat menghasilkan output teks, gambar, atau embeddings. Beberapa model dapat mengembalikan respons dalam aliran. Untuk memeriksa dukungan model untuk dukungan input, output, dan streaming, lakukan salah satu hal berikut:
+ Periksa nilai dalam modalitas **input, modalitas** **Output**, atau kolom yang **didukung Streaming** untuk model di. [Model pondasi yang didukung di Amazon Bedrock](models-supported.md)
+ Kirim [GetFoundationModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetFoundationModel.html)permintaan dengan ID model dan periksa nilai di `responseStreamingSupported` bidang `inputModalities``outputModalities`,, dan.
Jalankan inferensi model pada prompt dengan mengirimkan [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)atau [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)permintaan dengan titik akhir [runtime Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt).
**catatan**
Pembatasan berlaku untuk operasi berikut:`InvokeModel`,`InvokeModelWithResponseStream`,`Converse`, dan`ConverseStream`. Lihat [pembatasan API](inference-api-restrictions.md) untuk detailnya.
Bidang berikut diperlukan:
****
| Bidang | Kasus penggunaan |
| --- | --- |
| modelId | Untuk menentukan model, profil inferensi, atau prompt dari manajemen Prompt untuk digunakan. Untuk mempelajari cara menemukan nilai ini, lihat[Kirim prompt dan hasilkan respons menggunakan API](inference-api.md). |
| body | Untuk menentukan parameter inferensi untuk model. Untuk melihat parameter inferensi untuk model yang berbeda, lihat[Parameter permintaan inferensi dan bidang respons untuk model dasar](model-parameters.md). Jika Anda menentukan prompt dari manajemen Prompt di modelId bidang, hilangkan bidang ini (jika Anda memasukkannya, itu akan diabaikan). |
Bidang berikut adalah opsional:
****
| Bidang | Kasus penggunaan |
| --- | --- |
| menerima | Untuk menentukan jenis media untuk badan permintaan. Untuk informasi selengkapnya, lihat Jenis Media di [Swaggersitus web](https://swagger.io/specification/). |
| ContentType | Untuk menentukan jenis media untuk badan respons. Untuk informasi selengkapnya, lihat Jenis Media di [Swaggersitus web](https://swagger.io/specification/). |
| performanceConfigLatency | Untuk menentukan apakah akan mengoptimalkan model untuk latensi. Untuk informasi selengkapnya, lihat [Optimalkan inferensi model untuk latensi](latency-optimized-inference.md). |
| GuardraIlidentifier | Untuk menentukan pagar pembatas untuk diterapkan pada prompt dan respons. Untuk informasi selengkapnya, lihat [Uji pagar pembatas Anda](guardrails-test.md). |
| GuardrailVersion | Untuk menentukan pagar pembatas untuk diterapkan pada prompt dan respons. Untuk informasi selengkapnya, lihat [Uji pagar pembatas Anda](guardrails-test.md). |
| jejak | Untuk menentukan apakah akan mengembalikan jejak untuk pagar pembatas yang Anda tentukan. Untuk informasi selengkapnya, lihat [Uji pagar pembatas Anda](guardrails-test.md). |
| ServiceTier | Untuk menentukan tingkat layanan untuk permintaan. Untuk informasi selengkapnya, lihat [Tingkat layanan untuk mengoptimalkan kinerja dan biaya](service-tiers-inference.md). |
## Memanggil contoh kode model
Topik ini memberikan beberapa contoh dasar untuk menjalankan inferensi menggunakan satu prompt dengan [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API. Untuk contoh lainnya dengan model yang berbeda, kunjungi sumber daya berikut:
+ Pilih contoh di bawah [Contoh kode untuk Amazon Bedrock Runtime menggunakan AWS SDKs](service_code_examples_bedrock-runtime.md) topik.
+ Kunjungi referensi parameter inferensi untuk model yang diinginkan di[Parameter permintaan inferensi dan bidang respons untuk model dasar](model-parameters.md).
Contoh berikut mengasumsikan bahwa Anda telah menyiapkan akses terprogram sehingga Anda secara otomatis mengautentikasi ke AWS CLI dan SDK for Python (Boto3) secara default ketika Anda menjalankan contoh ini. Wilayah AWS Untuk informasi tentang pengaturan akses pemrograman, lihat[Memulai dengan API](getting-started-api.md).
**catatan**
Tinjau poin-poin berikut sebelum mencoba contoh:
Anda harus menguji contoh-contoh ini di US East (Virginia N.) (us-east-1), yang mendukung semua model yang digunakan dalam contoh.
`body`Parameternya bisa besar, jadi untuk beberapa contoh CLI, Anda akan diminta untuk membuat file JSON dan memberikan file itu ke dalam `--body` argumen alih-alih menentukannya di baris perintah.
Untuk contoh gambar dan video, Anda akan diminta untuk menggunakan gambar dan video Anda sendiri. Contohnya mengasumsikan bahwa file gambar Anda diberi nama *image.png* dan file video Anda diberi nama*video.mp4*.
Anda mungkin harus mengonversi gambar atau video menjadi string yang dikodekan base64 atau mengunggahnya ke lokasi Amazon S3. Dalam contoh, Anda harus mengganti placeholder dengan string yang dikodekan base64 atau lokasi S3 yang sebenarnya.
Perluas bagian untuk mencoba beberapa contoh kode dasar.
### Hasilkan teks dengan prompt teks
Contoh berikut menghasilkan respons teks ke prompt teks menggunakan Titan Text Premier model Amazon. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Jalankan perintah berikut di terminal dan temukan respons yang dihasilkan dalam file bernama*invoke-model-output.txt*.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-text-premier-v1:0 \
--body '{
"inputText": "Describe the purpose of a 'hello world' program in one line.",
"textGenerationConfig": {
"maxTokenCount": 512,
"temperature": 0.5
}
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Jalankan contoh kode Python berikut untuk menghasilkan respons teks:
```
# Use the native inference API to send a text message to Amazon Titan Text.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Text Premier.
model_id = "amazon.titan-text-premier-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"inputText": prompt,
"textGenerationConfig": {
"maxTokenCount": 512,
"temperature": 0.5,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["results"][0]["outputText"]
print(response_text)
```
------
### Hasilkan teks dengan prompt teks menggunakan tingkat layanan
Contoh berikut menghasilkan respons teks ke prompt teks menggunakan model OpenAI GPT dengan tingkat layanan untuk memprioritaskan permintaan. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Jalankan perintah berikut di terminal dan validasi tingkat layanan dalam respons.
```
aws bedrock-runtime invoke-model \
--model-id openai.gpt-oss-120b-1:0 \
--body '{
"messages": [
{
"role": "user",
"content": "Describe the purpose of a '\''hello world'\'' program in one line."
}
],
"max_tokens": 512,
"temperature": 0.7
}' \
--content-type application/json \
--accept application/json \
--service-tier priority \
--cli-binary-format raw-in-base64-out
```
------
#### [ Python ]
Jalankan contoh kode Python berikut untuk menghasilkan respons teks dengan tingkat layanan:
```
import boto3
import json
# Create a Bedrock Runtime client
bedrock_runtime = boto3.client(
service_name="bedrock-runtime",
region_name="us-east-1"
)
# Define the model ID and request body
model_id = "openai.gpt-oss-120b-1:0"
body = json.dumps({
"messages": [
{
"role": "user",
"content": "Describe the purpose of a 'hello world' program in one line."
}
],
"max_tokens": 512,
"temperature": 0.7
})
# Make the request with service tier
response = bedrock_runtime.invoke_model(
modelId=model_id,
body=body,
contentType="application/json",
accept="application/json",
serviceTier="priority"
)
# Parse and print the response
response_body = json.loads(response["body"])
print(response_body)
```
------
### Hasilkan gambar dengan prompt teks
Contoh kode berikut menghasilkan gambar menggunakan prompt teks dengan model Stable Diffusion XL 1.0. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Jalankan perintah berikut di terminal dan temukan respons yang dihasilkan dalam file bernama*invoke-model-output.txt*. Byte yang mewakili gambar dapat ditemukan di `base64` bidang dalam respons:
```
aws bedrock-runtime invoke-model \
--model-id stability.stable-diffusion-xl-v1 \
--body '{
"text_prompts": [{"text": "A stylized picture of a cute old steampunk robot."}],
"style_preset": "photographic",
"seed": 0,
"cfg_scale": 10,
"steps": 30
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Jalankan contoh kode Python berikut untuk menghasilkan gambar dan menemukan file *stability\$11.png* gambar yang dihasilkan dalam folder bernama. *output*
```
# Use the native inference API to create an image with Amazon Titan Image Generator
import base64
import boto3
import json
import os
import random
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Image Generator G1.
model_id = "amazon.titan-image-generator-v2:0"
# Define the image generation prompt for the model.
prompt = "A stylized picture of a cute old steampunk robot."
# Generate a random seed.
seed = random.randint(0, 2147483647)
# Format the request payload using the model's native structure.
native_request = {
"taskType": "TEXT_IMAGE",
"textToImageParams": {"text": prompt},
"imageGenerationConfig": {
"numberOfImages": 1,
"quality": "standard",
"cfgScale": 8.0,
"height": 512,
"width": 512,
"seed": seed,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract the image data.
base64_image_data = model_response["images"][0]
# Save the generated image to a local folder.
i, output_dir = 1, "output"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
while os.path.exists(os.path.join(output_dir, f"titan_{i}.png")):
i += 1
image_data = base64.b64decode(base64_image_data)
image_path = os.path.join(output_dir, f"titan_{i}.png")
with open(image_path, "wb") as file:
file.write(image_data)
print(f"The generated image has been saved to {image_path}")
```
------
### Hasilkan embeddings dari teks
Contoh berikut menggunakan Titan Text Embeddings V2 model Amazon untuk menghasilkan embeddings biner untuk input teks. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Jalankan perintah berikut di terminal dan temukan respons yang dihasilkan dalam file bernama*invoke-model-output.txt*. Embeddings yang dihasilkan ada di lapangan. `binary`
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-embed-text-v2:0 \
--body '{
"inputText": "What are the different services that you offer?",
"embeddingTypes": ["binary"]
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Jalankan contoh kode Python berikut untuk menghasilkan embeddings untuk teks yang disediakan:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an embedding with the Amazon Titan Text Embeddings V2 Model
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embedding(model_id, body):
"""
Generate an embedding with the vector representation of a text input using Amazon Titan Text Embeddings G1 on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embedding created by the model and the number of input tokens.
"""
logger.info("Generating an embedding with Amazon Titan Text Embeddings V2 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Amazon Titan Embeddings V2 - Text example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "amazon.titan-embed-text-v2:0"
input_text = "What are the different services that you offer?"
# Create request body.
body = json.dumps({
"inputText": input_text,
"embeddingTypes": ["binary"]
})
try:
response = generate_embedding(model_id, body)
print(f"Generated an embedding: {response['embeddingsByType']['binary']}") # returns binary embedding
print(f"Input text: {input_text}")
print(f"Input Token count: {response['inputTextTokenCount']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(f"Finished generating an embedding with Amazon Titan Text Embeddings V2 model {model_id}.")
if __name__ == "__main__":
main()
```
------
### Hasilkan embeddings dari gambar
Contoh berikut menggunakan Titan Multimodal Embeddings G1 model Amazon untuk menghasilkan embeddings untuk input gambar. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Buka terminal dan lakukan hal berikut:
1. Ubah gambar berjudul *image.png* di folder Anda saat ini menjadi string yang dikodekan base64 dan tulis ke file berjudul dengan menjalankan perintah berikut*image.txt*:
```
base64 -i image.png -o image.txt
```
1. Buat file JSON yang disebut *image-input-embeddings-output.json* dan tempel JSON berikut, ganti *\$1\$1image-base64\$1* dengan isi *image.txt* file (pastikan tidak ada baris baru di akhir string):
```
{
"inputImage": "${image-base64}",
"embeddingConfig": {
"outputEmbeddingLength": 256
}
}
```
1. Jalankan perintah berikut, tentukan *image-input-embeddings-output.json* file sebagai tubuh.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-embed-image-v1 \
--body file://image-input-embeddings-output.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Temukan embeddings yang dihasilkan dalam file. *invoke-model-output.txt*
------
#### [ Python ]
Dalam skrip Python berikut, ganti */path/to/image* dengan jalur ke gambar yang sebenarnya. Kemudian jalankan skrip untuk menghasilkan embeddings:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings from an image with the Amazon Titan Multimodal Embeddings G1 model (on demand).
"""
import base64
import json
import logging
import boto3
from botocore.exceptions import ClientError
class EmbedError(Exception):
"Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embeddings(model_id, body):
"""
Generate a vector of embeddings for an image input using Amazon Titan Multimodal Embeddings G1 on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embeddings that the model generated, token information, and the
reason the model stopped generating embeddings.
"""
logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings G1 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
finish_reason = response_body.get("message")
if finish_reason is not None:
raise EmbedError(f"Embeddings generation error: {finish_reason}")
return response_body
def main():
"""
Entrypoint for Amazon Titan Multimodal Embeddings G1 example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
model_id = 'amazon.titan-embed-image-v1'
output_embedding_length = 256
# Create request body.
body = json.dumps({
"inputImage": input_image,
"embeddingConfig": {
"outputEmbeddingLength": output_embedding_length
}
})
try:
response = generate_embeddings(model_id, body)
print(f"Generated image embeddings of length {output_embedding_length}: {response['embedding']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except EmbedError as err:
logger.error(err.message)
print(err.message)
else:
print(f"Finished generating image embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.")
if __name__ == "__main__":
main()
```
------
### Hasilkan respons teks ke gambar dengan prompt teks yang menyertainya
Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Contoh berikut menggunakan Anthropic Claude 3 Haiku model untuk menghasilkan respons, diberikan gambar dan prompt teks yang menanyakan isi gambar. Buka terminal dan lakukan hal berikut:
1. Ubah gambar berjudul *image.png* di folder Anda saat ini menjadi string yang dikodekan base64 dan tulis ke file berjudul dengan menjalankan perintah berikut*image.txt*:
```
base64 -i image.png -o image.txt
```
1. Buat file JSON yang disebut *image-text-input.json* dan tempel JSON berikut, ganti *\$1\$1image-base64\$1* dengan isi *image.txt* file (pastikan tidak ada baris baru di akhir string):
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1000,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": "${image-base64}"
}
},
{
"type": "text",
"text": "What's in this image?"
}
]
}
]
}
```
1. Jalankan perintah berikut untuk menghasilkan output teks, berdasarkan gambar dan prompt teks yang menyertainya, ke file bernama: *invoke-model-output.txt*
```
aws bedrock-runtime invoke-model \
--model-id anthropic.claude-3-haiku-20240307-v1:0 \
--body file://image-text-input.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Temukan output dalam *invoke-model-output.txt* file di folder saat ini.
------
#### [ Python ]
Dalam skrip python berikut, ganti */path/to/image.png* dengan jalur aktual ke gambar sebelum menjalankan skrip:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Anthropic Claude (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude multimodal prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
max_tokens = 1000
input_text = "What's in this image?"
input_image = "/path/to/image" # Replace with actual path to image file
# Read reference image from file and encode as base64 strings.
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as image_file:
content_image = base64.b64encode(image_file.read()).decode('utf8')
message = {
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": f"image/{image_ext}",
"data": content_image
}
},
{
"type": "text",
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
------
### Hasilkan respons teks ke video yang diunggah ke Amazon S3 dengan prompt teks yang menyertainya
Contoh berikut menunjukkan cara menghasilkan respons dengan Amazon Nova Lite model, mengingat video yang Anda unggah ke bucket S3 dan prompt teks yang menyertainya.
**Prasyarat:** Unggah video berjudul bucket *video.mp4* Amazon S3 di akun Anda dengan mengikuti langkah-langkah di Mengunggah [objek di](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html#upload-objects-procedure) Panduan Pengguna Layanan Penyimpanan Sederhana Amazon. Catat URI S3 dari video tersebut.
Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Buka terminal dan jalankan perintah berikut, ganti *s3://amzn-s3-demo-bucket/video.mp4* dengan lokasi S3 sebenarnya dari video Anda:
```
aws bedrock-runtime invoke-model \
--model-id amazon.nova-lite-v1:0 \
--body '{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/video.mp4"
}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
Temukan output dalam *invoke-model-output.txt* file di folder saat ini.
------
#### [ Python ]
Dalam skrip Python berikut, ganti *s3://amzn-s3-demo-bucket/video.mp4* dengan lokasi S3 sebenarnya dari video Anda. Kemudian jalankan skrip:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Nova Lite (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"messages": messages,
"inferenceConfig": {
"maxTokens": max_tokens
}
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Nova Lite video prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.nova-lite-v1:0"
max_tokens = 1000
input_video_s3_uri = "s3://amzn-s3-demo-bucket/video.mp4" # Replace with real S3 URI
video_ext = input_video_s3_uri.split(".")[-1]
input_text = "What happens in this video?"
message = {
"role": "user",
"content": [
{
"video": {
"format": video_ext,
"source": {
"s3Location": {
"uri": input_video_s3_uri
}
}
}
},
{
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
------
### Hasilkan respons teks ke video yang dikonversi ke string berenkode base64 dengan prompt teks yang menyertainya
Contoh berikut menunjukkan cara menghasilkan respons dengan Amazon Nova Lite model, mengingat video yang dikonversi ke string yang dikodekan base64 dan prompt teks yang menyertainya. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Lakukan hal-hal berikut:
1. Ubah video berjudul *video.mp4* di folder Anda saat ini menjadi base64 dengan menjalankan perintah berikut:
```
base64 -i video.mp4 -o video.txt
```
1. Buat file JSON bernama *video-text-input.json* dan tempel JSON berikut, ganti *\$1\$1video-base64\$1* dengan isi `video.txt` file (pastikan tidak ada baris baru di akhir):
```
{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": ${video-base64}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}
```
1. Jalankan perintah berikut untuk menghasilkan output teks berdasarkan video dan prompt teks yang menyertainya ke file bernama: *invoke-model-output.txt*
```
aws bedrock-runtime invoke-model \
--model-id amazon.nova-lite-v1:0 \
--body file://video-text-input.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Temukan output dalam *invoke-model-output.txt* file di folder saat ini.
------
#### [ Python ]
Dalam skrip Python berikut, ganti */path/to/video.mp4* dengan jalur sebenarnya ke video. Kemudian jalankan skrip:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Nova Lite (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"messages": messages,
"inferenceConfig": {
"maxTokens": max_tokens
}
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Nova Lite video prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.nova-lite-v1:0"
max_tokens = 1000
input_video = "/path/to/video.mp4" # Replace with real path to video
video_ext = input_video.split(".")[-1]
input_text = "What happens in this video?"
# Read reference video from file and encode as base64 string.
with open(input_video, "rb") as video_file:
content_video = base64.b64encode(video_file.read()).decode('utf8')\
message = {
"role": "user",
"content": [
{
"video": {
"format": video_ext,
"source": {
"bytes": content_video
}
}
},
{
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
------
## Memanggil model dengan contoh kode streaming
**catatan**
AWS CLI Tidak mendukung streaming.
Contoh berikut menunjukkan cara menggunakan [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API untuk menghasilkan teks streaming dengan Python menggunakan prompt. *write an essay for living on mars in 1000 words*
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
'prompt': '\n\nHuman: write an essay for living on mars in 1000 words\n\nAssistant:',
'max_tokens_to_sample': 4000
})
response = brt.invoke_model_with_response_stream(
modelId='anthropic.claude-v2',
body=body
)
stream = response.get('body')
if stream:
for event in stream:
chunk = event.get('chunk')
if chunk:
print(json.loads(chunk.get('bytes').decode()))
```