Integre modelos básicos en su código con Amazon Bedrock

El auge de los grandes modelos de lenguaje (LLM) y los modelos básicos (FM) ha revolucionado el campo del procesamiento del lenguaje natural (NLP) y la inteligencia artificial (IA). Estos poderosos modelos, entrenados con grandes cantidades de datos, pueden generar textos similares a los humanos, responder preguntas e incluso realizar tareas de escritura creativa. Sin embargo, entrenar e implementar dichos modelos desde cero es un proceso complejo y que requiere muchos recursos, y a menudo requiere experiencia especializada y importantes recursos computacionales.

Ingresar Roca Amazónicaun servicio totalmente administrado que brinda a los desarrolladores un acceso perfecto a FM de vanguardia a través de API simples. Amazon Bedrock agiliza la integración de capacidades de IA generativa de última generación para los desarrolladores, ofreciendo modelos previamente entrenados que se pueden personalizar e implementar sin la necesidad de una capacitación exhaustiva del modelo desde cero. Amazon mantiene la flexibilidad para la personalización del modelo al tiempo que simplifica el proceso, lo que facilita a los desarrolladores el uso de tecnologías de IA generativa de vanguardia en sus aplicaciones. Con Amazon Bedrock, puede integrar funciones avanzadas de PNL, como comprensión del lenguaje, generación de texto y respuesta a preguntas, en sus aplicaciones.

En esta publicación, exploramos cómo integrar Amazon Bedrock FM en su base de código, lo que le permitirá crear potentes aplicaciones basadas en IA con facilidad. Lo guiamos a través del proceso de configuración del entorno, creación del cliente Amazon Bedrock, solicitud y empaquetado del código, invocación de los modelos y uso de varios modelos e invocaciones de streaming. Al final de esta publicación, tendrá el conocimiento y las herramientas para aprovechar el poder de Amazon Bedrock FM, acelerar los cronogramas de desarrollo de sus productos y potenciar sus aplicaciones con capacidades avanzadas de IA.

Descripción general de la solución

Amazon Bedrock proporciona una forma sencilla y eficiente de utilizar FM potentes a través de API, sin la necesidad de entrenar modelos personalizados. Para esta publicación, ejecutamos el código en un cuaderno Jupyter dentro de VS Code y usamos Python. El proceso de integración de Amazon Bedrock en su base de código implica los siguientes pasos:

1. Configure su entorno de desarrollo importando las dependencias necesarias y creando un cliente de Amazon Bedrock. Este cliente servirá como punto de entrada para interactuar con Amazon Bedrock FM.
2. Una vez configurado el cliente de Amazon Bedrock, puede definir indicaciones o fragmentos de código que se utilizarán para interactuar con los FM. Estas indicaciones pueden incluir instrucciones en lenguaje natural o fragmentos de código que el modelo procesará y generará resultados en función de ellos.
3. Con las indicaciones definidas, puede invocar Amazon Bedrock FM pasando las indicaciones al cliente. Amazon Bedrock admite varios modelos, cada uno con sus propias fortalezas y capacidades, lo que le permite elegir el modelo más adecuado para su caso de uso.
4. Según el modelo y las indicaciones proporcionadas, Amazon Bedrock generará resultados, que pueden incluir texto en lenguaje natural, fragmentos de código o una combinación de ambos. Luego puede procesar e integrar este resultado en su aplicación según sea necesario.
5. Para ciertos modelos y casos de uso, Amazon Bedrock admite invocaciones de transmisión, que le permiten interactuar con el modelo en tiempo real. Esto puede resultar especialmente útil para la IA conversacional o aplicaciones interactivas en las que es necesario intercambiar múltiples indicaciones y respuestas con el modelo.

A lo largo de esta publicación, proporcionamos ejemplos de código detallados y explicaciones para cada paso, lo que le ayudará a integrar perfectamente Amazon Bedrock FM en su base de código. Al utilizar estos potentes modelos, puede mejorar sus aplicaciones con capacidades avanzadas de PNL, acelerar su proceso de desarrollo y ofrecer soluciones innovadoras a sus usuarios.

Requisitos previos

Antes de sumergirse en el proceso de integración, asegúrese de cumplir con los siguientes requisitos previos:

• cuenta de AWS – Necesitará una cuenta de AWS para acceder y utilizar Amazon Bedrock. Si no tienes uno, puedes crear una nueva cuenta.
• Entorno de desarrollo – Configure un entorno de desarrollo integrado (IDE) con su lenguaje y herramientas de codificación preferidos. Puedes interactuar con Amazon Bedrock usando SDK de AWS disponible en Python, Java, Node.js y más.
• Credenciales de AWS – Configure sus credenciales de AWS en su entorno de desarrollo para autenticarse con los servicios de AWS. Puede encontrar instrucciones sobre cómo hacer esto en la documentación de AWS del SDK elegido. En esta publicación analizamos un ejemplo de Python.

Con estos requisitos previos implementados, está listo para comenzar a integrar Amazon Bedrock FM en su código.

En su IDE, cree un nuevo archivo. Para este ejemplo, utilizamos un cuaderno Jupyter (Kernel: Python 3.12.0).

En las siguientes secciones, demostramos cómo implementar la solución en un cuaderno Jupyter.

Configurar el entorno

Para comenzar, importe las dependencias necesarias para interactuar con Amazon Bedrock. El siguiente es un ejemplo de cómo puedes hacer esto en Python.

El primer paso es importar. boto3 y json:

A continuación, cree una instancia del cliente de Amazon Bedrock. Este cliente servirá como punto de entrada para interactuar con los FM. El siguiente es un ejemplo de código de cómo crear el cliente:

bedrock_runtime = boto3.client(
    service_name="bedrock-runtime",
    region_name="us-east-1"
)

Definir indicaciones y fragmentos de código

Con el cliente de Amazon Bedrock configurado, defina indicaciones y fragmentos de código que se utilizarán para interactuar con los FM. Estas indicaciones pueden incluir instrucciones en lenguaje natural o fragmentos de código que el modelo procesará y generará resultados en función de ellos.

En este ejemplo, le preguntamos al modelo, “Hello, who are you?”.

Para enviar el mensaje al punto final de la API, necesita pasar algunos argumentos de palabras clave. Puede obtener estos argumentos desde la consola de Amazon Bedrock.

1. En la consola de Amazon Bedrock, elija Modelos básicos en el panel de navegación.
   

2. Seleccionar Texto Titan G1 – Rápido.
   

3. Elija el nombre del modelo (Texto Titan G1 – Rápido) y vaya a la solicitud de API.
   

4. Copie la solicitud de API:

{
"modelId": "amazon.titan-text-express-v1",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"inputText\":\"this is where you place your input text\",\"textGenerationConfig\":{\"maxTokenCount\":8192,\"stopSequences\":[],\"temperature\":0,\"topP\":1}}"
}

5. Inserte este código en el cuaderno de Jupyter con las siguientes modificaciones menores:
   • Publicamos las solicitudes de API en argumentos de palabras clave (kwargs).
   • El siguiente cambio se produce en el mensaje. Reemplazaremos \”aquí es donde colocas el texto ingresado\” por \”Hola, ¿quién eres?\”
6. Imprima los argumentos de las palabras clave:

kwargs = {
 "modelId": "amazon.titan-text-express-v1",
 "contentType": "application/json",
 "accept": "application/json",
 "body": "{\"inputText\":\"Hello, who are you?\",\"textGenerationConfig\":{\"maxTokenCount\":8192,\"stopSequences\":[],\"temperature\":0,\"topP\":1}}"
}
print(kwargs)

Esto debería darle el siguiente resultado:

{'modelId': 'amazon.titan-text-express-v1', 'contentType': 'application/json', 'accept': 'application/json', 'body': '{"inputText":"Hello, who are you?","textGenerationConfig":{"maxTokenCount":8192,"stopSequences":[],"temperature":0,"topP":1}}'}

Invocar el modelo

Con el mensaje definido, ahora puede invocar Amazon Bedrock FM.

1. Pase el mensaje al cliente:

response = bedrock_runtime.invoke_model(**kwargs)
response

Esto invocará el modelo de Amazon Bedrock con el mensaje proporcionado e imprimirá la respuesta del objeto de cuerpo de transmisión generado.

{'ResponseMetadata': {'RequestId': '3cfe2718-b018-4a50-94e3-59e2080c75a3',
'HTTPStatusCode': 200,
'HTTPHeaders': {'date': 'Fri, 18 Oct 2024 11:30:14 GMT',
'content-type': 'application/json',
'content-length': '255',
'connection': 'keep-alive',
'x-amzn-requestid': '3cfe2718-b018-4a50-94e3-59e2080c75a3',
'x-amzn-bedrock-invocation-latency': '1980',
'x-amzn-bedrock-output-token-count': '37',
'x-amzn-bedrock-input-token-count': '6'},
'RetryAttempts': 0},
'contentType': 'application/json',
'body': <botocore.response.StreamingBody at 0x105e8e7a0>}

El modelo de invocación del tiempo de ejecución de Amazon Bedrock anterior funcionará para el FM que elija invocar.

2. Desempaquete la cadena JSON de la siguiente manera:

response_body = json.loads(response.get('body').read())
response_body

Debería recibir la siguiente respuesta (esta es la respuesta que recibimos del modelo Titan Text G1 – Express para el mensaje que le proporcionamos).

{'inputTextTokenCount': 6, 'results': [{'tokenCount': 37, 'outputText': '\nI am Amazon Titan, a large language model built by AWS. It is designed to assist you with tasks and answer any questions you may have. How may I help you?', 'completionReason': 'FINISH'}]}

Experimenta con diferentes modelos.

Amazon Bedrock ofrece varios FM, cada uno con sus propios puntos fuertes y capacidades. Puede especificar qué modelo desea utilizar pasando el model_name parámetro al crear el cliente de Amazon Bedrock.

1. Al igual que en el ejemplo anterior de Titan Text G1 – Express, obtenga la solicitud de API desde la consola de Amazon Bedrock. Esta vez, utilizamos Claude de Anthropic en Amazon Bedrock.
   

{
"modelId": "anthropic.claude-v2",
"contentType": "application/json",
"accept": "*/*",
"body": "{\"prompt\":\"\\n\\nHuman: Hello world\\n\\nAssistant:\",\"max_tokens_to_sample\":300,\"temperature\":0.5,\"top_k\":250,\"top_p\":1,\"stop_sequences\":[\"\\n\\nHuman:\"],\"anthropic_version\":\"bedrock-2023-05-31\"}"
}

Claude de Anthropic acepta el mensaje de una manera diferente (\\n\\nHuman:), por lo que la solicitud de API en la consola de Amazon Bedrock proporciona el mensaje en la forma que Claude de Anthropic puede aceptar.

2. Edite la solicitud de API y colóquela en el argumento de palabra clave:

   kwargs = {
     "modelId": "anthropic.claude-v2",
     "contentType": "application/json",
     "accept": "*/*",
     "body": "{\"prompt\":\"\\n\\nHuman: we have received some text without any context.\\nWe will need to label the text with a title so that others can quickly see what the text is about \\n\\nHere is the text between these <text></text> XML tags\\n\\n<text>\\nToday I sent to the beach and saw a whale. I ate an ice-cream and swam in the sea\\n</text>\\n\\nProvide title between <title></title> XML tags\\n\\nAssistant:\",\"max_tokens_to_sample\":300,\"temperature\":0.5,\"top_k\":250,\"top_p\":1,\"stop_sequences\":[\"\\n\\nHuman:\"],\"anthropic_version\":\"bedrock-2023-05-31\"}"
   }
   print(kwargs)

Debería obtener la siguiente respuesta:

{'modelId': 'anthropic.claude-v2', 'contentType': 'application/json', 'accept': '*/*', 'body': '{"prompt":"\\n\\nHuman: we have received some text without any context.\\nWe will need to label the text with a title so that others can quickly see what the text is about \\n\\nHere is the text between these <text></text> XML tags\\n\\n<text>\\nToday I sent to the beach and saw a whale. I ate an ice-cream and swam in the sea\\n</text>\\n\\nProvide title between <title></title> XML tags\\n\\nAssistant:","max_tokens_to_sample":300,"temperature":0.5,"top_k":250,"top_p":1,"stop_sequences":["\\n\\nHuman:"],"anthropic_version":"bedrock-2023-05-31"}'}

3. Con el mensaje definido, ahora puede invocar Amazon Bedrock FM pasando el mensaje al cliente:

response = bedrock_runtime.invoke_model(**kwargs)
response

Debería obtener el siguiente resultado:

{'ResponseMetadata': {'RequestId': '72d2b1c7-cbc8-42ed-9098-2b4eb41cd14e', 'HTTPStatusCode': 200, 'HTTPHeaders': {'date': 'Thu, 17 Oct 2024 15:07:23 GMT', 'content-type': 'application/json', 'content-length': '121', 'connection': 'keep-alive', 'x-amzn-requestid': '72d2b1c7-cbc8-42ed-9098-2b4eb41cd14e', 'x-amzn-bedrock-invocation-latency': '538', 'x-amzn-bedrock-output-token-count': '15', 'x-amzn-bedrock-input-token-count': '100'}, 'RetryAttempts': 0}, 'contentType': 'application/json', 'body': <botocore.response.StreamingBody at 0x1200b5990>}

4. Desempaquete la cadena JSON de la siguiente manera:

response_body = json.loads(response.get('body').read())
response_body

Esto da como resultado el siguiente resultado sobre el título del texto dado.

{'type': 'completion',
'completion': ' <title>A Day at the Beach</title>',
'stop_reason': 'stop_sequence',
'stop': '\n\nHuman:'}

5. Imprimir la finalización:

completion = response_body.get('completion')
completion

Debido a que la respuesta se devuelve en las etiquetas XML tal como las definió, puede consumir la respuesta y mostrarla al cliente.

' <title>A Day at the Beach</title>'

Invocar modelo con código de transmisión

Para ciertos modelos y casos de uso, Amazon Bedrock admite invocaciones de streamingque te permiten interactuar con el modelo en tiempo real. Esto puede resultar especialmente útil para la IA conversacional o aplicaciones interactivas en las que es necesario intercambiar múltiples indicaciones y respuestas con el modelo. Por ejemplo, si le solicita al FM un artículo o una historia, es posible que desee transmitir el resultado del contenido generado.

1. Importe las dependencias y cree el cliente de Amazon Bedrock:

import boto3, json
bedrock_runtime = boto3.client(
service_name="bedrock-runtime",
region_name="us-east-1"
)

2. Defina el mensaje de la siguiente manera:

prompt = "write an article about fictional planet Foobar"

3. Edite la solicitud de API y colóquela en un argumento de palabra clave como antes:
   Usamos la solicitud API del modelo claude-v2.

kwargs = {
  "modelId": "anthropic.claude-v2",
  "contentType": "application/json",
  "accept": "*/*",
  "body": "{\"prompt\":\"\\n\\nHuman: " + prompt + "\\nAssistant:\",\"max_tokens_to_sample\":300,\"temperature\":0.5,\"top_k\":250,\"top_p\":1,\"stop_sequences\":[\"\\n\\nHuman:\"],\"anthropic_version\":\"bedrock-2023-05-31\"}"
}

4. Ahora puede invocar Amazon Bedrock FM pasando el mensaje al cliente:
   Usamos invoke_model_with_response_stream en lugar de invoke_model.

response = bedrock_runtime.invoke_model_with_response_stream(**kwargs)

stream = response.get('body')
if stream:
    for event in stream:
        chunk = event.get('chunk')
        if chunk:
            print(json.loads(chunk.get('bytes')).get('completion'), end="")

Obtendrá una respuesta como la siguiente como salida de transmisión:

Here is a draft article about the fictional planet Foobar: Exploring the Mysteries of Planet Foobar Far off in a distant solar system lies the mysterious planet Foobar. This strange world has confounded scientists and explorers for centuries with its bizarre environments and alien lifeforms. Foobar is slightly larger than Earth and orbits a small, dim red star. From space, the planet appears rusty orange due to its sandy deserts and red rock formations. While the planet looks barren and dry at first glance, it actually contains a diverse array of ecosystems. The poles of Foobar are covered in icy tundra, home to resilient lichen-like plants and furry, six-legged mammals. Moving towards the equator, the tundra slowly gives way to rocky badlands dotted with scrubby vegetation. This arid zone contains ancient dried up riverbeds that point to a once lush environment. The heart of Foobar is dominated by expansive deserts of fine, deep red sand. These deserts experience scorching heat during the day but drop to freezing temperatures at night. Hardy cactus-like plants manage to thrive in this harsh landscape alongside tough reptilian creatures. Oases rich with palm-like trees can occasionally be found tucked away in hidden canyons. Scattered throughout Foobar are pockets of tropical jungles thriving along rivers and wetlands.

Conclusión

En esta publicación, mostramos cómo integrar Amazon Bedrock FM en su base de código. Con Amazon Bedrock, puede utilizar capacidades de IA generativa de última generación sin la necesidad de entrenar modelos personalizados, lo que acelera su proceso de desarrollo y le permite crear aplicaciones potentes con funciones avanzadas de PNL.

Ya sea que esté creando un asistente de IA conversacional, una herramienta de generación de código u otra aplicación que requiera capacidades de PNL, Amazon Bedrock proporciona una solución simple y eficiente. Al utilizar el poder de los FM a través de las API de Amazon Bedrock, puede concentrarse en crear soluciones innovadoras y ofrecer valor a sus usuarios, sin preocuparse por las complejidades subyacentes de los modelos de lenguaje.

A medida que continúa explorando e integrando Amazon Bedrock en sus proyectos, recuerde mantenerse actualizado con las últimas actualizaciones y funciones que ofrece el servicio. Además, considere explorar otros servicios y herramientas de AWS que puedan complementar y mejorar sus aplicaciones impulsadas por IA, como Amazon SageMaker para la capacitación e implementación de modelos de aprendizaje automático, o amazon lex para construir interfaces conversacionales.

Para explorar más a fondo las capacidades de Amazon Bedrock, consulte los siguientes recursos:

Comparta y aprenda con nuestra comunidad de IA generativa en comunidad.aws.

¡Feliz codificación y construcción con Amazon Bedrock!

Acerca de los autores

Rajakumar Sampathkumar es gerente técnico principal de cuentas en AWS y brinda orientación a los clientes sobre la alineación de la tecnología empresarial y respalda la reinvención de sus modelos y procesos operativos en la nube. Le apasiona la nube y el aprendizaje automático. Raj también es especialista en aprendizaje automático y trabaja con clientes de AWS para diseñar, implementar y administrar sus cargas de trabajo y arquitecturas de AWS.

Yadu Kishore Tatavarthi es arquitecto senior de soluciones de socios en Amazon Web Services y brinda soporte a clientes y socios en todo el mundo. Durante los últimos 20 años, ha ayudado a los clientes a crear estrategias de datos empresariales, asesorándolos sobre IA generativa, implementaciones en la nube, migraciones, creación de arquitecturas de referencia, mejores prácticas de modelado de datos y arquitecturas de lago/almacén de datos.