Almacenamiento de datos de Amazon Rekognition con Amazon RDS y DynamoDB - Amazon Rekognition
Requisitos previosCómo obtener etiquetas para imágenes en bucket de Amazon S3Creación de una tabla de Amazon DynamoDBCarga de datos a DynamoDBCreación de una base de datos de MySQL en Amazon RDSCarga de datos a una tabla MySQL de Amazon RDS

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Almacenamiento de datos de Amazon Rekognition con Amazon RDS y DynamoDB

Al utilizar Amazon Rekognition APIs, es importante recordar que las operaciones de la API no guardan ninguna de las etiquetas generadas. Puede guardar estas etiquetas colocándolas en la base de datos, junto con los identificadores de las imágenes respectivas.

En este tutorial se muestra cómo detectar etiquetas y cómo guardarlas en una base de datos. La aplicación de ejemplo desarrollada en este tutorial leerá imágenes de un bucket de Amazon S3, realizará la DetectLabelsoperación en estas imágenes y almacenará las etiquetas resultantes en una base de datos. La aplicación almacenará los datos en una instancia de base de datos de Amazon RDS o en una base de datos de DynamoDB, según el tipo de base de datos que desee utilizar.

Usará el AWS SDK para Python en este tutorial. También puedes consultar el GitHub repositorio de ejemplos del SDK de AWS documentación para ver más tutoriales de Python.

Requisitos previos

Antes de comenzar este tutorial, necesitará instalar Python y completar los pasos necesarios para configurar el AWS SDK de Python. Además de esto, asegúrese de que:

Ha creado una cuenta de AWS y un rol de IAM

Ha instalado el SDK de Python (Boto3)

Has configurado correctamente tus credenciales de AWS acceso

Ha creado un bucket de Amazon S3 y lo ha llenado de imágenes

Ha creado una instancia de base de datos de RDS, si utiliza RDS para almacenar datos

Cómo obtener etiquetas para imágenes en bucket de Amazon S3

Comience por escribir una función que tome el nombre de una imagen de su bucket de Amazon S3 y recupere esa imagen. Esta imagen se mostrará para confirmar que se están transfiriendo las imágenes correctas a una llamada DetectLabelsque también está incluida en la función.

  1. Busque el bucket de Amazon S3 que desee usar y anote su nombre. Realizará llamadas a este bucket de Amazon S3 y leerá las imágenes que contiene. Asegúrese de que su depósito contenga algunas imágenes para pasarlas a la DetectLabelsoperación.

  2. Escriba el código para conectarse a su bucket de Amazon S3. Puede conectarse al recurso de Amazon S3 con Boto3 para recuperar una imagen de un bucket de Amazon S3. Una vez se haya conectado al recurso de Amazon S3, puede acceder a su bucket proporcionando el método del bucket con el nombre de su bucket de Amazon S3. Tras conectarse al bucket de Amazon S3, puede recuperar las imágenes del bucket mediante el método Object. Mediante Matplotlib, puede utilizar esta conexión para visualizar las imágenes a medida que se procesan. Boto3 también se utiliza para conectarse al cliente de Rekognition.

    En el siguiente código, introduzca su región en el parámetro region_name. Pasarás el nombre del bucket de Amazon S3 y el nombre de la imagen a DetectLabels, que devolverá las etiquetas de la imagen correspondiente. Tras seleccionar solo las etiquetas de la respuesta, se devolverán tanto el nombre de la imagen como las etiquetas.

    import boto3
from io import BytesIO
from matplotlib import pyplot as plt
from matplotlib import image as mp_img

boto3 = boto3.Session()

def read_image_from_s3(bucket_name, image_name):

    # Connect to the S3 resource with Boto 3
    # get bucket and find object matching image name
    s3 = boto3.resource('s3')
    bucket = s3.Bucket(name=bucket_name)
    Object = bucket.Object(image_name)

    # Downloading the image for display purposes, not necessary for detection of labels
    # You can comment this code out if you don't want to visualize the images
    file_name = Object.key
    file_stream = BytesIO()
    Object.download_fileobj(file_stream)
    img = mp_img.imread(file_stream, format="jpeg")
    plt.imshow(img)
    plt.show()

    # get the labels for the image by calling DetectLabels from Rekognition
    client = boto3.client('rekognition', region_name="region-name")
    response = client.detect_labels(Image={'S3Object': {'Bucket': bucket_name, 'Name': image_name}},
                                    MaxLabels=10)

    print('Detected labels for ' + image_name)

    full_labels = response['Labels']

    return file_name, full_labels

  3. Guarde este código en un archivo llamado get_images.py.

Creación de una tabla de Amazon DynamoDB

El código siguiente usa Boto3 para conectarse a DynamoDB y usa el método CreateTable de DynamoDB para crear una tabla denominada Images. La tabla tiene una clave primaria compuesta de una clave de partición denominada Image y de una clave de clasificación denominada Labels. La clave Image contiene el nombre de la imagen, mientras que la clave Labels almacena las etiquetas asignadas a esa imagen. 

import boto3

def create_new_table(dynamodb=None):
    dynamodb = boto3.resource(
        'dynamodb',)
    # Table defination
    table = dynamodb.create_table(
        TableName='Images',
        KeySchema=[
            {
                'AttributeName': 'Image',
                'KeyType': 'HASH'  # Partition key
            },
            {
                'AttributeName': 'Labels',
                'KeyType': 'RANGE'  # Sort key
            }
        ],
        AttributeDefinitions=[
            {
                'AttributeName': 'Image',
                'AttributeType': 'S'
            },
            {
                'AttributeName': 'Labels',
                'AttributeType': 'S'
            },
        ],
        ProvisionedThroughput={
            'ReadCapacityUnits': 10,
            'WriteCapacityUnits': 10
        }
    )
    return table

if __name__ == '__main__':
    device_table = create_new_table()
    print("Status:", device_table.table_status)

Guarde este código en un editor y ejecútelo una vez para crear una tabla de DynamoDB.

Carga de datos a DynamoDB

Ahora que se ha creado la base de datos de DynamoDB y tiene una función para obtener etiquetas para las imágenes, puede almacenar las etiquetas en DynamoDB. El siguiente código recupera todas las imágenes de un bucket de S3, obtiene las etiquetas para ellas y almacena los datos en DynamoDB.

  1. Deberá escribir el código para subir los datos en DynamoDB. Se utiliza una función llamada get_image_names para conectarse a su bucket de Amazon S3, que devuelve los nombres de todas las imágenes del bucket en forma de lista. Pasará esta lista a la función read_image_from_S3, que se importará del archivo get_images.py que creó. 

    import boto3
import json
from get_images import read_image_from_s3

boto3 = boto3.Session()

def get_image_names(name_of_bucket):

    s3_resource = boto3.resource('s3')
    my_bucket = s3_resource.Bucket(name_of_bucket)
    file_list = []
    for file in my_bucket.objects.all():
        file_list.append(file.key)
    return file_list

  2. La función read_image_from_S3 que creamos anteriormente devolverá el nombre de la imagen que se está procesando y el diccionario de etiquetas asociadas a esa imagen. Se usa una función llamada find_values para obtener solo las etiquetas de la respuesta. A continuación, el nombre de la imagen y sus etiquetas estarán listos para subirse en la tabla de DynamoDB.

    def find_values(id, json_repr):
    results = []

    def _decode_dict(a_dict):
        try:
            results.append(a_dict[id])
        except KeyError:
            pass
        return a_dict

    json.loads(json_repr, object_hook=_decode_dict) # Return value ignored.
    return results

  3. Utilizará una tercera función, llamada load_data, para subir las imágenes y etiquetas en la tabla de DynamoDB que ha creado.

    def load_data(image_labels, dynamodb=None):

    if not dynamodb:
        dynamodb = boto3.resource('dynamodb')

    table = dynamodb.Table('Images')

    print("Adding image details:", image_labels)
    table.put_item(Item=image_labels)
    print("Success!!")

  4. Aquí es donde se llaman las tres funciones que definimos anteriormente y se llevan a cabo las operaciones. Añada las tres funciones definidas anteriormente, junto con el código siguiente, a un archivo de Python. Ejecute el código. 

    bucket = "bucket_name"
file_list = get_image_names(bucket)

for file in file_list:
    file_name = file
    print("Getting labels for " + file_name)
    image_name, image_labels = read_image_from_s3(bucket, file_name)
    image_json_string = json.dumps(image_labels, indent=4)
    labels=set(find_values("Name", image_json_string))
    print("Labels found: " + str(labels))
    labels_dict = {}
    print("Saving label data to database")
    labels_dict["Image"] = str(image_name)
    labels_dict["Labels"] = str(labels)
    print(labels_dict)
    load_data(labels_dict)
    print("Success!")

Acabas de generar etiquetas para tus imágenes y las has almacenado en una instancia de DynamoDB. DetectLabels Asegúrese de eliminar todos los recursos que ha creado mientras sigue este tutorial. Eso evitará que le cobren por los recursos que no utilice.

Creación de una base de datos de MySQL en Amazon RDS

Antes de continuar, asegúrese de haber completado el procedimiento de configuración de Amazon RDS y de haber creado una instancia de base de datos de MySQL con Amazon RDS.

El siguiente código utiliza la biblioteca PyMySQL y su instancia de base de datos de Amazon RDS. Crea una tabla que contiene los nombres de las imágenes y las etiquetas asociadas a esas imágenes. Amazon RDS recibe comandos para crear tablas e insertar datos en ellas. Para usar Amazon RDS, debe conectarse al host de Amazon RDS con su nombre de host, nombre de usuario y contraseña. Para conectarse a Amazon RDS, debe proporcionar estos argumentos a la connect función de PyMy SQL y crear una instancia de un cursor.

  1. En el siguiente código, sustituya el valor de host por su punto de conexión de host de Amazon RDS y sustituya el valor de user por el nombre de usuario maestro asociado a su instancia de Amazon RDS. También tendrá que reemplazar la contraseña por la contraseña maestra de su usuario principal.

    import pymysql

host = "host-endpoint"
user = "username"
password = "master-password"

  2. Cree una base de datos y una tabla para insertar sus datos de imagen y etiqueta. Para ello, ejecute y confirme una consulta de creación. El siguiente código crea una base de datos. Ejecute este código solo una vez.

    conn = pymysql.connect(host=host, user=user, passwd=password)
print(conn)
cursor = conn.cursor()
print("Connection successful")

# run once
create_query = "create database rekogDB1"
print("Creation successful!")
cursor.execute(create_query)
cursor.connection.commit()

  3. Una vez creada la base de datos, debe crear una tabla en la que insertar los nombres y etiquetas de las imágenes. Para crear una tabla, primero debe pasar el comando use de SQL, junto con el nombre de la base de datos, a la función execute. Una vez realizada la conexión, se ejecuta una consulta para crear una tabla. El siguiente código se conecta a la base de datos y, a continuación, crea una tabla con una clave principal, denominada image_id, y un atributo de texto que almacena las etiquetas. Utilice las importaciones y variables que definió anteriormente y ejecute este código para crear una tabla en la base de datos. 

    # connect to existing DB
cursor.execute("use rekogDB1")
cursor.execute("CREATE TABLE IF NOT EXISTS test_table(image_id VARCHAR (255) PRIMARY KEY, image_labels TEXT)")
conn.commit()
print("Table creation - Successful creation!")

Carga de datos a una tabla MySQL de Amazon RDS

Tras crear la base de datos de Amazon RDS y una tabla en la base de datos, puede obtener etiquetas para sus imágenes y almacenarlas en la base de datos de Amazon RDS.

  1. Conéctese a su bucket de Amazon S3 y recupere los nombres de todas las imágenes del bucket. Estos nombres de imágenes se pasarán a la función read_image_from_s3 que creó anteriormente para obtener las etiquetas de todas sus imágenes. El siguiente código se conecta a su bucket de Amazon S3 y devuelve una lista de todas las imágenes de su bucket.

    import pymysql
from get_images import read_image_from_s3
import json
import boto3

host = "host-endpoint"
user = "username"
password = "master-password"

conn = pymysql.connect(host=host, user=user, passwd=password)
print(conn)
cursor = conn.cursor()
print("Connection successful")

def get_image_names(name_of_bucket):

    s3_resource = boto3.resource('s3')
    my_bucket = s3_resource.Bucket(name_of_bucket)
    file_list = []
    for file in my_bucket.objects.all():
        file_list.append(file.key)
    return file_list

  2. La respuesta de la DetectLabelsAPI contiene algo más que las etiquetas, así que escriba una función para extraer únicamente los valores de las etiquetas. La siguiente función devuelve una lista que únicamente contiene las etiquetas.

    def find_values(id, json_repr):
    results = []

    def _decode_dict(a_dict):
        try:
            results.append(a_dict[id])
        except KeyError:
            pass
        return a_dict

    json.loads(json_repr, object_hook=_decode_dict) # Return value ignored.
    return results

  3. Necesitará una función para insertar los nombres y etiquetas de las imágenes en la tabla. La siguiente función ejecuta una consulta de inserción e inserta cualquier par de nombres y etiquetas de imagen determinados.

    def upload_data(image_id, image_labels):

    # insert into db
    cursor.execute("use rekogDB1")
    query = "INSERT IGNORE INTO test_table(image_id, image_labels) VALUES (%s, %s)"
    values = (image_id, image_labels)
    cursor.execute(query, values)
    conn.commit()
    print("Insert successful!")

  4. Por último, debe ejecutar las funciones que ha definido anteriormente. En el siguiente código, se recopilan los nombres de todas las imágenes del depósito y se proporcionan a la función que las invoca DetectLabels. Después, las etiquetas y el nombre de la imagen a la que se aplican se cargan en la base de datos de Amazon RDS. Copie las tres funciones definidas anteriormente, junto con el código siguiente, a un archivo de Python. Ejecute el archivo Python.

    bucket = "bucket-name"
file_list = get_image_names(bucket)

for file in file_list:
    file_name = file
    print("Getting labels for " + file_name)
    image_name, image_labels = read_image_from_s3(bucket, file_name)
    image_json = json.dumps(image_labels, indent=4)
    labels=set(find_values("Name", image_json))
    print("Labels found: " + str(labels))
    unique_labels=set(find_values("Name", image_json))
    print(unique_labels)
    image_name_string = str(image_name)
    labels_string = str(unique_labels)
    upload_data(image_name_string, labels_string)
    print("Success!")

Ha utilizado DetectLabels correctamente la generación de etiquetas para sus imágenes y las ha almacenado en una base de datos MySQL mediante Amazon RDS. Asegúrese de eliminar todos los recursos que ha creado mientras sigue este tutorial. Esto evitará que le cobren por los recursos que no utilice.

Para ver más ejemplos de AWS varios servicios, consulte el repositorio de ejemplos GitHub del SDK de AWS documentación.